How to Implement a single program in C that replicates the following Unix command(s): ps -ef | grep YOUR_USER_id | wc

Question

My teacher gave us a practice assignment for studying in my Operating Systems class. The assignment was to pipe three processes together and implement the commands in the title all at once. We are only allowed to use these commands when implementing it:

dup2()
one of the exec()
fork()
pipe()
close()

I can pipe two together but I don't know how to do three. Could someone either show me how to do it or at least point me in the right direction?

Here is my code so far:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
        int pfd[2];
        int pfdb[2];
        int pid;

        if (pipe(pfd) == -1) {
                perror("pipe failed");
                exit(-1);
        }
        if ((pid = fork()) < 0) {
                perror("fork failed");
                exit(-2);
        }
        if (pid == 0) {
                close(pfd[1]);
                dup2(pfd[0], 0);
                close(pfd[0]);
                execlp("ps", "ps", "-ef", (char *) 0);
                perror("ps failed");
                exit(-3);
        } 
        else {
                close(pfd[0]);
                dup2(pfd[1], 1);
                close(pfd[1]);
                execlp("grep", "grep", "darrowr", (char *) 0);
                perror("grep failed");
                exit(-4);
        }
        exit(0);

}

Any help would be appreciated. Heck a tutorial on how to complete it would be wondrous!

Answer 1

You're going to need 3 processes and 2 pipes to connect them together. You start with 1 process, so you are going to need 2 fork() calls, 2 pipe() calls, and 3 exec*() calls. You have to decide which of the processes the initial process will end up running; it is most likely either the ps or the wc. You can write the code either way, but decide before you start.

The middle process, the grep, is going to need a pipe for its input and a pipe for its output. You could create one pipe and one child process and have it run ps with its output going to a pipe; you then create another pipe and another child process and fix its pipes up before running grep; the original process would have both pipes open and would close most of the file descriptors before running wc.

The key thing with pipes is to make sure you close enough file descriptors. If you duplicate a pipe to standard input or standard output, you should almost always close both of the original file descriptors returned by the pipe() call; in your example, you should close both. And with two pipes, that means there are four descriptors to close.

Working code

Note the use of an error report and exit function; it simplifies error reporting enormously. I have a library of functions that do different error reports; this is a simple implementation of one of those functions. (It's overly simple: it doesn't include the program name in the messages.)

#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static void err_syserr(const char *fmt, ...);

int main(void)
{
  int p1[2];
  int p2[2];
  pid_t pid1;
  pid_t pid2;

  if (pipe(p1) == -1)
    err_syserr("failed to create first pipe");
  if ((pid1 = fork()) < 0)
    err_syserr("failed to fork first time");
  if (pid1 == 0)
  {
    dup2(p1[1], STDOUT_FILENO);
    close(p1[0]);
    close(p1[1]);
    execlp("ps", "ps", "-ef", (char *)0);
    err_syserr("failed to exec 'ps'");
  }
  if (pipe(p2) == -1)
    err_syserr("failed to create second pipe");
  if ((pid2 = fork()) < 0)
    err_syserr("failed to fork second time");
  if (pid2 == 0)
  {
    dup2(p1[0], STDIN_FILENO);
    close(p1[0]);
    close(p1[1]);
    dup2(p2[1], STDOUT_FILENO);
    close(p2[0]);
    close(p2[1]);
    execlp("grep", "grep", "root", (char *)0);
    err_syserr("failed to exec 'grep'");
  }
  else
  {
    close(p1[0]);
    close(p1[1]);
    dup2(p2[0], STDIN_FILENO);
    close(p2[0]);
    close(p2[1]);
    execlp("wc", "wc", (char *)0);
    err_syserr("failed to exec 'wc'");
  }
  /*NOTREACHED*/
}

#include <stdarg.h>
#include <errno.h>
#include <string.h>

static void err_syserr(const char *fmt, ...)
{
  int errnum = errno;
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  if (errnum != 0)
    fprintf(stderr, " (%d: %s)", errnum, strerror(errnum));
  putc('\n', stderr);
  exit(EXIT_FAILURE);
}

Sample output:

    234    2053   18213

My machine is rather busy running root-owned programs, it seems.