Unable to write into pipe IPC for 2 processes - c

Question

I have 2 processes (an 'ls' process and a 'grep'). I'm using pipe to communicate between both of them. But the grep process is unable to read from the pipe. Could you help me figure out why so?
Here is my code
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
int pipe_fd[2];
int main()
{
pid_t p1,p2;
char *prog1_argv[4];
char *prog2_argv[2];
/* Build argument list */
prog1_argv[0] = "ls";
prog1_argv[1] = "-l";
prog1_argv[2] = "/";
prog1_argv[3] = NULL;
prog2_argv[0] = "grep";
prog2_argv[1] = "s";
prog2_argv[1] = NULL;
if (pipe(pipe_fd) < 0)
{
printf ("pipe failed");
}
p1 = fork();
if(p1 == 0)
{
printf("in child\n");
close(pipe_fd[0]);
if(dup2(pipe_fd[1],1)<0)
{
printf("dup failed:%d\n",errno);
}
close(pipe_fd[1]);
if(execvp (prog1_argv[0], prog1_argv)<0)
printf("exec failed");
}
if(p1>0)
{
printf("im in parent\n");
waitpid(p1,NULL,0);
printf("parent: child exited. Now test the pipe\n");
close(pipe_fd[1]);
if(dup2(pipe_fd[0],0)<0)
{
printf("dup failed:%d\n",errno);
}
close(pipe_fd[0]);
if(execvp (prog2_argv[0], prog2_argv)<0)
printf("exec failed");
}
}

Answer 1

Fundamentally, you should not be waiting for the ls to die before running the grep.
The ls command might generate so much data that it can't all be stored in the pipe, so the ls command will block until the other process reads from the pipe, but the other process is waiting for ls to complete before it tries to read anything from the pipe. This is a deadlock.
Also, by waiting like that, you enforce serial execution, which throws away the benefits of multiple cores.
There are a number of minor improvements you should make. There are various points at which you report errors. Errors should be reported on the standard error stream (stderr), not on stdout. You should also ensure the program does not continue after at least some of those errors.
You don't have to test the return value from any of the exec*() system calls. If the function returns, it failed. And again, you should ensure that the process exits after that. In this program, it doesn't matter that the child continues; in many programs, not exiting would lead to chaos (two processes trying to read standard input at the same time, for example).
There's no need for pipe_fd to be a global variable. Do make sure all your messages end with a newline, please. You didn't include <sys/wait.h> so you were working without a prototype in scope for the waitpid() function — that's generally a bad idea. You should set your compiler to fussy so it demands that every function has a prototype in scope before it is used or defined. You can initialize the argument lists in the definitions:
char *prog1_argv[] = { "ls", "-l", "/", NULL };
char *prog2_argv[] = { "grep", "s", NULL };
This has the crucial beneficial side-effect of not zapping prog_argv2[1] with a NULL pointer (as noted by Matthias in his answer. I also removed the sizes of the arrays; the second one was dimensioned at 2 and needed to be 3, but when you initialize like this, the compiler does the counting.
One thing you did correctly that was important to do correctly is ensure that the pipe file descriptors were all closed.
This works correctly for me:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
int main(void)
{
pid_t p1;
int pipe_fd[2];
char *prog1_argv[] = { "ls", "-l", "/", NULL };
char *prog2_argv[] = { "grep", "s", 0 };
if (pipe(pipe_fd) < 0)
{
fprintf(stderr, "pipe failed:%d\n", errno);
exit(1);
}
p1 = fork();
if (p1 == 0)
{
printf("In child\n");
close(pipe_fd[0]);
if (dup2(pipe_fd[1], 1) < 0)
{
fprintf(stderr, "dup failed:%d\n", errno);
exit(1);
}
close(pipe_fd[1]);
execvp(prog1_argv[0], prog1_argv);
fprintf(stderr, "exec failed:%d\n", errno);
exit(1);
}
if (p1 > 0)
{
printf("In parent\n");
close(pipe_fd[1]);
if (dup2(pipe_fd[0], 0) < 0)
{
fprintf(stderr, "dup failed:%d\n", errno);
exit(1);
}
close(pipe_fd[0]);
execvp(prog2_argv[0], prog2_argv);
fprintf(stderr, "exec failed:%d\n", errno);
exit(1);
}
fprintf(stderr, "Fork failed:%d\n", errno);
return(1);
}

Answer 2

You override your grep's argument. Try:
int main()
{
pid_t p1,p2;
char *prog1_argv[4];
char *prog2_argv[3];
/* Build argument list */
prog1_argv[0] = "ls";
prog1_argv[1] = "-l";
prog1_argv[2] = "/";
prog1_argv[3] = NULL;
prog2_argv[0] = "grep";
prog2_argv[1] = "s";
prog2_argv[2] = NULL;
// ...