[C] Programmazione di Sistema (pipe)

[Savius]

Salve a tutti! ^^
Volevo sapere se qualcuno potrebbe aiutarmi a capire cosa sbaglio nel realizzare programmi che sfruttano le "pipe" per la comunicazione tra processi. Per farvi un esempio vi spiego il seguente programma cosa "dovrebbe" fare:

In pratica si leggono come parametri input 4 nomi di file, rispettivamente:

A.txt (Contenente n parole)
B.txt (Contenente n parole)
AND.txt (vuoto)
OR.txt (vuoto)

Una volta fatto ciò vengono creati due processi figlio che svolgono i seguenti compiti:

Figlio1:
Legge dal file A.txt un carattere alla volta e scrive su una pipe per comunicarlo al Figlio2.

Figlio2:
Legge dalla pipe i caratteri passati dal Figlio1 e confronta ogni parola del file A.txt con quelle presenti in B.txt, il rsultato del confronto viene passato al padre il quale opera in questo modo:

Le parole di A.txt presenti anche in B.txt le scrive nel file AND.txt.

Le parole che non sono presenti nel file B.txt le scrive nel file OR.txt.

Bene... Logicamente ho elaborato un algoritmo che seguisse tutti questi passaggi ma nella pratica non fa quello che deve fare... Ho inserito un printf nel Figlio2 per vedere se almeno concatenava i singoli caratteri in una variabile così da poter ricomporre la parola letta dal file A.txt ma a quanto pare è come se questa si azzerasse ogni volta... Non so se sono riuscito a spiegare bene quel che intendo dire, se c'è qualcuno che mastica un po' di programmazione di sistema mi aiuterebbe non di poco a capire questo e di conseguenza altri problemi legati a tale tipologia di esercizio.

Algoritmo:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<errno.h>
#include<string.h>

#define MAXLINE 100

int main(int argc, char *argv[])
{
	int n,n1,fd[4],fdpipe[2],fdpipeAND[2],fdpipeOR[2];
	pid_t pid1,pid2;
	char parola1[MAXLINE],carattere1[MAXLINE],carattere2[MAXLINE],parola2[MAXLINE];

	// Controllo numero parametri
	if (argc!=5)
	{
		printf("Usage: %s A.txt B.txt AND.txt OR.txt\n",argv[0]);
		exit(1);
	}
	
	// Apertura file A.txt
	if ((fd[0]=open(argv[1],O_RDONLY))<0)
		perror("Errore di apertura file A.txt"), exit(1);
	
	// Creazione pipe
	pipe(fdpipe);
	pipe(fdpipeAND);
	pipe(fdpipeOR);
	

	if ((pid1=fork())<0)
		perror("Errore di creazione Figlio 1."), exit(1);
	else 
		if (pid1==0) // Figlio 1
		{
			while ((n=read(fd[0],carattere1,1))>0)
			{
				close(fdpipe[0]);
				if ((write(fdpipe[1],carattere1,n))!=n)
					perror("Errore di scrittura sulla pipe."), exit(1);
			}
		}
		else
			if ((pid2=fork())<0)
				perror("Errore di creazione figlio2."), exit(1);
			else
				if (pid2==0) // Figlio 2
				{
					close(fdpipe[1]);
					while ((n=read(fdpipe[0],carattere1,1))>0)
					{
						if (carattere1!=" ")
						{strcat(parola1,carattere1);
							printf("parola = %s\n",parola1);}
						else
						{printf("Salto!\n");
							if ((fd[1]=open(argv[2],O_WRONLY))<0)
								perror("Errore di apertura file B.txt"), exit(1);
							while ((n1=read(fd[2],carattere2,1))>0)
							{
								if (carattere2!=" ")
									strcat(parola2,carattere2);
								else
								{
									if ((strcmp(parola1,parola2))==0)
									{
										close(fdpipeAND[0]);
										if ((write(fdpipeAND[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe AND."), exit(1);
									}
									else
									{
										close(fdpipeOR[0]);
										if ((write(fdpipeOR[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe AND."), exit(1);
									}
									strcpy(parola2,"");
								}
							}
							strcpy(parola1,"");
						}
					}
				}
				else
				{
					close(fdpipeAND[1]);
					while ((n=read(fdpipeAND[0],parola1,sizeof(parola1)))>0)
					{
						if ((fd[2]=open(argv[3],O_APPEND))<0)
							perror("Errore di apertura file AND.txt");
						if ((write(fd[2],parola1,n))!=n)
							perror("Errore di scrittura sul file AND.txt"), exit(1);
						close(fd[2]);
					}
					close(fdpipeOR[1]);
					while ((n1=read(fdpipeOR[0],parola2,sizeof(parola2)))>0)
					{
						if ((fd[3]=open(argv[4],O_APPEND))<0)
							perror("Errore di apertura file OR.txt");
						if ((write(fd[3],parola2,n1))!=n1)
							perror("Errore di scrittura sul file AND.txt"), exit(1);
						close(fd[3]);
					}
				}

	return 0;
}

[wingman87]

Mi sembra che non inizializzi parola1 e parola2. Puoi postare i file A.txt e B.txt per provare?
Ma il programma crasha o restituisce risultati sbagliati?

[Savius]

Innanzi tutto, grazie mille per la risposta wingman87! ^^
I file A.txt e B.txt contengono solo una lista di parole tipo:

casa
letto
computer
televisore
cesto

In B.txt ho ripetuto solo un paio di parole esistenti anche nel file A.txt.

Il programma compila e parte l'unica cosa è che ho inserito un printf per vedere se almeno la parola1 si componesse dei caratteri passati dalla pipe e non sembra lo faccia o almeno non come dovrebbe... Anche inizializzando le due stringhe parola1 e parola2, il risultato non cambia.

Ah! Ho notato anche un'altra cosa che proprio non riesco a capire: se aggiungo una variabile nella dichiarazione (tipo che faccio int pippo l'output del programma mi restituisce caratteri strani oltre a quelli letti dal file A.txt... Questo non riesco proprio a concepirlo! Come può una semplice dichiarazione di variabile modificare un ooutput di un programma??? O_O

[wingman87]

Riguardo l'ultima domanda, è perché nella printf viene stampata un'area di memoria sporca,è un caso se già prima non ti venivano caratteri strani, comunque aggiungendo la dichiarazione di una variabile in più probabilmente le è stato riservato uno spazio che precede quello delle altre variabili e quindi l'area di memoria sporca che viene stampata è un po' shiftata.
Ti ho corretto la parte di lettura delle parole, forse ora vorrai andare avanti da solo:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<errno.h>
#include<string.h>

#define MAXLINE 100

int main(int argc, char *argv[])
{
	int n,n1,fd[4],fdpipe[2],fdpipeAND[2],fdpipeOR[2];
	pid_t pid1,pid2;
	char parola1[MAXLINE],carattere1[2],carattere2[2],parola2[MAXLINE];
	strcpy(parola2,"");
	strcpy(parola1,"");

	// Controllo numero parametri
	if (argc!=5)
	{
		printf("Usage: %s A.txt B.txt AND.txt OR.txt\n",argv[0]);
		exit(1);
	}
	
	// Apertura file A.txt
	if ((fd[0]=open(argv[1],O_RDONLY))<0)
		perror("Errore di apertura file A.txt"), exit(1);
	
	// Creazione pipe
	pipe(fdpipe);
	pipe(fdpipeAND);
	pipe(fdpipeOR);
	

	if ((pid1=fork())<0)
		perror("Errore di creazione Figlio 1."), exit(1);
	else 
		if (pid1==0) // Figlio 1
		{
			while ((n=read(fd[0],carattere1,1))>0)
			{
				close(fdpipe[0]);
				if ((write(fdpipe[1],carattere1,n))!=n)
					perror("Errore di scrittura sulla pipe."), exit(1);
			}
		}
		else
			if ((pid2=fork())<0)
				perror("Errore di creazione figlio2."), exit(1);
			else
				if (pid2==0) // Figlio 2
				{
					close(fdpipe[1]);
					while ((n=read(fdpipe[0],carattere1,1))>0)
					{
						if (carattere1[0]!=' ')
						{
							carattere1[1]='\0';
							strcat(parola1,carattere1);
							printf("parola = %s\n",parola1);}
						else
						{printf("Salto!\n");
							if ((fd[1]=open(argv[2],O_WRONLY))<0)
								perror("Errore di apertura file B.txt"), exit(1);
							while ((n1=read(fd[2],carattere2,1))>0)
							{
								if (carattere2[0]!=' '){
									carattere2[1]='\0';
									strcat(parola2,carattere2);
								}
								else
								{
									if ((strcmp(parola1,parola2))==0)
									{
										close(fdpipeAND[0]);
										if ((write(fdpipeAND[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe AND."), exit(1);
									}
									else
									{
										close(fdpipeOR[0]);
										if ((write(fdpipeOR[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe AND."), exit(1);
									}
									strcpy(parola2,"");
								}
							}
							strcpy(parola1,"");
						}
					}
				}
				else
				{
					close(fdpipeAND[1]);
					while ((n=read(fdpipeAND[0],parola1,sizeof(parola1)))>0)
					{
						if ((fd[2]=open(argv[3],O_APPEND))<0)
							perror("Errore di apertura file AND.txt");
						if ((write(fd[2],parola1,n))!=n)
							perror("Errore di scrittura sul file AND.txt"), exit(1);
						close(fd[2]);
					}
					close(fdpipeOR[1]);
					while ((n1=read(fdpipeOR[0],parola2,sizeof(parola2)))>0)
					{
						if ((fd[3]=open(argv[4],O_APPEND))<0)
							perror("Errore di apertura file OR.txt");
						if ((write(fd[3],parola2,n1))!=n1)
							perror("Errore di scrittura sul file AND.txt"), exit(1);
						close(fd[3]);
					}
				}

	return 0;
}

Un'altra cosa: io l'ho testato su un file di testo in cui effettivamente le parole erano separate da spazi, ma se sono come hai scritto nel precedente post dovresti fermare la lettura della parola quando incontri \n e non lo spazio.

[Savius]

Grazie mille per la dritta!!!
Non ci sarei mai arrivato da solo sia per la questione di accesso alla memoria "sporca" sia per la differenza sostanziale che c'è tra i doppi apici ed i singoli... Ho sempre usato i doppi allo stesso modo dei singoli, quelle poche volte che non mi sarà capitato un errore sarà forse dovuto all'utilizzo di un linguaggio di programmazione differente... ^^''
Grazie ancora! Adesso posso continuare a lavorare sulla logica dell'algoritmo, ero davvero arrivato ad un punto morto...

Un'ultima cosa, scusa se ne approfitto, sai per caso dirmi se l'apertura e la chiusura (in scrittura/lettura) di una pipe deve essere speculare anche nel numero di volte? Mi spiego meglio: nel mio caso c'è un while che che ripete il ciclo finché esiste un elemento da leggere nella pipe ma la pipe stessa è chiusa in scrittura fuori dal while quindi lo è una sola volta rispetto a tutte le iterazioni successive del while. La domanda dunque è riferita a questa cosa e cioè se anche la chiusura in scrittura deve essere ripetuta tante volte quanti sono i prelievi del dato da essa. Non so se mi sono spiegato bene, nel caso cerco di spiegarmi meglio... ^^''

Questo credo potrebbe anche spiegare del perché, una volta effettuate queste modifiche, il programma necessiti di una terminazione indotta dall'esterno.

[wingman87]

Originariamente inviato da Savius

Un'ultima cosa, scusa se ne approfitto, sai per caso dirmi se l'apertura e la chiusura (in scrittura/lettura) di una pipe deve essere speculare anche nel numero di volte? Mi spiego meglio: nel mio caso c'è un while che che ripete il ciclo finché esiste un elemento da leggere nella pipe ma la pipe stessa è chiusa in scrittura fuori dal while quindi lo è una sola volta rispetto a tutte le iterazioni successive del while. La domanda dunque è riferita a questa cosa e cioè se anche la chiusura in scrittura deve essere ripetuta tante volte quanti sono i prelievi del dato da essa. Non so se mi sono spiegato bene, nel caso cerco di spiegarmi meglio... ^^''

Questo credo potrebbe anche spiegare del perché, una volta effettuate queste modifiche, il programma necessiti di una terminazione indotta dall'esterno.

In effetti non ho capito molto bene quello che intendi dire, quindi non so se la mia risposta sia inerente.
Con la system call "pipe" hai aggiunto nella UFT 2 entry, una per la lettura dalla pipe e una per la scrittura sulla stessa. Con la system call "close" non fai altro che cancellare una di queste entry (e quindi eliminare uno degli accessi alla pipe).
Quando leggerai dalla pipe ti sarà utile sapere quando non c'è più nulla da leggere (il classico EOF) ma perché il sistema possa assicurarti che non c'è più nulla da leggere devono verificarsi due condizioni: la pipe deve essere vuota e non devono esserci accessi alla pipe in scrittura.
Questo per chiarirti un po' le idee. Ad ogni modo, e qui credo di rispondere alla tua domanda, una lettura tramite uno dei filedescriptor non provoca l'inserimento o il reinserimento di una entry nella UFT (e meno male).

[Savius]

Grazie mille! Sei stato molto chiaro ed esaustivo, il mio dubbio stava proprio nel capire se dovessi aprire e chiudere una pipe (in lettura/scrittura) ogni volta che dovevo effettuare una di queste operazioni o bastava farlo una volta. ^^

[Savius]

Chiedo scusa per il post doppio, volevo solo fare un aggiornamento: Il programma ora funziona, fa quello che dovrebbe fare, solo che sono contretto a terminarlo ogni volta manualmente, qualcuno di voi sa spiegarmi dov'è il possibile intoppo? ^^''

Algoritmo finale:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<errno.h>
#include<string.h>

#define MAXLINE 100

int main(int argc, char *argv[])
{
	int n,n1,fd[4],fdpipe[2],fdpipeAND[2],fdpipeOR[2];
	pid_t pid1,pid2;
	char parola1[MAXLINE],carattere1[2],carattere2[2],parola2[MAXLINE];

	// Controllo numero parametri
	if (argc!=5)
	{
		printf("Usage: %s A.txt B.txt AND.txt OR.txt\n",argv[0]);
		exit(1);
	}
	
	// Apertura file A.txt
	if ((fd[0]=open(argv[1],O_RDONLY))<0)
		perror("Errore di apertura file A.txt"), exit(1);
	
	// Creazione pipe
	pipe(fdpipe);
	pipe(fdpipeAND);
	pipe(fdpipeOR);

	strcpy(parola1,"");
	strcpy(parola2,"");

	if ((pid1=fork())<0)
		perror("Errore di creazione Figlio 1."), exit(1);
	else 
		if (pid1==0) // Figlio 1
		{
			while ((n=read(fd[0],carattere1,1))>0)
			{
				close(fdpipe[0]);
				if ((write(fdpipe[1],carattere1,n))!=n)
					perror("Errore di scrittura sulla pipe."), exit(1);
			}
			close(fd[0]);
		}
		else
			if ((pid2=fork())<0)
				perror("Errore di creazione figlio2."), exit(1);
			else
				if (pid2==0) // Figlio 2
				{
					close(fdpipe[1]);
					while ((n=read(fdpipe[0],carattere1,1))>0)
					{
						if (carattere1[0]!=' ')
						{
							carattere1[1]='\0';
							strcat(parola1,carattere1);
						}
						else
						{
							if ((fd[1]=open(argv[2],O_RDONLY))<0)
								perror("Errore di apertura file B.txt"), exit(1);
							while ((n1=read(fd[1],carattere2,1))>0)
							{
								if (carattere2[0]!=' ')
								{
									carattere2[1]='\0';
									strcat(parola2,carattere2);
								}
								else
								{
									if ((strcmp(parola1,parola2))==0)
									{
										close(fdpipeAND[0]);
										if ((write(fdpipeAND[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe AND."), exit(1);
									}
									else
									{
										close(fdpipeOR[0]);
										if ((write(fdpipeOR[1],parola1,strlen(parola1)))!=strlen(parola1))
											perror("Errore di scrittura sulla pipe OR."), exit(1);
									}
									strcpy(parola2,"");
								}
							}
							close(fd[1]);
							strcpy(parola1,"");
						}
					}
				}
				else
				{
					close(fdpipeAND[1]);
					close(fdpipeOR[1]);
					while (((n=read(fdpipeAND[0],parola1,sizeof(parola1)))>0) && ((n1=read(fdpipeOR[0],parola2,sizeof(parola2)))>0))
					{
						if (parola1!="")
						{
							if ((fd[2]=open(argv[3],O_WRONLY|O_APPEND))<0)
								perror("Errore di apertura file AND.txt");
							if ((write(fd[2],parola1,n))!=n)
								perror("Errore di scrittura sul file AND.txt"), exit(1);
							close(fd[2]);
						}
						if (parola2!="")
						{
							if ((fd[3]=open(argv[4],O_WRONLY|O_APPEND))<0)
								perror("Errore di apertura file OR.txt");
							if ((write(fd[3],parola2,n1))!=n1)
								perror("Errore di scrittura sul file OR.txt"), exit(1);
							close(fd[3]);
						}
					}
				}
	return 0;
}

[wingman87]

Prova a chiudere le pipe anche in scrittura quando hai terminato di scriverci (intendo nei due processi figli).

[Savius]

Grazie per la risposta, ho provato ma non sembrano sortire effetto... ^^''

[wingman87]

EDIT: ho editato perché ho provato la soluzione che avevo scritto ma il problema rimaneva. Alla fine però ho scoperto il vero errore: è un problema di chiusura delle pipe, come dicevo nel precedente post, solo che io stesso correggendo il tuo codice avevo dimenticato qualche chiusura. Quindi ricontrolla meglio. Io avevo dimenticato di chiudere fdpipe[1] nel padre, di conseguenza il ciclo più esterno del figlio 2 non terminava e di conseguenza non venivano eseguite le close che chiudevano fdpipeAND[1] e fdpipeOR[1] che avevo messo alla fine di figlio 2.
Ah e poi in C standard non è possibile confrontare le stringhe con l'operatore di uguaglianza ma bisogna usare strcmp.

[Savius]

Mi è bastato soltato aggingere nel padre la chiusura di fdpipe in scrittura per risolvere il problema. Per quanto riguarda le stringhe questo lo sapevo infatto nell'if del figlio 2 ho sempre usato la funzione strcmp.
Adesso posso finalmente aggiungere un bel RISOLTO nel titolo! Grazie ancora per il tuo aiuto! A buon rendere - se mai avessi bisogno di qualche aiuto dal sottoscritto - anche se credo sia molto difficile che ciò accada (ne sai più di me, almeno in quest'ambito XD).

Sei la dimostrazione lampante che c'è sempre da imparare anche da chi è più giovane di te!

Grazie ancora!

[wingman87]

Originariamente inviato da Savius

Per quanto riguarda le stringhe questo lo sapevo infatto nell'if del figlio 2 ho sempre usato la funzione strcmp.

Mi riferivo a quando nel padre hai usato parola1!="" e parola2!=""

Originariamente inviato da Savius

Grazie ancora!

Di nulla, è stato utile anche a me così ho rivisto un po' di cose che avevo accantonato

[Savius]

Originariamente inviato da wingman87

Mi riferivo a quando nel padre hai usato parola1!="" e parola2!=""

Ah sì! Lì, hai ragione però stranamente non mi dà errori né fa cose diverse da quelle richieste, proverò a cancellare i due if e vedere se funge lo stesso in questo caso. ^^

Originariamente inviato da wingman87

Di nulla, è stato utile anche a me così ho rivisto un po' di cose che avevo accantonato

Mi fa piacere! Pensa che per anni ho usato il TURBO PASCAL e non ho mai approfondito lo studio del C oltre i normali utilizzi universitari... ^^'' Appena riuscirò vedrò di ri-studiarmelo meglio. XD Grazie ancora! ^^