home *** CD-ROM | disk | FTP | other *** search
/ gdead.berkeley.edu / gdead.berkeley.edu.tar / gdead.berkeley.edu / pub / cad-tools / ciftomann.tar / driver_dir / npipe.c < prev    next >
C/C++ Source or Header  |  1988-01-28  |  2KB  |  143 lines
  1. #include <stdio.h>
  2.  
  3. char *malloc(), *strcpy();
  4. static int pid;
  5.  
  6. int pipeline(firstin, lastout, errfile, cmdv, argvv)
  7. char *firstin;
  8. char *lastout;
  9. char *errfile;
  10. char **cmdv;
  11. char ***argvv;
  12. {
  13.     char *infile, *outfile;
  14.     char tempname[40];
  15.     int oldin, oldout, olderr;
  16.     int val, status;
  17.     int errd, tmp_num = 0;
  18.     FILE *errstream;
  19.  
  20.     oldin = dup2(0);
  21.     oldout = dup2(1);
  22.     close(2);
  23.  
  24.     infile = firstin;
  25.     if (access(errfile, 2) != 0) {
  26.     errd = creat(errfile,1);
  27.     if (errd == -1) {
  28.         return(-1);
  29.     }
  30.     close(errd);
  31.     }
  32.  
  33.  
  34.     while ( cmdv[1] != (char *) 0 ) {
  35.     fprintf(tempname, "pipe%.4d.tmp", tmp_num++);
  36.     outfile = strcpy(malloc(strlen(tempname+1)),tempname);
  37.     status = do_cmd(infile, outfile, errfile, *cmdv, *argvv);
  38.     if (status != 0) {
  39.         return(status);
  40.     }
  41.     cmdv++;
  42.     argvv++;
  43.     if (infile != firstin) {
  44.         unlink(infile);
  45.         free(infile);
  46.     }
  47.     infile = outfile;
  48.     }
  49.  
  50.     status = do_cmd(infile, lastout, errfile, *cmdv, *argvv);
  51.     if (status != 0) {
  52.     return(status);
  53.     }
  54.  
  55.     if (infile != firstin) {
  56.     unlink(infile);
  57.     free(infile);
  58.     }
  59.  
  60.     dup2(oldin, 0);
  61.     close(oldin);
  62.     dup2(oldout, 1);
  63.     close(oldout);
  64.     set_stderr(errfile);
  65.     return(0);
  66. }
  67.  
  68. do_cmd(infile, outfile, errfile, cmd, argv)
  69. char *infile, *outfile, *errfile;
  70. char *cmd, **argv;
  71. {
  72.     int val, status;
  73.     int ind, outd, errd;
  74.     char buf[101];
  75.  
  76.     pid = vfork();
  77.  
  78.     if (pid == -1) {
  79.     if (set_stderr(errfile) < 0) {
  80.         return(-1);
  81.     }
  82.     perror("Cannot vfork");
  83.     return(-1);
  84.     }
  85.  
  86.     if (pid == 0) {
  87.     if (set_stderr(errfile) < 0) {
  88.         exit(-1);
  89.     }
  90.     ind = open(infile, 0600);
  91.     if (ind < 0 || dup2(ind,0) == -1) {
  92.         perror(infile);
  93.         exit(-1);
  94.     }
  95.     close(ind);
  96.     if (outd < 0 || dup2(outd,1) == -1) {
  97.         perror(infile);
  98.         exit(-1);
  99.     }
  100.     close(outd);
  101.  
  102.     execv(cmd, argv);
  103.     sprintf(buf, "Cannot exec %s", cmd);
  104.     perror(buf);
  105.     exit(-1);
  106.     } else {
  107.     while ((val = wait(&status)) != pid) {
  108.         if (val == -1) {
  109.         if (set_stderr(errfile) < 0) {
  110.             exit(-1);
  111.         }
  112.         fprintf(stderr, "The process %s has disappeared\n",
  113.             cmd);
  114.         close(2);
  115.         return(-1);
  116.         }
  117.     }
  118.     return(status);
  119.     }
  120. }
  121.  
  122. set_stderr(file)
  123. char *file;
  124. {
  125.     FILE *errstream;
  126.  
  127.     errstream = fopen(file, "a");
  128.     if (errstream == NULL) {
  129.     return(-1);
  130.     }
  131.     if (dup2(fileno(errstream),2) == -1) {
  132.     return(-1);
  133.     }
  134.     fclose(errstream);
  135.     return(0);
  136. }
  137.  
  138. #include <signal.h>
  139.  
  140. kill_pipe() {
  141.     kill(pid, SIGTERM);
  142. }
  143.