[C] implementation shell unix (fork, pipe)

implementation shell unix (fork, pipe) [C] - C - Programmation

Marsh Posté le 29-04-2004 à 17:01:13    

J'ai un programme à faire en C qui doit être capable d'exécuter les commandes de base suivantes :  
 
#  % ls
# % ls > filelist
# % cat filelist
# % cat < filelist
# % ls | wc
# % ls | cat | cat | cat | wc
 
les quatres premiers types de commandes fonctionnent (simples, redirections), mais j'ai des problèmes avec les pipes
 
J'avais une structure de base avec des fonctions déjà opérationnelles : parser...
 
donc il reste deux fonctions importantes :
 

Code :
  1. static char* progname;  /* name of this shell program. */
  2. static char input_buf[MAXBUF]; /* input is placed here. */
  3. static char token_buf[2 * MAXBUF]; /* tokens are placed here. */
  4. static char* input_char;  /* next character to check. */
  5. static char* token;   /* a token such as /bin/ls */
  7. static list_t* path_dir_list;  /* list of directories in PATH. */
  8. static int input_fd;  /* for i/o redirection or pipe. */
  9. static int output_fd;  /* for i/o redirection or pipe */
  12. /* run_program: fork and exec a program. */
  13. void run_program(char** argv, int argc, bool foreground, bool doing_pipe)
  14. {
  15. /* you need to fork, search for the command in argv[0],
  16.          * setup stdin and stdout of the child process, execv it.
  17.          * the parent should sometimes wait and sometimes not wait for
  18.  * the child process (you must figure out when). if foreground
  19.  * is true then basically you should wait but when we are
  20.  * running a command in a pipe such as PROG1 | PROG2 you might
  21.  * not want to wait for each of PROG1 and PROG2...
  22.  *  
  23.  * hints:
  24.  *  sprintf is useful for constructing strings.
  25.  *  access is useful for checking wether a path refers to an  
  26.  *      executable program.
  27.  *  
  28.  *  
  29.  */
  31.  int  child_pid;
  32.  char   file[MAXBUF];
  34.  sprintf(file,"/usr/bin/%s",argv[0]);
  36. if (doing_pipe) {
  37. printf("pipe\n" );
  38.  if (access(file,X_OK) == 0) {
  41.   if ((child_pid = fork()) < 0) {
  42.    perror("fork failed" );
  43.    exit(1);
  44.   }
  45.   else if (child_pid == 0) {
  47.    if (output_fd != 0) {
  48.     dup2(output_fd,1);  // > case
  49.    }
  50.    if (input_fd != 0) {
  51.     dup2(input_fd,0);  // < case
  52.    }
  53.    execv(file,argv);
  54.   }
  56.  }
  57.  else {
  58.    printf("command does not exist : %s \n",argv[0]);
  59.   }
  62. }
  63. else {
  64.  if (access(file,X_OK) == 0) {
  67.   if ((child_pid = fork()) < 0) {
  68.    perror("fork failed" );
  69.    exit(1);
  70.   }
  71.   else if (child_pid == 0) {
  73.    if (output_fd != 0) {
  74.     dup2(output_fd,1);  // > case
  75.    }
  76.    if (input_fd != 0) {
  77.     dup2(input_fd,0);  // < case
  78.    }
  79.    execv(file,argv);
  80.   }
  82.  }
  83.  else {
  84.    printf("command does not exist : %s \n",argv[0]);
  85.   }
  87. }
  92. }
  95. void parse_line(void)
  96. {
  97. char*  argv[MAX_ARG + 1];
  98. int  argc;
  99. int  pipe_fd[2]; /* 1 for producer and 0 for consumer. */
  100. token_type_t type;
  101. bool  foreground;
  102. bool  doing_pipe;
  104. input_fd = 0;
  105. output_fd = 0;
  106. argc  = 0;
  108. for (;;) {
  110.  foreground = true;
  111.  doing_pipe = false;
  113.  type = gettoken(&argv[argc]);
  115.  switch (type) {
  116.  case NORMAL:
  117.   argc += 1;
  118.   break;
  120.  case INPUT:
  121.   type = gettoken(&argv[argc]);
  122.   if (type != NORMAL) {
  123.    error("expected file name: but found %s",
  124.     argv[argc]);
  125.    return;
  126.   }
  128.   input_fd = open(argv[argc], O_RDONLY);
  130.   if (input_fd < 0)
  131.    error("cannot read from %s", argv[argc]);
  133.   break;
  135.  case OUTPUT:
  136.   type = gettoken(&argv[argc]);
  137.   if (type != NORMAL) {
  138.    error("expected file name: but found %s",
  139.     argv[argc]);
  140.    return;
  141.   }
  143.   output_fd = open(argv[argc], O_CREAT | O_WRONLY, PERM);
  145.   if (output_fd < 0)
  146.    error("cannot write to %s", argv[argc]);
  147.   break;
  149.  case PIPE:
  150.   doing_pipe = true;
  151.   pipe(pipe_fd);
  152.   output_fd = pipe_fd[1];
  153.   printf("output_fd : %d \n",output_fd);
  157.   /*FALLTHROUGH*/
  159.  case AMPERSAND:
  160.   foreground = false;
  162.   /*FALLTHROUGH*/
  164.  case NEWLINE:
  165.  case SEMICOLON:
  167.   if (argc == 0)
  168.    return;
  170.   argv[argc] = NULL;
  171.   run_program(argv, argc, foreground, doing_pipe);
  174.   input_fd = 0;
  175.   output_fd = 0;
  176.   argc  = 0;
  177.   input_fd = pipe_fd[0];
  178.   printf("input_fd : %d \n",input_fd);
  179.   if (type == NEWLINE)
  180.    return;
  182.   break;
  183.  }
  184. }
  185. }


 
 
j'explique un peu le principe : la fonction parse_line analyse la ligne de commande et place les arguments (nom de commande,"<",">","|","&",fin de ligne) dans un tableau.
Ensuite run_program est appelé. Elle a pour but de créer le nouveau processus. La partie redirection fonctionne, c'est pour la gestion des pipes que je ne m'en sors pas.


Message édité par frabill le 29-04-2004 à 18:18:47
Reply

Marsh Posté le 29-04-2004 à 17:01:13   

Reply

Marsh Posté le 29-04-2004 à 17:04:10    

1) utilise les balises de formatage de code si tu le peux
2) c'est quoi ta question?


Message édité par Moktar1er le 29-04-2004 à 17:04:38
Reply

Marsh Posté le 29-04-2004 à 17:16:40    

en fait c'est déjà du point de vue algorithmie que je ne suis pas sûr d'avoir compris
 
si je souhaite implémenter "ls | wc", le principe c'est :
1) créer un pipe : pipe (int fd[2])
2) remplacer le file descriptor 1 (stdout) de ls par fd[1]
3) remplacer le file descriptor 0 (stdin) de wc par fd[0]
 
mais avec la structure imposée je n'arrive pas à mettre ça correctement en place

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed