Prova pratica 2014.09.25 - Revision history

FedericoB: Aggiunte soluzioni di altri studenti

2017-05-10T07:35:56Z

Aggiunte soluzioni di altri studenti

FedericoB: Aggiunti soluzioni da altra pagina in modo da uniformare

2017-05-06T15:25:05Z

Aggiunti soluzioni da altra pagina in modo da uniformare

Show changes

LeonardoF at 16:53, 30 April 2017

2017-04-30T16:53:42Z

Show changes

LeonardoF at 16:34, 29 April 2017

2017-04-29T16:34:18Z

LeonardoF at 09:35, 26 April 2017

2017-04-26T09:35:11Z

LeonardoF: Created page with "Testo: [http://http://www.cs.unibo.it/~renzo/so/pratiche/2014.09.25.pdf] Esercizio 2 //ESERCIZIO 2 #include #include #include..."

2017-04-26T09:33:56Z

Created page with "Testo: [http://http://www.cs.unibo.it/~renzo/so/pratiche/2014.09.25.pdf] Esercizio 2 <syntaxhighlight lang="C"> //ESERCIZIO 2 #include <stdio.h> #include <stdlib.h> #include..."

New page

Testo: [http://http://www.cs.unibo.it/~renzo/so/pratiche/2014.09.25.pdf]

Esercizio 2

<syntaxhighlight lang="C">
//ESERCIZIO 2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "execs.h" //https://github.com/rd235/s2argv-execs
#include <fcntl.h>

#define AOI_LENSTEP 8
#define AOS_LENSTEP 8
#define BUFFLEN 256
/*
* Define a struct for managing and array of pointer to strings.
*/
struct array_of_strings {
char **strings;
size_t currentlength; //the length of number of string in memory
size_t arraylength; //the length of memory allocated
};

typedef struct array_of_strings array_of_strings;

void array_of_strings_add(array_of_strings *arrayOfStrings, char *string) {
//if there is not enough space for the string increase it
if (arrayOfStrings->currentlength >= arrayOfStrings->arraylength) {
//increase the array length by the size of a string pointer
size_t newlength = arrayOfStrings->arraylength + AOS_LENSTEP;
//reallocate the arrayOfString with the new size
char **new_string = realloc(arrayOfStrings->strings, newlength * sizeof(arrayOfStrings->strings[0]));
//if the reallocation is successful
if (new_string != NULL) {
arrayOfStrings->arraylength = newlength;
arrayOfStrings->strings = new_string;
}
}
//if there is enough space for the string insert it
if (arrayOfStrings->currentlength < arrayOfStrings->arraylength)
//strdup return a pointer to a duplicate of the string
arrayOfStrings->strings[arrayOfStrings->currentlength++] = strdup(string);
}

void array_of_strings_print(array_of_strings *v) {
size_t i;
for (i = 0; i < v->currentlength; i++)
printf("[%3lu]: %s\n", i, v->strings[i]);
}

//readapting the struct and the functions above to manage integers
//polymorphism?
struct array_of_integers {
int **integers;
size_t currentlength; //the length of number of integers in memory
size_t arraylength; //the length of memory allocated
};

typedef struct array_of_integers array_of_integers;

void array_of_integers_add(array_of_integers *arrayOfIntegers, int val) {

if (arrayOfIntegers->currentlength >= arrayOfIntegers->arraylength) {
size_t newlength = arrayOfIntegers->arraylength + AOI_LENSTEP;
int **new_vec = realloc(arrayOfIntegers->integers, newlength * sizeof(arrayOfIntegers->integers[0]));

if (new_vec != NULL) {
arrayOfIntegers->arraylength = newlength;
arrayOfIntegers->integers = new_vec;
}
}
if (arrayOfIntegers->currentlength < arrayOfIntegers->arraylength)
arrayOfIntegers->integers[arrayOfIntegers->currentlength] = malloc(sizeof(int));
*(arrayOfIntegers->integers[arrayOfIntegers->currentlength++]) = val;

}

void array_of_integers_print(array_of_integers *v) {
size_t i;
for (i = 0; i < v->currentlength; i++)
printf("[%3lu]: %d\n", i, *(v->integers[i]));
}

int main(int argc, char *argv[]) {
/*opening and reading the file*/
int commandNumber= 0;
char* line = NULL;
size_t lineLength = 0;
ssize_t numberOfCharactersRead;
static array_of_strings arrayOfStrings;

FILE* fd1 = fopen(argv[1],"r");

while ((numberOfCharactersRead = getline(&line, &lineLength, fd1)) >= 0) {
if (line[numberOfCharactersRead - 1] == '\n')
line[numberOfCharactersRead - 1] = 0;
array_of_strings_add(&arrayOfStrings, line);
commandNumber ++;
}

free(line);
/*done*/
/* opening output files, forking , saving pids and file descriptors*/
int pid;
int i = 0; //iterator
int fd; //file descriptor
char concat[BUFFLEN];
static array_of_integers arrayOfPid;
static array_of_integers arrayOfFd;

while(commandNumber > 0 ){
sprintf(concat,"./temp%d",i);
fd = open(concat,O_RDWR | O_CREAT | O_TRUNC , 0666);

pid = fork();
switch(pid){
case 0: //children
//children stdio = file fd
dup2(fd,STDOUT_FILENO);
//execution of the command
execsp(arrayOfStrings.strings[i]);
break;
default: //parent
//must save all the pids
array_of_integers_add(&arrayOfPid,pid);
//must save all the fds. ( they will have the same order of the pids);
array_of_integers_add(&arrayOfFd,fd); /*this statement needs to be discussed*/
commandNumber --;
i ++;
break;
}

}
printf("arrayofFd\n");
array_of_integers_print(&arrayOfFd);
/*done*/
/*waiting first process and killing the others*/
int firstpid;
size_t j; //iterator
size_t firstpid_pos; //position of the first pid in the array
//wait the first process
firstpid = wait(NULL);
//printf("%d\n",firstpid );
//sigterm the other processes iterating the pids vector
for (j = 0; j < (&arrayOfPid)->currentlength; j++){
int temp = *((&arrayOfPid)->integers[j]);

if(temp != firstpid)
kill( temp,SIGTERM);
else
firstpid_pos = j ;
}
/*done*/

/*this part needs to be discussed*/
/*printign the file of the "fisrt pid" process , unlinking the file and closing them*/
for (j = 0; j < (&arrayOfFd)->currentlength; j++){
fd = *((&arrayOfFd)->integers[j]);

sprintf(concat,"./temp%lu",j);
if (j == firstpid_pos){
int c;
//FILE *fdp = fdopen(fd,"r");
FILE *fdp = fopen(concat,"r");

while ((c = getc(fdp)) != EOF)
putchar(c);

}

//unlink file fd
unlink(concat);
//close file fd
close(fd);

}
/*done*/

return 0;
}
</syntaxhighlight>

--[[User:LeonardoF|LeonardoF]] ([[User talk:LeonardoF|talk]]) 11:33, 26 April 2017 (CEST)LeonardoF

← Older revision		Revision as of 07:35, 10 May 2017
Line 94:		Line 94:
	}		}

		+	</source>
		+
		+	===Soluzione di Blisset===
		+	<source lang="c">
		+	#include <stdio.h>
		+	#include <stdlib.h>
		+	#include <errno.h>
		+	#include <unistd.h>
		+	#include <s2argv.h>
		+	#include <sys/types.h>
		+	#include <signal.h>
		+
		+	#define MAX 20
		+
		+	int contaRighe (FILE *A){
		+	char *a;
		+	int i=0;
		+	a= malloc (MAX*sizeof(char));
		+
		+	if (a==NULL) {
		+	perror ("malloc");
		+	return -1;
		+	}
		+
		+	while (fgets(a, MAX, A)){
		+	if (a==EOF \|\| a=='\n') break;
		+	i++;
		+	}
		+
		+	return i;
		+	}
		+
		+
		+	int main (int argc, char *argv []){
		+	int status;
		+	int i=0;
		+	int j=0;
		+	int z=0; /indice per ampiezza "pid_t ID" e "char comando"*/
		+	char *comando[z];
		+	pid_t ID [z]; /* memorizza i pid di tutti i processi attivati */
		+	pid_t terminato; /* memorizza il pid del primo processo che termina*/
		+
		+	FILE *fd = fopen (argv[1], "r");
		+
		+	if( fd==NULL ) {
		+	perror("Errore in apertura del file");
		+	return -1;
		+	}
		+
		+	j=contaRighe (fd); /ritorna il numero di righe del file dato in input/
		+	z=j; /* setto gli array con il numero di righe del file contenente i comandi */
		+
		+	rewind(fd); /ritorno all'inizio del file/
		+
		+	/* riempie "comando[z]" con tutti i comandi presenti nel file passato, i comando sono contati da 1 a z. */
		+	while (j!=0){
		+	comando [i] = malloc (MAX*sizeof(char));
		+	fgets(comando [i], MAX, fd);
		+	i++;
		+	j--;
		+	}
		+
		+	i--; /* diminuisco "i" di uno perchè prima di uscire dall'ultimo ciclo è aumentata di uno, "j" è uguale a 0 */
		+
		+	/ESEGUE TUTTI I COMANDI /
		+	while (i>=0){
		+	switch (ID[j]=fork()) {
		+	case 0:
		+	execsp(comando[j]);
		+	perror("exec");
		+	case -1:
		+	perror ("fork");
		+	return -1;
		+	}
		+	i--;
		+	j++;
		+	}
		+
		+	i=0; /setto "i" a 0 per il prossimo while /
		+
		+	terminato=wait(&status);
		+
		+	/* TERMINA TUTTI I PROCESSI */
		+	while(i<j){ /* "i" strettamente minore di "j" poichè nell'ultimo ciclo del precedente while viene incrementata di uno */
		+	if (ID[i]!=terminato) {
		+	printf ("Termina processo %d\n",ID[i]);
		+	kill(ID[i], SIGTERM); /* mando segnale di terminazione a tutti i PID che non sono ancora terminati */
		+	}
		+	else printf ("Processo completato %d\n",ID[i]);
		+	i++;
		+	}
		+
		+	fclose (fd);
		+	return 0;
		+	}
		+	</source>
		+
		+	--[[User:Blissett\|Blissett]] ([[User talk:Blissett\|talk]]) 14:12, 11 March 2015 (CET)
		+	===Soluzione di Luca===
		+	<source lang="c">
		+	#include <stdio.h>
		+	#include <unistd.h>
		+	#include <stdlib.h>
		+	#include <sys/types.h>
		+	#include <sys/wait.h>
		+	#include <s2argv.h>
		+	#include <signal.h>
		+
		+
		+	int main(int argc, char *argv[]){
		+	char buff[256];
		+	int num_cmd=0, tmp=0, i=0, pfd[2];
		+	FILE *file=fopen(argv[1], "r");
		+	while(fgets(buff, sizeof(buff), file)!=NULL){//ottengo numero comandi
		+	num_cmd++;
		+	}
		+	rewind(file);
		+	char cmd[num_cmd][256];
		+	int pid[num_cmd];
		+	pipe(pfd);
		+
		+	for(i=0; i<num_cmd; i++){
		+	fgets(cmd[i], sizeof(cmd[i]), file);
		+	//printf("Comando %d: %s", i, cmd[i]);
		+	switch(pid[i]=fork()){
		+	case 0:
		+	close(pfd[0]);
		+	close(pfd[1]);
		+	execsp(cmd[i]);
		+	exit(1);
		+	case -1: exit(1);
		+	}
		+	}
		+	int status;
		+	close(pfd[0]);
		+	close(pfd[1]);
		+	tmp=wait(&status);
		+	for(i=0; i<num_cmd; i++){
		+	if(tmp==pid[i])
		+	continue;
		+	kill(pid[i], SIGTERM);
		+	printf("terminato il processo: pid[%d]=%d\n", i, pid[i]);
		+	}
		+	fclose(file);
		+	}
	</source>		</source>

← Older revision		Revision as of 09:35, 26 April 2017
Line 1:		Line 1:
−	Testo: [~~http://~~http://www.cs.unibo.it/~renzo/so/pratiche/2014.09.25.pdf]	+	Testo: [http://www.cs.unibo.it/~renzo/so/pratiche/2014.09.25.pdf]

	Esercizio 2		Esercizio 2

@@ Line 120: / Line 120: @@
   			switch(pid){
   				case 0: //children
-                        //children stdio = file fd
+                                        //children stdio = file fd
-                        dup2(fd,STDOUT_FILENO);
+                                        dup2(fd,STDOUT_FILENO);
-						//execution of the command
+				        //execution of the command
 				        execsp(arrayOfStrings.strings[i]);
- 						break;
+ 				        exit(-1); // in case of execsp failure
   				default: //parent
-                        //must save all the pids
+                                         //must save all the pids
-                        array_of_integers_add(&arrayOfPid,pid);
+                                         array_of_integers_add(&arrayOfPid,pid);
-                        //must save all the fds. ( they will have the same order of the pids);
+                                         //must save all the fds. ( they will have the same order of the pids);
-                        array_of_integers_add(&arrayOfFd,fd); /*this statement needs to be discussed*/
+                                          array_of_integers_add(&arrayOfFd,fd);
- 						commandNumber --;
+ 					  commandNumber --;
- 						i ++;
+ 					  i ++;
- 						break;
+ 					  break;
+  			}
@@ Line 157: / Line 157: @@
      /*done*/
-    /*this part needs to be discussed*/
      /*printign the file of the "fisrt pid" process , unlinking the file and closing them*/
      for (j = 0; j < (&arrayOfFd)->currentlength; j++){
@@ Line 165: / Line 165: @@
      	if (j == firstpid_pos){
      		int c;
-     		//FILE *fdp = fdopen(fd,"r");
+     		//lseek is needed because the file is inherited
-    		FILE *fdp = fopen(concat,"r");
+    		lseek(fd,0,SEEK_SET);
      		   while ((c = getc(fdp)) != EOF)
          			putchar(c);