La tuyauterie d'entrée/de sortie

Votre principal problème, c'est que vous avez des arguments à dup2() inversée. Vous devez utiliser:

dup2(fd_p2c[0], 0);   //Duplicate read end of pipe to standard input
dup2(fd_pFc[1], 1);   //Duplicate write end of pipe to standard output

J'ai dupé dans l'erreur de lecture, ce que vous avez écrit comme OK jusqu'à ce que j'ai mis vérification des erreurs sur le code et a obtenu des valeurs inattendues de la dup2() appels, qui m'a dit que ce était la difficulté. Quand quelque chose va mal, insérer les contrôles d'erreur vous lésiné sur les avant de.

Vous également de ne pas assurer la terminaison null de la lecture de données à partir de l'enfant; ce code n'.

Code de travail (diagnostic), à l'aide de cat que le plus simple possible", d'autres de la commande":

#include <unistd.h>
#include <string>
#include <iostream>
using namespace std;
int main()
{
int fd_p2c[2], fd_c2p[2], bytes_read;
pid_t childpid;
char readbuffer[80];
string program_name = "/bin/cat";
string gulp_command = "this is the command data sent to the child cat (kitten?)";
string receive_output = "";
if (pipe(fd_p2c) != 0 || pipe(fd_c2p) != 0)
{
cerr << "Failed to pipe\n";
exit(1);
}
childpid = fork();
if (childpid < 0)
{
cout << "Fork failed" << endl;
exit(-1);
}
else if (childpid == 0)
{
if (dup2(fd_p2c[0], 0) != 0 ||
close(fd_p2c[0]) != 0 ||
close(fd_p2c[1]) != 0)
{
cerr << "Child: failed to set up standard input\n";
exit(1);
}
if (dup2(fd_c2p[1], 1) != 1 ||
close(fd_c2p[1]) != 0 ||
close(fd_c2p[0]) != 0)
{
cerr << "Child: failed to set up standard output\n";
exit(1);
}
execl(program_name.c_str(), program_name.c_str(), (char *) 0);
cerr << "Failed to execute " << program_name << endl;
exit(1);
}
else
{
close(fd_p2c[0]);
close(fd_c2p[1]);
cout << "Writing to child: <<" << gulp_command << ">>" << endl;
int nbytes = gulp_command.length();
if (write(fd_p2c[1], gulp_command.c_str(), nbytes) != nbytes)
{
cerr << "Parent: short write to child\n";
exit(1);
}
close(fd_p2c[1]);
while (1)
{
bytes_read = read(fd_c2p[0], readbuffer, sizeof(readbuffer)-1);
if (bytes_read <= 0)
break;
readbuffer[bytes_read] = '\0';
receive_output += readbuffer;
}
close(fd_c2p[0]);
cout << "From child: <<" << receive_output << ">>" << endl;
}
return 0;
}

Exemple de sortie:

Writing to child: <<this is the command data sent to the child cat (kitten?)>>
From child: <<this is the command data sent to the child cat (kitten?)>>

Notez que vous aurez besoin d'être prudent afin de s'assurer que vous n'obtenez pas dans l'impasse avec votre code. Si vous avez un strict protocole synchrone (de sorte que le parent écrit un message et lit une réponse en lock-step), vous devez être bien, mais si le parent est d'essayer d'écrire un message qui est trop gros pour rentrer dans le tuyau de l'enfant lorsque l'enfant est d'essayer d'écrire un message qui est trop gros pour rentrer dans le tuyau à la maison mère, alors chacun sera bloqué par écrit lors de l'attente pour les autres à lire.

OriginalL'auteur Jonathan Leffler

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <string.h>
#include <iostream>
using namespace std;
int main() {
int i, status, len;
char str[10];
mknod("pipe", S_IFIFO | S_IRUSR | S_IWUSR, 0); //create named pipe
pid_t pid = fork(); //create new process
/* Process A */
if (pid == 0) {
int myPipe = open("pipe", O_WRONLY); //returns a file descriptor for the pipe
cout << "\nThis is process A having PID= " << getpid(); //Get pid of process A
cout << "\nEnter the string: ";
cin >> str;
len = strlen(str);
write(myPipe, str, len); //Process A write to the named pipe
cout << "Process A sent " << str;
close(myPipe); //closes the file descriptor fields.
}
/* Process B */
else {
int myPipe = open("pipe", O_RDONLY); //Open the pipe and returns file descriptor
char buffer[21];
int pid_child;
pid_child = wait(&status); //wait until any one child process terminates
int length = read(myPipe, buffer, 20); //reads up to size bytes from pipe with descriptor fields, store results
// in buffer;
cout<< "\n\nThis is process B having PID= " << getpid();//Get pid of process B
buffer[length] = '\0';
cout << "\nProcess B received " << buffer;
i = 0;
//Reverse the string
for (length = length - 1; length >= 0; length--)
str[i++] = buffer[length];
str[i] = '\0';
cout << "\nRevers of string is " << str;
close(myPipe);
}
unlink("pipe");
return 0;
}

OriginalL'auteur Priyanshu Shukla