dup and dup2 useful?

xeon123 · 10-20-2007, 01:46 PM

Hi,

I was watching to dup and dup2 description, but I can't understand how uselful this primitives can be. Are they really useful?

Thanks,

xeon123 · 10-20-2007, 01:49 PM

The following example is a pipe example. Please, see the question inside the code.

Code:

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>


void piping(char* ptr)
{
  int status;
  int pid[2];
  int pipe_fd[2];

  char *prog1_argv[4];
  char *prog2_argv[2];

  char* args[getNrOftokens(ptr, "|")];

  //tokenizer( ptr, "|", args );

/*   for int i = 0; i< ,.asd,sa.d,sd */
/*   if( ptr[len-2] == ' ' ) */
/*     ptr[len-2] = 0; */
  /*
   * Build argument list
   */

  prog1_argv[0] = "ls";
  prog1_argv[1] = "-lR";
  prog1_argv[2] = "/";
  prog1_argv[3] = NULL;


  prog2_argv[0] = "more";
  prog2_argv[1] = NULL;

  /*
   * Create the pipe
   */
  if (pipe(pipe_fd) < 0)


    perror ("pipe failed");
      exit (errno);
    }

  /*
   * Create a process space for the ls
   */
  if ((pid[0]=fork()) < 0)
    {
      perror ("Fork failed");
      exit(errno);
    }

  if (!pid[0])// Child
    {
      /*
       * Set stdout to pipe
       */
      printf("%d\t%d\n", pipe_fd[0], pipe_fd[1]);
      close (pipe_fd[0]);// Close stdin
      dup2 (pipe_fd[1], 1);<<<------------------ Is this really usefeul? I don't understand why.
      printf("%d\t%d\n", pipe_fd[0], pipe_fd[1]);

      close (pipe_fd[1]);

      /* Execute the ls */
      execute (prog1_argv[0], prog1_argv);
    }

  if (pid[0])//Parent
    {
      /*
       * We're in the parent
       */

      /*
       * Create a process space for the more
       */

    perror ("pipe failed");
      exit (errno);
    }

  /*
   * Create a process space for the ls
   */
  if ((pid[0]=fork()) < 0)
    {
      perror ("Fork failed");
      exit(errno);
    }

  if (!pid[0])// Child
    {
      /*
       * Set stdout to pipe
       */
      printf("%d\t%d\n", pipe_fd[0], pipe_fd[1]);
      close (pipe_fd[0]);// Close stdin
      dup2 (pipe_fd[1], 1);
      printf("%d\t%d\n", pipe_fd[0], pipe_fd[1]);

      close (pipe_fd[1]);

      /* Execute the ls */
      execute (prog1_argv[0], prog1_argv);
    }

  if (pid[0])//Parent
    {
      /*
       * We're in the parent
       */

      /*
       * Create a process space for the more
       */
if ((pid[1]=fork()) < 0)
        {
          perror ("Fork failed");
          exit(errno);
        }

      if (!pid[1])
        {
          /*
           * We're in the child
           */

          /*
           * Set stdin to pipe
           */
          close (pipe_fd[1]);
          dup2 (pipe_fd[0], 0);
          close (pipe_fd[0]);

          /* Execute the more */
          execute (prog1_argv[0], prog1_argv);
          //execvp (prog2_argv[0], prog2_argv);
        }

      /* This is the parent */
      close(pipe_fd[0]);
      close(pipe_fd[1]);

      waitpid (pid[1], &status, 0);
      printf ("Done waiting for more.\n");

    }
}

paulsm4 · 10-20-2007, 07:22 PM

Yes, "dup2()" is useful. In situations with concurrency (and the possibility of race conditions), it might even be essential.

Look at this link for more info:
http://www.linuxquestions.org/questi...40#post2931140

ta0kira · 10-22-2007, 10:48 AM

You need dup2 in cases where you want to pipe standard input and output between two programs as opposed to having everything taken from or sent to the terminal. dup can be very useful when opening a temporary stream on a file descriptor: when the stream is closed so is the file descriptor, so you need to duplicate it so the original isn't closed when the temporary stream is. dup2 is also useful for replacing a file descriptor at the process level. It allows you to change the underlying file for a file descriptor, allowing multiple threads, functions, and contexts to seamlessly write across multiple files.
ta0kira