Sistemi Operativi - User contributions [en]

Esercizio 1, prova pratica 20.01.2015

2015-05-25T16:17:20Z

Ale: /* Soluzione di AleZ */

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo.
Questo file contiene due comandi con I rispettivi parametri, uno per riga.
Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi I comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>
==Soluzione di Stefano.zaniboni==
<source lang="c">
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
int mypipe[2];
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;

/*controllo il numero degli argomenti passati*/
if(argc != 2){
fprintf(stderr, "no such arguments \n");
exit(1);
}

/*apro il file in sola lettura*/
stream=fopen(argv[1], "r");
if(stream==NULL){
exit(EXIT_FAILURE);
}

/*apro la pipe*/
if(pipe(mypipe) == -1){
fprintf(stderr, "Error pipe\n");
exit (1);
}

if(fork()==0){
close(1); /*chiudo lo stdout*/
dup(mypipe[1]); /*rimpiazzo lo stdout con la pipe*/
close(mypipe[0]); /*chiudo la read della pipe*/
close(mypipe[1]);

read=getline(&line, &len, stream);

char *lines[2]={line, NULL};
execvp(argv[1], lines);
perror("execvp failed");
exit (1);
}
if(fork()==0){
close(0); /*chiudo lo stdin*/
dup(mypipe[0]); /*rimpiazzo lo stdin con la pipe read*/
close(mypipe[1]); /*chiudo la write della pipe*/
close(mypipe[0]);

read=getline(&line, &len, stream);
execvp(argv[1], &line);
perror("execvp 2 failed");
exit (1);
}
close(mypipe[0]);
close(mypipe[1]);
wait(0);
wait(0);
free(line);
fclose(stream);
exit (0);
}

</source>

Il codice ho provato a testarlo ma la shell mi restituisce sempre su entrambe le exec "Permission Denied".

Nota del Prof: execvp(argv[1], &line) tenta di eseguire il file di testo (argv[1]) [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 16:04, 7 April 2015 (CEST)

==Soluzione di AleZ==
'''Nota''': ho messo la soluzione di questo esercizio solamente perché non ne ho trovata sulla wiki una versione funzionante. Non so se sia stato corretto in classe e/o se sia stato già postato da qualche altra parte. Nel caso mi scuso.

Due versioni: una utilizzando la libreria s2argv e la funzione getline, l'altra senza entrambe.

'''Versione 1 (con s2argv e getline)'''
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "/home/alessandro/Scrivania/s2argv/s2argv.h"

int main(int argc, char *argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

FILE *f;
size_t n;
int fd[2];
char *command = NULL;

f = fopen(argv[1], "rt");

//get first command
getline(&command, &n, f);

//create the pipe
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create child process
switch (fork()) {
case -1:
perror("fork");
break;

case 0: //child process
close(fd[0]);
dup2(fd[1], STDOUT_FILENO); //redirect STDOUT to write to fd[1]->fd[0]
execsp(command);
return(EXIT_FAILURE);

default:
close(fd[1]);
dup2(fd[0], STDIN_FILENO); //redirect STDIN to read from fd[0]<-fd[1]
wait(NULL); //wait for child to terminate
lseek (fd[1], 0, SEEK_SET); //reposition STDOUT read offset to the start
free(command);
command = NULL;
getline(&command, &n, f); //get second command
execsp(command);
return(EXIT_FAILURE);
}
}
</source>

'''Versione 2 (senza s2argv e getline)'''

'''Nota 2''': Nella versione senza s2argv e getline, tutto funziona, però ho un "problema" incredibilmente strano: se cancello la variabile <code>char sono_forse_inutile[4096]</code> dichiarata a riga 48, a run-time il programma restituisce segmentation fault. Quella variabile era stata introdotta in precedenza inizialmente per diversa scelta implementativa, e in seguito mantenuta per scopi di debug. Terminata la sua utilità, avevo pensato di rimuoverla, ma a quanto pare non mi è permesso, e il motivo mi sfugge davvero.

La funzione fsplit è stata realizzata prendendo largamente spunto da un'altra funzione trovata su stackoverflow.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>

char **fsplit(char **res, char str[]) {
char *p = strtok(str, " ");
int n_spaces = 0;

/* split string and append tokens to "res" */

while (p) {
n_spaces++;
res = realloc(res, sizeof(char*) * n_spaces);
if (res == NULL)
exit(EXIT_FAILURE); //allocation failed
res[n_spaces - 1] = p;
p = strtok(NULL, " ");
}

/* realloc one extra element for the last NULL */

res = realloc(res, sizeof(char*) * (n_spaces + 1));
res[n_spaces] = NULL;

// debug purpose
/* int i;
for (i = 0; i < (n_spaces + 1); i++) {
printf ("res[%d] = %s\n", i, res[i]);
}*/

return res;
}

int main (int argc, char* argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

char *pathname = argv[1];
FILE *f;
struct stat f_info;
char command_one[100], command_two[100], sono_forse_inutile[4096];
int fd[2], file_desc_out;
pid_t pid;

f = fopen(pathname, "rt");

//check if file exists
if(lstat(pathname, &f_info) == -1) {
perror("stat");
return(EXIT_FAILURE);
}

//read the commands from the first two lines - ignore the other lines
if ( (fgets(command_one, 100, f) == NULL) ||
(fgets(command_two, 100, f) == NULL) ) {
fprintf(stderr, "Error while reading text from %s.", argv[1]);
}

fclose(f);

//remove the \n patterns from the command strings
strtok(command_one, "\n");
strtok(command_two, "\n");

/*split the command strings in arrays, where
- comm[0] is the command
- comm[1], comm[2], etc, are the arguments*/

char **commv_1 = fsplit(commv_1, command_one);
char **commv_2 = fsplit(commv_2, command_two);

//create the pipe
//remember: fd[0] reads and fd[1] writes
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create the child and get its pid
if ( (pid = fork()) == -1) {
perror("fork");
return(EXIT_FAILURE);
}

if (pid == 0) { //child
dup2(fd[1], STDOUT_FILENO); //connect pipe from execvp to standard output
close(fd[0]); //close read side from parent
execvp(commv_1[0], commv_1);
perror(commv_1[0]);
return(EXIT_FAILURE);
} else {
close(fd[1]); //close write side from child
dup2(fd[0], file_desc_out);
char *path;

// obtain absolute path of the reader-side file descriptor of the pipe
realpath("/proc/self/fd/file_desc_out", path);

commv_2[1] = path; //set the obtained path as argument for command 2
wait(NULL); //wait for child to terminate
}

execvp(commv_2[0], commv_2);
perror(commv_2[0]);
return(EXIT_FAILURE);
}</source>
--[[User:Ale|Ale]] ([[User talk:Ale|talk]]) 14:01, 25 May 2015 (CEST)

Esercizio 1, prova pratica 20.01.2015

2015-05-25T16:14:41Z

Ale: /* Soluzione di AleZ */

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo.
Questo file contiene due comandi con I rispettivi parametri, uno per riga.
Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi I comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>
==Soluzione di Stefano.zaniboni==
<source lang="c">
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
int mypipe[2];
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;

/*controllo il numero degli argomenti passati*/
if(argc != 2){
fprintf(stderr, "no such arguments \n");
exit(1);
}

/*apro il file in sola lettura*/
stream=fopen(argv[1], "r");
if(stream==NULL){
exit(EXIT_FAILURE);
}

/*apro la pipe*/
if(pipe(mypipe) == -1){
fprintf(stderr, "Error pipe\n");
exit (1);
}

if(fork()==0){
close(1); /*chiudo lo stdout*/
dup(mypipe[1]); /*rimpiazzo lo stdout con la pipe*/
close(mypipe[0]); /*chiudo la read della pipe*/
close(mypipe[1]);

read=getline(&line, &len, stream);

char *lines[2]={line, NULL};
execvp(argv[1], lines);
perror("execvp failed");
exit (1);
}
if(fork()==0){
close(0); /*chiudo lo stdin*/
dup(mypipe[0]); /*rimpiazzo lo stdin con la pipe read*/
close(mypipe[1]); /*chiudo la write della pipe*/
close(mypipe[0]);

read=getline(&line, &len, stream);
execvp(argv[1], &line);
perror("execvp 2 failed");
exit (1);
}
close(mypipe[0]);
close(mypipe[1]);
wait(0);
wait(0);
free(line);
fclose(stream);
exit (0);
}

</source>

Il codice ho provato a testarlo ma la shell mi restituisce sempre su entrambe le exec "Permission Denied".

Nota del Prof: execvp(argv[1], &line) tenta di eseguire il file di testo (argv[1]) [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 16:04, 7 April 2015 (CEST)

==Soluzione di AleZ==
'''Nota''': ho messo la soluzione di questo esercizio solamente perché non ne ho trovata sulla wiki una versione funzionante. Non so se sia stato corretto in classe e/o se sia stato già postato da qualche altra parte. Nel caso mi scuso.

Due versioni: una utilizzando la libreria s2argv e la funzione getline, l'altra senza entrambe.

'''Versione 1 (con s2argv e getline)'''
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "/home/alessandro/Scrivania/s2argv/s2argv.h"

int main(int argc, char *argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

FILE *f;
size_t n;
int fd[2];
char *command = NULL;

f = fopen(argv[1], "rt");

//get first command
getline(&command, &n, f);

//create the pipe
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create child process
switch (fork()) {
case -1:
perror("fork");
break;

case 0: //child process
close(fd[0]);
dup2(fd[1], STDOUT_FILENO); //redirect STDOUT to write to fd[1]->fd[0]
execsp(command);
exit(1);

default:
close(fd[1]);
dup2(fd[0], STDIN_FILENO); //redirect STDIN to read from fd[0]<-fd[1]
wait(NULL); //wait for child to terminate
lseek (fd[1], 0, SEEK_SET); //reposition STDOUT read offset to the start
free(command);
command = NULL;
getline(&command, &n, f); //get second command
execsp(command);
exit(1);
}
}
</source>

'''Versione 2 (senza s2argv e getline)'''

'''Nota 2''': Nella versione senza s2argv e getline, tutto funziona, però ho un "problema" incredibilmente strano: se cancello la variabile <code>char sono_forse_inutile[4096]</code> dichiarata a riga 48, a run-time il programma restituisce segmentation fault. Quella variabile era stata introdotta in precedenza inizialmente per diversa scelta implementativa, e in seguito mantenuta per scopi di debug. Terminata la sua utilità, avevo pensato di rimuoverla, ma a quanto pare non mi è permesso, e il motivo mi sfugge davvero.

La funzione fsplit è stata realizzata prendendo largamente spunto da un'altra funzione trovata su stackoverflow.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>

char **fsplit(char **res, char str[]) {
char *p = strtok(str, " ");
int n_spaces = 0;

/* split string and append tokens to "res" */

while (p) {
n_spaces++;
res = realloc(res, sizeof(char*) * n_spaces);
if (res == NULL)
exit(EXIT_FAILURE); //allocation failed
res[n_spaces - 1] = p;
p = strtok(NULL, " ");
}

/* realloc one extra element for the last NULL */

res = realloc(res, sizeof(char*) * (n_spaces + 1));
res[n_spaces] = NULL;

// debug purpose
/* int i;
for (i = 0; i < (n_spaces + 1); i++) {
printf ("res[%d] = %s\n", i, res[i]);
}*/

return res;
}

int main (int argc, char* argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

char *pathname = argv[1];
FILE *f;
struct stat f_info;
char command_one[100], command_two[100], sono_forse_inutile[4096];
int fd[2], file_desc_out;
pid_t pid;

f = fopen(pathname, "rt");

//check if file exists
if(lstat(pathname, &f_info) == -1) {
perror("stat");
return(EXIT_FAILURE);
}

//read the commands from the first two lines - ignore the other lines
if ( (fgets(command_one, 100, f) == NULL) ||
(fgets(command_two, 100, f) == NULL) ) {
fprintf(stderr, "Error while reading text from %s.", argv[1]);
}

fclose(f);

//remove the \n patterns from the command strings
strtok(command_one, "\n");
strtok(command_two, "\n");

/*split the command strings in arrays, where
- comm[0] is the command
- comm[1], comm[2], etc, are the arguments*/

char **commv_1 = fsplit(commv_1, command_one);
char **commv_2 = fsplit(commv_2, command_two);

//create the pipe
//remember: fd[0] reads and fd[1] writes
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create the child and get its pid
if ( (pid = fork()) == -1) {
perror("fork");
return(EXIT_FAILURE);
}

if (pid == 0) { //child
dup2(fd[1], STDOUT_FILENO); //connect pipe from execvp to standard output
close(fd[0]); //close read side from parent
execvp(commv_1[0], commv_1);
perror(commv_1[0]);
return(EXIT_FAILURE);
} else {
close(fd[1]); //close write side from child
dup2(fd[0], file_desc_out);
char *path;

// obtain absolute path of the reader-side file descriptor of the pipe
realpath("/proc/self/fd/file_desc_out", path);

commv_2[1] = path; //set the obtained path as argument for command 2
wait(NULL); //wait for child to terminate
}

execvp(commv_2[0], commv_2);
perror(commv_2[0]);
return(EXIT_FAILURE);
}</source>
--[[User:Ale|Ale]] ([[User talk:Ale|talk]]) 14:01, 25 May 2015 (CEST)

Esercizio 1, prova pratica 20.01.2015

2015-05-25T13:55:56Z

Ale: /* Soluzione di AleZ */

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo.
Questo file contiene due comandi con I rispettivi parametri, uno per riga.
Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi I comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>
==Soluzione di Stefano.zaniboni==
<source lang="c">
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
int mypipe[2];
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;

/*controllo il numero degli argomenti passati*/
if(argc != 2){
fprintf(stderr, "no such arguments \n");
exit(1);
}

/*apro il file in sola lettura*/
stream=fopen(argv[1], "r");
if(stream==NULL){
exit(EXIT_FAILURE);
}

/*apro la pipe*/
if(pipe(mypipe) == -1){
fprintf(stderr, "Error pipe\n");
exit (1);
}

if(fork()==0){
close(1); /*chiudo lo stdout*/
dup(mypipe[1]); /*rimpiazzo lo stdout con la pipe*/
close(mypipe[0]); /*chiudo la read della pipe*/
close(mypipe[1]);

read=getline(&line, &len, stream);

char *lines[2]={line, NULL};
execvp(argv[1], lines);
perror("execvp failed");
exit (1);
}
if(fork()==0){
close(0); /*chiudo lo stdin*/
dup(mypipe[0]); /*rimpiazzo lo stdin con la pipe read*/
close(mypipe[1]); /*chiudo la write della pipe*/
close(mypipe[0]);

read=getline(&line, &len, stream);
execvp(argv[1], &line);
perror("execvp 2 failed");
exit (1);
}
close(mypipe[0]);
close(mypipe[1]);
wait(0);
wait(0);
free(line);
fclose(stream);
exit (0);
}

</source>

Il codice ho provato a testarlo ma la shell mi restituisce sempre su entrambe le exec "Permission Denied".

Nota del Prof: execvp(argv[1], &line) tenta di eseguire il file di testo (argv[1]) [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 16:04, 7 April 2015 (CEST)

==Soluzione di AleZ==
'''Nota''': ho messo la soluzione di questo esercizio solamente perché non ne ho trovata sulla wiki una versione funzionante. Non so se sia stato corretto in classe e/o se sia stato già postato da qualche altra parte. Nel caso mi scuso.

'''Nota 2''': La mia versione dovrebbe funzionare, però ho un "problema" incredibilmente strano: se cancello la variabile <code>char sono_forse_inutile[4096]</code> dichiarata a riga 48, a run-time il programma restituisce segmentation fault. Quella variabile era stata introdotta in precedenza inizialmente per diversa scelta implementativa, e in seguito mantenuta per scopi di debug. Terminata la sua utilità, avevo pensato di rimuoverla, ma a quanto pare non mi è permesso, e il motivo mi sfugge davvero.

La funzione fsplit è stata realizzata prendendo largamente spunto da un'altra funzione trovata su stackoverflow.

Ho cercato di non usare la libreria s2argv (ovviamente complicandomi la vita).

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>

char **fsplit(char **res, char str[]) {
char *p = strtok(str, " ");
int n_spaces = 0;

/* split string and append tokens to "res" */

while (p) {
n_spaces++;
res = realloc(res, sizeof(char*) * n_spaces);
if (res == NULL)
exit(EXIT_FAILURE); //allocation failed
res[n_spaces - 1] = p;
p = strtok(NULL, " ");
}

/* realloc one extra element for the last NULL */

res = realloc(res, sizeof(char*) * (n_spaces + 1));
res[n_spaces] = NULL;

// debug purpose
/* int i;
for (i = 0; i < (n_spaces + 1); i++) {
printf ("res[%d] = %s\n", i, res[i]);
}*/

return res;
}

int main (int argc, char* argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

char *pathname = argv[1];
FILE *f;
struct stat f_info;
char command_one[100], command_two[100], sono_forse_inutile[4096];
int fd[2], file_desc_out;
pid_t pid;

f = fopen(pathname, "rt");

//check if file exists
if(lstat(pathname, &f_info) == -1) {
perror("stat");
return(EXIT_FAILURE);
}

//read the commands from the first two lines - ignore the other lines
if ( (fgets(command_one, 100, f) == NULL) ||
(fgets(command_two, 100, f) == NULL) ) {
fprintf(stderr, "Error while reading text from %s.", argv[1]);
}

fclose(f);

//remove the \n patterns from the command strings
strtok(command_one, "\n");
strtok(command_two, "\n");

/*split the command strings in arrays, where
- comm[0] is the command
- comm[1], comm[2], etc, are the arguments*/

char **commv_1 = fsplit(commv_1, command_one);
char **commv_2 = fsplit(commv_2, command_two);

//create the pipe
//remember: fd[0] reads and fd[1] writes
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create the child and get its pid
if ( (pid = fork()) == -1) {
perror("fork");
return(EXIT_FAILURE);
}

if (pid == 0) { //child
dup2(fd[1], STDOUT_FILENO); //connect pipe from execvp to standard output
close(fd[0]); //close read side from parent
execvp(commv_1[0], commv_1);
perror(commv_1[0]);
return(EXIT_FAILURE);
} else {
close(fd[1]); //close write side from child
dup2(fd[0], file_desc_out);
char *path;

// obtain absolute path of the reader-side file descriptor of the pipe
realpath("/proc/self/fd/file_desc_out", path);

commv_2[1] = path; //set the obtained path as argument for command 2
wait(NULL); //wait for child to terminate
}

execvp(commv_2[0], commv_2);
perror(commv_2[0]);
return(EXIT_FAILURE);
}</source>
--[[User:Ale|Ale]] ([[User talk:Ale|talk]]) 14:01, 25 May 2015 (CEST)

Esercizio 1, prova pratica 20.01.2015

2015-05-25T12:01:26Z

Ale:

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo.
Questo file contiene due comandi con I rispettivi parametri, uno per riga.
Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi I comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>
==Soluzione di Stefano.zaniboni==
<source lang="c">
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
int mypipe[2];
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;

/*controllo il numero degli argomenti passati*/
if(argc != 2){
fprintf(stderr, "no such arguments \n");
exit(1);
}

/*apro il file in sola lettura*/
stream=fopen(argv[1], "r");
if(stream==NULL){
exit(EXIT_FAILURE);
}

/*apro la pipe*/
if(pipe(mypipe) == -1){
fprintf(stderr, "Error pipe\n");
exit (1);
}

if(fork()==0){
close(1); /*chiudo lo stdout*/
dup(mypipe[1]); /*rimpiazzo lo stdout con la pipe*/
close(mypipe[0]); /*chiudo la read della pipe*/
close(mypipe[1]);

read=getline(&line, &len, stream);

char *lines[2]={line, NULL};
execvp(argv[1], lines);
perror("execvp failed");
exit (1);
}
if(fork()==0){
close(0); /*chiudo lo stdin*/
dup(mypipe[0]); /*rimpiazzo lo stdin con la pipe read*/
close(mypipe[1]); /*chiudo la write della pipe*/
close(mypipe[0]);

read=getline(&line, &len, stream);
execvp(argv[1], &line);
perror("execvp 2 failed");
exit (1);
}
close(mypipe[0]);
close(mypipe[1]);
wait(0);
wait(0);
free(line);
fclose(stream);
exit (0);
}

</source>

Il codice ho provato a testarlo ma la shell mi restituisce sempre su entrambe le exec "Permission Denied".

Nota del Prof: execvp(argv[1], &line) tenta di eseguire il file di testo (argv[1]) [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 16:04, 7 April 2015 (CEST)

==Soluzione di AleZ==
'''Nota''': ho messo la soluzione di questo esercizio solamente perché non ne ho trovata sulla wiki una versione funzionante. Non so se sia stato corretto in classe e/o se sia stato già postato da qualche altra parte. Nel caso mi scuso.

'''Nota 2''': La mia versione dovrebbe funzionare, però ho un "problema" incredibilmente strano: se cancello la variabile <code>char sono_forse_inutile[4096]</code> dichiarata a riga 48, a run-time il programma restituisce segmentation fault. Quella variabile era stata introdotta in precedenza inizialmente per diversa scelta implementativa, e in seguito mantenuta per scopi di debug. Terminata la sua utilità, avevo pensato di rimuoverla, ma a quanto pare non mi è permesso, e il motivo mi sfugge davvero.

La funzione fsplit è stata realizzata prendendo largamente spunto da un'altra funzione trovata su stackoverflow.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>

char **fsplit(char **res, char str[]) {
char *p = strtok(str, " ");
int n_spaces = 0;

/* split string and append tokens to "res" */

while (p) {
n_spaces++;
res = realloc(res, sizeof(char*) * n_spaces);
if (res == NULL)
exit(EXIT_FAILURE); //allocation failed
res[n_spaces - 1] = p;
p = strtok(NULL, " ");
}

/* realloc one extra element for the last NULL */

res = realloc(res, sizeof(char*) * (n_spaces + 1));
res[n_spaces] = NULL;

// debug purpose
/* int i;
for (i = 0; i < (n_spaces + 1); i++) {
printf ("res[%d] = %s\n", i, res[i]);
}*/

return res;
}

int main (int argc, char* argv[]) {
//check arguments
if (argc != 2) {
fprintf(stderr, "Error: Expected 1 parameter.\n"
"Usage: %s <pathname>\n", argv[0]);
return(EXIT_FAILURE);
}

char *pathname = argv[1];
FILE *f;
struct stat f_info;
char command_one[100], command_two[100], sono_forse_inutile[4096];
int fd[2], file_desc_out;
pid_t pid;

f = fopen(pathname, "rt");

//check if file exists
if(lstat(pathname, &f_info) == -1) {
perror("stat");
return(EXIT_FAILURE);
}

//read the commands from the first two lines - ignore the other lines
if ( (fgets(command_one, 100, f) == NULL) ||
(fgets(command_two, 100, f) == NULL) ) {
fprintf(stderr, "Error while reading text from %s.", argv[1]);
}

fclose(f);

//remove the \n patterns from the command strings
strtok(command_one, "\n");
strtok(command_two, "\n");

/*split the command strings in arrays, where
- comm[0] is the command
- comm[1], comm[2], etc, are the arguments*/

char **commv_1 = fsplit(commv_1, command_one);
char **commv_2 = fsplit(commv_2, command_two);

//create the pipe
//remember: fd[0] reads and fd[1] writes
if (pipe(fd) == -1) {
perror("pipe");
return(EXIT_FAILURE);
}

//create the child and get its pid
if ( (pid = fork()) == -1) {
perror("fork");
return(EXIT_FAILURE);
}

if (pid == 0) { //child
dup2(fd[1], STDOUT_FILENO); //connect pipe from execvp to standard output
close(fd[0]); //close read side from parent
execvp(commv_1[0], commv_1);
perror(commv_1[0]);
return(EXIT_FAILURE);
} else {
close(fd[1]); //close write side from child
dup2(fd[0], file_desc_out);
char *path;

// obtain absolute path of the reader-side file descriptor of the pipe
realpath("/proc/self/fd/file_desc_out", path);

commv_2[1] = path; //set the obtained path as argument for command 2
wait(NULL); //wait for child to terminate
}

execvp(commv_2[0], commv_2);
perror(commv_2[0]);
return(EXIT_FAILURE);
}</source>
--[[User:Ale|Ale]] ([[User talk:Ale|talk]]) 14:01, 25 May 2015 (CEST)

Esercizio 1, prova pratica 12/02/2009

2014-12-01T19:39:04Z

Ale:

Ho provato a svolgere l'esercizio 1 dell'esame di laboratorio del 2 febbraio 2009 ([http://www.cs.unibo.it/~renzo/so/pratiche/2009.02.12.pdf]).

Consegna:
<source lang="text">
Esercizio1 (obbligatorio): (10 punti)
Scrivere un programma C denominato “invarg” che esegua il programma passato come parametro invertendo gli argomenti.
Esempio:
invarg cat a b c
deve avere l'effetto di
cat c b a
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(int argc , char* argv[]){
char *nargv[argc-1] ; /*nargv è il vettore degli argomenti da passare al programma da eseguire*/
int i , j ; /*puntatori che scorrono, rispettivamente, argv ed nargv per riempire correttamente nargv*/
nargv[0] = argv[1] ; /*il primo valore di nargv deve essere il programma chiamato, l'ultimo deve essere NULL*/
nargv[argc-1] = NULL ;
for( i = argc - 1 , j = 1 ; i > 1 , j < (argc - 1) ; i-- , j++ ) nargv[j] = argv[i] ; /*metto in nargv (dal secondo elemento in poi) gli argomenti presenti
in argv in ordine invertito*/
execvp( nargv[0] , nargv ) ; /*eseguo il programma (il cui nome è contenuto in nargv[0]) passandogli nargv come vettore di parametri*/
fprintf( stderr , "programma errato\n" ) ; /*se ci troviamo in questo punto significa che la chiamata a execvp è fallita, probabilmente
perchè il programma indicato non è stato trovato*/
exit(1) ;
}
</source>

==Soluzione di Eddy==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

void scambia_ordine(int argc, char **argv, int j);

int main(int argc , char* argv[])
{
if (argc < 2) return 2;
argv++; argc--;
scambia_ordine(argc, argv, 1);
execvp(argv[0], argv);
perror("execvp");
return 3;
}

/* piccola funzione ricorsiva che:
* -memorizza in tmp gli argomenti dalla fine
* -assegna ad argv in ordine inverso
*
* non scambia il primo argomento
*/
void scambia_ordine(int argc, char **argv, int j)
{
char *tmp;
if (argc > 1){
tmp = argv[argc-1];
scambia_ordine (argc-1, argv, j+1);
argv[j]=tmp;
}

}
</source>
[[User:Eddy|Eddy]] ([[User talk:Eddy|talk]]) 21:00 Saturday, 22 November 2014 (CET)

==Soluzione di GFede==
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void scambia(int offset, int argc, char* argv[]);

int main(int argc, char* argv[])
{
if(argc <= 1)
{
printf("Usage: invarg.exe command [arguments...]\n");
return 2;
}
scambia(2, argc - 1, argv);

execvp(argv[1], argv + 1);
perror("execvp");
return 1;
}

/**
* Scambia le stringhe all'interno dell'array
* void scambia
* int offset Indice da cui iniziare a scambiare
* int argc Numero di valori nell'array (Compreso l'offset)
* char* argv[] array di stringhe da scambiare
*/
void scambia(int offset, int argc, char* argv[])
{
int i;
char* tmp;
for( i = offset; i < argc - i + offset; i++ )
{
tmp = argv[i];
argv[i] = argv[argc - i + offset];
argv[argc - i + offset] = tmp;
}
}
</source>

==Soluzione di LorenzoV==
<source lang="c">
#include <stdlib.h>
#include <stdio.h>

void swap(char **p, char **q){ // La swap modifica solo i puntatori
char *tmp;
tmp=*p;
*p=*q;
*q=tmp;
}

int main(int argc, char* argv[]){
char **begin, **end;
if (argc<3){
fprintf(stderr, "Usage:\n\t%s command ...arguments...\n", argv[0]);
exit(1);
}
begin=argv+2;
end=argv+argc-1;
while (begin<end){ // Inverte i parametri passati al comando
swap(begin, end);
begin++;
end--;
}
execvp(argv[1], argv+1);
return 0;
}
</source>
--[[User:LorenzoV|LorenzoV]] ([[User talk:LorenzoV|talk]]) 18:35, 25 November 2014 (CET)

==Soluzione di BoldrinD==
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void invarg(int Qparametri, char* Rargv[], char* argv[]);

int main(int argc, char* argv[]){
int Qparametri=argc-1;
char *Rargv[Qparametri];
invarg(Qparametri, Rargv, argv);
printf("%s\n","il nuovo vettore dei parametri è stato creato con successo");
execvp(Rargv[0], Rargv);
perror("execvp");
return 1;

}

void invarg(int Qparametri, char* Rargv[], char* argv[]){
Rargv[0]=argv[1];
Rargv[Qparametri]=NULL;
int i=2;
while(argv[i]!=NULL){
Rargv[Qparametri-1]=(argv[i]);
i++;
Qparametri--;
}

}
</source>

==Soluzione di AleZ==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>

int main (int argc, char* argv[]) {
if (argc == 1) { // Non è stato passato alcun comando per la execvp
fprintf(stderr, "Error: Segmentation fault\nUsage: [command] [arguments...]\n");
return(EXIT_FAILURE);
}
char* tmp[argc]; // vettore che conterrà gli argomenti scambiati
int i = 0;
tmp[0] = argv[1]; // per convenzione il primo argomento è il programma chiamato
tmp[argc-1] = (char*)NULL; // come da manuale
for (i = argc-2; i > 0; i--) tmp[i] = argv[(argc-i)]; // inverto gli argomenti
execvp(tmp[0], tmp);
fprintf(stderr, "%s: command not found\n", argv[1]); //execvp ha fallito
return(EXIT_FAILURE);
}
</source>
--[[User:Ale|Ale]] ([[User talk:Ale|talk]]) 20:39, 1 December 2014 (CET)