Mauvais descripteur de fichier d'erreur lors de la mise en œuvre de la tuyauterie en C

J'ai pris le paresseux moyen de sortir, et écrit mes propres plutôt que de fixer un autre code. Traiter cela comme "encore un autre tuyau-raccord exemple en C", mais il pourrait aider à préciser les questions avec l'OP du code.

/*
* hard-wired example program exploring how to implement
*
*     system("ls | wc");
*
* using calls to pipe(2), fork(2), execvp(2) and wait(2)
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
static void
do_close(int fd)
{
if (close(fd) == -1) {
perror("close");
exit(1);
}
}
static void
do_execvp(char *const cmd[])
{
execvp(cmd[0], cmd);
/*
* if execvp returns in this text, an error occured.
*/
perror("execvp");
exit(1);
}
static void
dup_and_exec(int fd, int *pp, char *const cmd[])
{
if (dup2(pp[fd], fd) == -1) {
perror("dup2");
exit(1);
}
do_close(pp[0]);
do_close(pp[1]);
do_execvp(cmd);
}
int
main(void)
{
char *const ls_cmd[] = { "ls", 0 };
char *const wc_cmd[] = { "wc", 0 };
int fds[2];
int w_stat;
pid_t ls_pid, wc_pid, w_pid;
/* create a single pipe to connect our writer and reader processes */
if (pipe(fds) == -1) {
perror("pipe");
exit(1);
}
/* create the writer process: ls */
ls_pid = fork();
if (ls_pid == -1) {
perror("fork");
exit(1);
}
if (ls_pid == 0) {
/* this is the child - do the "ls" command */
dup_and_exec(1, fds, ls_cmd);   /* no return from here */
}
/* create the reader process: wc */
wc_pid = fork();
if (wc_pid == -1) {
perror("fork");
exit(1);
}
if (wc_pid == 0) {
/* this is the child - do the "wc" command */
dup_and_exec(0, fds, wc_cmd);   /* no return from here */
}
/* parent process */
/*
* It's important to close the pipe completely in the parent,
* so (in particular) there's no process that could be an
* additional writer to the "write" side of the pipe.
*
* We need to arrange things so that our reader process (the "wc"
* process in this example) will see EOF when the only writer (the
* "ls" process) closes its output and exits.
*
* If this parent process does not close the write side of the pipe,
* it remains open, since it's shared across fork(2), so the reader
* (wc) won't ever see EOF and exit, and this parent process won't
* ever see the wc exit, and everything hangs.
*
* The core problems will have started with the parent, which all
* children know to be true.
*
* The next lines also close the "read" side of the pipe, which
* is a bit cleaner, but won't affect proper operation of this
* sample program. But closing all un-needed file descriptors is
* good hygiene: for longer running applications, or for library
* code that could be called from longer running programs, avoiding
* any leaks of file descriptors is a good thing.
*/
do_close(fds[0]);
do_close(fds[1]);
while ((w_pid = wait(&w_stat)) > 0) {
printf("%s process exited", w_pid == ls_pid ? "ls" : "wc");
if (WIFEXITED(w_stat)) {
printf(" (status %d)", WEXITSTATUS(w_stat));
}
fputs("\n", stdout);
}
if (w_pid == -1 && errno != ECHILD) {
perror("wait");
exit(1);
}
return 0;
}

Il y a quelques problèmes dans votre code:

---

Vous faites un petit-enfant de la première étape du processus

pid=fork();
char *host = "armadillo";
printf("%s%% ", host);
p = parse();
c=p->head;  
printf("1 \n");
pid=fork(); //this fork here is wrong

Vous êtes bifurquer et ensuite bifurquer à nouveau de sorte que le parent d'un enfant, puis deux d'entre eux sont de faire un enfant chacun. À ce stade, vous avez déjà 4 processus.

Votre code pourrait être quelque chose comme cela dans la partie:

pid_t pid;
pid=fork();
char *host = "armadillo";
printf("%s%% ", host);
p = parse();
c=p->head;  
printf("1 \n");
//pid=fork(); //it'll be in another part
if (pid == -1) {
//print error
exit(1);
} else if (pid == 0) {
//child
close(pip[0][0]);
close(STDOUT_FILENO);
dup2(pip[0][1],STDOUT_FILENO);
close(pip[0][1]); //I added this
execvp(c->args[0],c->args);
}
//parent
waitpid(pid,NULL,0); //it's not a good idea but I leave it here
printf("2 \n");
//now you can fork again and use the same pid variable
pid=fork();

---

Vous êtes en attente de l'enfant à la fin.

if(pid==0)
{
close(pip[0][0]);
close(STDOUT_FILENO);
dup2(pip[0][1],STDOUT_FILENO);
execvp(c->args[0],c->args);
}
else
{
waitpid(pid,NULL,0); //you have more commands to execute yet, so you must do it before this
}

Waitpid ne serait pas nécessaire si vous utilisez le processus parent pour exécuter la dernière commande sur le tuyau (wc). Mais c'est à vous, si vous voulez avoir un processus parent. Si oui, vous devez appeler le waitpid une fois que tous les enfants sont de faire ses tâches.

---

Il ne faut pas fermer le tuyau avant dup2..
L'erreur que vous avez posté, qui semble être à cause de cela.

wc: standard input: Bad file descriptor 0 0 0 wc: -: Bad file descriptor

Après dup2, vous devez fermer la conduite de l'enfant.

close(pip[0][0]); //it's ok
close(STDOUT_FILENO); //it's ok but not necessary
dup2(pip[0][1],STDOUT_FILENO);
//here you have to close(pip[0][1]) due to you have already duped it in STDOUT_FILENO
execvp(c->args[0],c->args);

Si vous allez avoir un parent, vous devez le fermer une fois les deux enfants ont dupped il.

printf("2 \n");
close(pip[0][1]); 
close(pip[0][0]); //You're closing the file descriptor which wc needs to read.

---

Vous n'êtes pas la vérification de tous, le retour éventuel état de certaines fonctions.

pipe
fork
execvp
dup2

---

Il y a quelque chose d'autre pour améliorer

int pip[3][2];  //in your case with `int pip[2]` would be enough
pipe(pip[0]);
pipe(pip[1]);  //in your case you have to create just one pipe