L'écriture de mon propre coquille... coincé sur des tuyaux?

Première suggestion: constantes Symboliques sont mieux que des numéros de magie.

const int PIPE_READ = 0;
const int PIPE_WRITE = 1;
int fd[2];
pipe(fd);
//Now you can refer to fd[PIPE_READ] and fd[PIPE_WRITE].

Deuxième suggestion: Prendre du recul et de réfléchir à ce que vous essayez d'accomplir.

Vous voulez lancer deux processus, avec le premier processus de la sortie standard (stdout) connecté à la deuxième processus de stdin. Droit?

Donc, en C, cela signifie que vous avez besoin de prendre l'appel pipe, passer fd[PIPE_WRITE] pour le premier enfant, qui va dup2 à 1, et de passer fd[PIPE_READ] pour le deuxième enfant, qui va dup2 à 0.

Simplement en regardant forkAndExecute's prototype montre qu'il ne peut pas le faire:

void forkAndExecute( char* arrayOfWords[] , vector *vectorOfPIDs , 
    bool hasNextCmd , bool hasPrevCmd);

Il ne gère qu'une seule commande, et de l'examen que de la liste d'arguments, à moins qu'il recourt à mal les variables globales, il n'y a aucun moyen pour elle de recevoir un descripteur de fichier à partir de son PrevCmd ou de recevoir un descripteur de fichier à partir de son NextCmd.

Réfléchir à la façon de gérer les descripteurs de fichier que vous avez besoin, et la refonte forkAndExecute pour être en mesure d'utiliser ces.

OriginalL'auteur

ok C'est de travailler pour moi. Espérons que cela vous aide:

/************************
function: void pipeCommand(char** cmd1, char** cmd2)
comment: This pipes the output of cmd1 into cmd2.
**************************/
void pipeCommand(char** cmd1, char** cmd2) {
  int fds[2]; //file descriptors
  pipe(fds);
  //child process #1
  if (fork() == 0) {
    //Reassign stdin to fds[0] end of pipe.
    dup2(fds[0], STDIN_FILENO);
    close(fds[1]);
    close(fds[0]);
    //Execute the second command.
    //child process #2
    if (fork() == 0) {
        //Reassign stdout to fds[1] end of pipe.
        dup2(fds[1], STDOUT_FILENO);
        close(fds[0]);
        close(fds[1]);
        //Execute the first command.
        execvp(cmd1[0], cmd1);
    }
    wait(NULL);
    execvp(cmd2[0], cmd2);
    }
    close(fds[1]);
    close(fds[0]);
    wait(NULL);
}

OriginalL'auteur

Essayez de lire le le code source de Bash de voir comment ils ont fait.

OriginalL'auteur

Ici sont les notes sur un tuyau de la Programmation des Systèmes de classe, j'ai pris le dernier semestre.

OriginalL'auteur

bien, je n'ai pas de réponse, mais je suis en train de travailler sur le même problème atm. Je vais partager ce que j'ai. Il fonctionne pour les deux commandes, mais une fois qu'elle est en cours d'exécution, i/o sont cassés. d'une manière étrange, je n'ai pas été en mesure de comprendre encore. appelez le plombier!

void pipeCommand(char** cmd1, char** cmd2) {
  int fds[2]; //file descriptors
  pipe(fds);
  int oldIn, oldOut;
  //child process #1
  if (fork() == 0) {
    //Reassign stdin to fds[0] end of pipe.
    oldIn = dup(STDIN_FILENO);
    dup2(fds[0], STDIN_FILENO);
    close(fds[1]);
    close(fds[0]);
    //Execute the second command.
    execvp(cmd2[0], cmd2);
  //child process #2
  } else if ((fork()) == 0) {
    oldOut = dup(STDOUT_FILENO);
    //Reassign stdout to fds[1] end of pipe.
    dup2(fds[1], STDOUT_FILENO);
    close(fds[0]);
    close(fds[1]);
    //Execute the first command.
    execvp(cmd1[0], cmd1);
  //parent process
  } else
    wait(NULL);
    dup2(oldIn, STDIN_FILENO);
    dup2(oldOut, STDOUT_FILENO);
    close(oldOut);
    close(oldIn);
}

J'ai le sentiment que ça a à voir avec ce qui suis ou ne suis pas le faire après le wait()

OriginalL'auteur