pith/osdep/pipe.c

   1 #if !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: pipe.c 1204 2009-02-02 19:54:23Z hubert@u.washington.edu $";
   3 #endif
   4
   5 /*
   6  * ========================================================================
   7  * Copyright 2006-2008 University of Washington
   8  * Copyright 2013-2015 Eduardo Chappa
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *     http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * ========================================================================
  17  */
  18
  19 #include <system.h>
  20
  21 #include "err_desc.h"
  22
  23 #include "canaccess.h"
  24 #include "temp_nam.h"
  25 #include "forkwait.h"
  26 #include "pipe.h"
  27 #include "../charconv/utf8.h"
  28 #include "../charconv/filesys.h"
  29 #include "../debug.h"
  30
  31 #ifdef _WINDOWS
  32 #include "../../pico/osdep/mswin.h"
  33 #endif
  34
  35
  36
  37 /*======================================================================
  38     pipe
  39
  40     Initiate I/O to and from a process.  These functions used to be
  41     similar to popen and pclose, but both an incoming stream and an
  42     output file are provided.
  43
  44  ====*/
  45
  46
  47
  48 /*
  49  * Global's to helpsignal handler tell us child's status has changed...
  50  */
  51 static pid_t    child_pid;
  52
  53
  54 /*
  55  * Internal Protos
  56  */
  57 void       zot_pipe(PIPE_S **);
  58 #ifdef  _WINDOWS
  59 int pipe_mswin_exec_wrapper(char *, PIPE_S *, unsigned,
  60                             void (*)(PIPE_S *, int, void *),
  61                             void (*)(char *));
  62 #else  /* UNIX */
  63 char      *pipe_error_msg(char *, char *, char *);
  64 RETSIGTYPE pipe_alarm(int);
  65 #endif /* UNIX */
  66
  67
  68
  69
  70 /*----------------------------------------------------------------------
  71      Spawn a child process and optionally connect read/write pipes to it
  72
  73   Args: command -- string to hand the shell
  74         outfile -- address of pointer containing file to receive output
  75         errfile -- address of pointer containing file to receive error output
  76         mode -- mode for type of shell, signal protection etc...
  77   Returns: pointer to alloc'd PIPE_S on success, NULL otherwise
  78
  79   The outfile is either NULL, a pointer to a NULL value, or a pointer
  80   to the requested name for the output file.  In the pointer-to-NULL case
  81   the caller doesn't care about the name, but wants to see the pipe's
  82   results so we make one up.  It's up to the caller to make sure the
  83   free storage containing the name is cleaned up.
  84
  85   Mode bits serve several purposes.
  86     PIPE_WRITE tells us we need to open a pipe to write the child's
  87         stdin.
  88     PIPE_READ tells us we need to open a pipe to read from the child's
  89         stdout/stderr.  *NOTE*  Having neither of the above set means
  90         we're not setting up any pipes, just forking the child and exec'ing
  91         the command.  Also, this takes precedence over any named outfile.
  92     PIPE_STDERR means we're to tie the childs stderr to the same place
  93         stdout is going.  *NOTE* This only makes sense then if PIPE_READ
  94         or an outfile is provided.  Also, this takes precedence over any
  95         named errfile.
  96     PIPE_RESET means we reset the terminal mode to what it was before
  97         we started pine and then exec the command. In PC-Pine, _RESET
  98         was a shortcut for just executing a command.  We'll try to pay
  99         attention to the above flags to make sure we do the right thing.
 100     PIPE_PROT means to protect the child from the usual nasty signals
 101         that might cause premature death.  Otherwise, the default signals are
 102         set so the child can deal with the nasty signals in its own way.
 103         NOT USED UNDER WINDOWS
 104     PIPE_NOSHELL means we're to exec the command without the aid of
 105         a system shell.  *NOTE* This negates the affect of PIPE_USER.
 106         NOT USED UNDER WINDOWS
 107     PIPE_USER means we're to try executing the command in the user's
 108         shell.  Right now we only look in the environment, but that may get
 109         more sophisticated later.
 110         NOT USED UNDER WINDOWS
 111     PIPE_RUNNOW was added for WINDOWS for the case pipe is called to run
 112         a shell program (like for url viewing).  This is the only option
 113         where we don't wait for child termination, and is only obeyed if
 114         PIPE_WRITE and PIPE_READ aren't set
 115  ----*/
 116 PIPE_S *
 117 open_system_pipe(char *command, char **outfile, char **errfile, int mode,
 118                  int timeout, void (*pipecb_f)(PIPE_S *, int, void *),
 119                  void (*piperr_f)(char *))
 120 {
 121     PIPE_S *syspipe = NULL;
 122 #ifdef  _WINDOWS
 123     int exit_code = 0;
 124     char cmdbuf[1024];
 125     unsigned flags = 0;
 126 #else
 127     char    shellpath[MAXPATH+1], *shell;
 128     int     p[2], oparentd = -1, ochildd = -1, iparentd = -1, ichildd = -1;
 129 #endif
 130
 131 #ifdef  _WINDOWS
 132     if(mode & PIPE_STDERR)
 133       flags |= MSWIN_EAW_CAPT_STDERR;
 134     /*
 135      * It'll be a lot more difficult to support READing and WRITing.
 136      * This was never supported, and there don't look to be any cases
 137      * that set both of these flags anymore for win32.
 138      *
 139      * errfile could probably be supported pretty easily
 140      */
 141
 142     if(errfile){
 143         if(piperr_f)
 144           (*piperr_f)("Pipe arg not yet supported: Error File");
 145
 146         return(NULL);
 147     }
 148
 149
 150     if((mode & PIPE_RUNNOW)
 151        && !(mode & (PIPE_WRITE | PIPE_READ | PIPE_STDERR))){
 152         if(mswin_shell_exec(command, NULL) == 0
 153            && (syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) != NULL){
 154             memset(syspipe, 0, sizeof(PIPE_S));
 155             return(syspipe);
 156         }
 157
 158         return(NULL);
 159     }
 160
 161     strncpy(cmdbuf, command, sizeof(cmdbuf));
 162     cmdbuf[sizeof(cmdbuf)-1] = '\0';
 163
 164     if((syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) == NULL)
 165       return(NULL);
 166
 167     memset(syspipe, 0, sizeof(PIPE_S));
 168     syspipe->mode = mode;
 169     if(!outfile){
 170         syspipe->deloutfile = 1;
 171         if(mode & PIPE_READ){
 172             syspipe->outfile = temp_nam(NULL, "po");
 173             our_unlink(syspipe->outfile);
 174         }
 175     }
 176     else{
 177         if(!*outfile) /* asked for, but not named? */
 178           *outfile = temp_nam(NULL, "po");
 179
 180         our_unlink(*outfile);
 181         syspipe->outfile = (char *) malloc((strlen(*outfile)+1)*sizeof(char));
 182         snprintf(syspipe->outfile, strlen(*outfile)+1, "%s", *outfile);
 183     }
 184
 185     if(mode & PIPE_WRITE){
 186         /*
 187          * Create tmp file to write, spawn child in close_pipe
 188          * after tmp file's written...
 189          */
 190         syspipe->infile = temp_nam(NULL, "pw");
 191         syspipe->out.f = our_fopen(syspipe->infile, "wb");
 192         syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
 193         snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
 194         dprint((1, "pipe write: %s", cmdbuf));
 195     }
 196     else if(mode & PIPE_READ){
 197         /*
 198          * Create a tmp file for command result, exec the command
 199          * here into temp file, and return file pointer to it...
 200          */
 201         syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
 202         snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
 203         dprint((1, "pipe read: %s", cmdbuf));
 204         if(pipe_mswin_exec_wrapper("pipe command", syspipe,
 205                                    flags, pipecb_f, piperr_f)){
 206             if(syspipe->outfile){
 207                 free((void *) syspipe->outfile);
 208                 syspipe->outfile = NULL;
 209             }
 210
 211             zot_pipe(&syspipe);
 212         }
 213         else{
 214           syspipe->in.f = our_fopen(syspipe->outfile, "rb");
 215           syspipe->exit_code = exit_code;
 216         }
 217     }
 218     else{
 219         /* we just run the command taking outfile into account */
 220         syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
 221         snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
 222         if(pipe_mswin_exec_wrapper("pipe command", syspipe,
 223                                    flags, pipecb_f, piperr_f)){
 224             if(syspipe->outfile){
 225                 free((void *) syspipe->outfile);
 226                 syspipe->outfile = NULL;
 227             }
 228
 229             zot_pipe(&syspipe);
 230         }
 231         else
 232           syspipe->exit_code = exit_code;
 233     }
 234
 235 #else /* !_WINDOWS */
 236
 237     if((syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) == NULL)
 238       return(NULL);
 239
 240     memset(syspipe, 0, sizeof(PIPE_S));
 241
 242     syspipe->mode = mode;
 243
 244     /*
 245      * If we're not using the shell's command parsing smarts, build
 246      * argv by hand...
 247      */
 248     if(mode & PIPE_NOSHELL){
 249         char   **ap, *p;
 250         size_t   n;
 251
 252         /* parse the arguments into argv */
 253         for(p = command; *p && isspace((unsigned char)(*p)); p++)
 254           ;                                     /* swallow leading ws */
 255
 256         if(*p){
 257             int l = strlen(p);
 258
 259             if((syspipe->args = (char *) malloc((l + 1) * sizeof(char))) != NULL){
 260                 strncpy(syspipe->args, p, l);
 261                 syspipe->args[l] = '\0';
 262             }
 263             else{
 264                 if(piperr_f)
 265                   (*piperr_f)(pipe_error_msg("<null>", "execute",
 266                                              "Can't allocate command string"));
 267                 zot_pipe(&syspipe);
 268                 return(NULL);
 269             }
 270         }
 271         else{
 272             if(piperr_f)
 273               (*piperr_f)(pipe_error_msg("<null>", "execute",
 274                                          "No command name found"));
 275             zot_pipe(&syspipe);
 276             return(NULL);
 277         }
 278
 279         for(p = syspipe->args, n = 2; *p; p++)  /* count the args */
 280           if(isspace((unsigned char)(*p))
 281              && *(p+1) && !isspace((unsigned char)(*(p+1))))
 282             n++;
 283
 284         if ((syspipe->argv = ap = (char **)malloc(n * sizeof(char *))) == NULL){
 285             zot_pipe(&syspipe);
 286             return(NULL);
 287         }
 288
 289         memset(syspipe->argv, 0, n * sizeof(char *));
 290
 291         for(p = syspipe->args; *p; ){           /* collect args */
 292             while(*p && isspace((unsigned char)(*p)))
 293               *p++ = '\0';
 294
 295             *ap++ = (*p) ? p : NULL;
 296             while(*p && !isspace((unsigned char)(*p)))
 297               p++;
 298         }
 299
 300         /* make sure argv[0] exists in $PATH */
 301         if(can_access_in_path(getenv("PATH"), syspipe->argv[0],
 302                               EXECUTE_ACCESS) < 0){
 303             if(piperr_f)
 304               (*piperr_f)(pipe_error_msg(syspipe->argv[0], "access",
 305                                          error_description(errno)));
 306             zot_pipe(&syspipe);
 307             return(NULL);
 308         }
 309     }
 310
 311     /* fill in any output filenames */
 312     if(!(mode & PIPE_READ)){
 313         if(outfile && !*outfile)
 314           *outfile = temp_nam(NULL, "pine_p"); /* asked for, but not named? */
 315
 316         if(errfile && !*errfile)
 317           *errfile = temp_nam(NULL, "pine_p"); /* ditto */
 318     }
 319
 320     /* create pipes */
 321     if(mode & (PIPE_WRITE | PIPE_READ)){
 322         if(mode & PIPE_WRITE){
 323             pipe(p);                            /* alloc pipe to write child */
 324             oparentd = p[STDOUT_FILENO];
 325             ichildd  = p[STDIN_FILENO];
 326         }
 327
 328         if(mode & PIPE_READ){
 329             pipe(p);                            /* alloc pipe to read child */
 330             iparentd = p[STDIN_FILENO];
 331             ochildd  = p[STDOUT_FILENO];
 332         }
 333     }
 334
 335     if(pipecb_f)                                /* let caller prep display */
 336       (*pipecb_f)(syspipe, OSB_PRE_OPEN, NULL);
 337
 338
 339     if((syspipe->pid = vfork()) == 0){
 340         /* reset child's handlers in requested fashion... */
 341         (void)signal(SIGINT,  (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
 342         (void)signal(SIGQUIT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
 343         (void)signal(SIGHUP,  (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
 344 #ifdef  SIGCHLD
 345         (void) signal(SIGCHLD,  SIG_DFL);
 346 #endif
 347
 348         /* if parent isn't reading, and we have a filename to write */
 349         if(!(mode & PIPE_READ) && outfile){     /* connect output to file */
 350             int output = our_creat(*outfile, 0600);
 351             dup2(output, STDOUT_FILENO);
 352             if(mode & PIPE_STDERR)
 353               dup2(output, STDERR_FILENO);
 354             else if(errfile)
 355               dup2(our_creat(*errfile, 0600), STDERR_FILENO);
 356         }
 357
 358         if(mode & PIPE_WRITE){                  /* connect process input */
 359             close(oparentd);
 360             dup2(ichildd, STDIN_FILENO);        /* tie stdin to pipe */
 361             close(ichildd);
 362         }
 363
 364         if(mode & PIPE_READ){                   /* connect process output */
 365             close(iparentd);
 366             dup2(ochildd, STDOUT_FILENO);       /* tie std{out,err} to pipe */
 367             if(mode & PIPE_STDERR)
 368               dup2(ochildd, STDERR_FILENO);
 369             else if(errfile)
 370               dup2(our_creat(*errfile, 0600), STDERR_FILENO);
 371
 372             close(ochildd);
 373         }
 374
 375         if(mode & PIPE_NOSHELL){
 376             execvp(syspipe->argv[0], syspipe->argv);
 377         }
 378         else{
 379             if(mode & PIPE_USER){
 380                 char *env, *sh;
 381                 if((env = getenv("SHELL")) && (sh = strrchr(env, '/'))){
 382                     shell = sh + 1;
 383                     strncpy(shellpath, env, sizeof(shellpath)-1);
 384                     shellpath[sizeof(shellpath)-1] = '\0';
 385                 }
 386                 else{
 387                     shell = "csh";
 388                     strncpy(shellpath, "/bin/csh", sizeof(shellpath)-1);
 389                     shellpath[sizeof(shellpath)-1] = '\0';
 390                 }
 391             }
 392             else{
 393                 shell = "sh";
 394                 strncpy(shellpath, "/bin/sh", sizeof(shellpath)-1);
 395                 shellpath[sizeof(shellpath)-1] = '\0';
 396             }
 397
 398             execl(shellpath, shell, command ? "-c" : (char *)NULL, fname_to_locale(command), (char *)NULL);
 399         }
 400
 401         fprintf(stderr, "Can't exec %s\nReason: %s",
 402                 command, error_description(errno));
 403         _exit(-1);
 404     }
 405
 406     if((child_pid = syspipe->pid) > 0){
 407         syspipe->isig = signal(SIGINT,  SIG_IGN); /* Reset handlers to make */
 408         syspipe->qsig = signal(SIGQUIT, SIG_IGN); /* sure we don't come to  */
 409         syspipe->hsig = signal(SIGHUP,  SIG_IGN); /* a premature end...     */
 410         if((syspipe->timeout = timeout) != 0){
 411             syspipe->alrm      = signal(SIGALRM,  pipe_alarm);
 412             syspipe->old_timeo = alarm(timeout);
 413         }
 414
 415         if(mode & PIPE_WRITE){
 416             close(ichildd);
 417             if(mode & PIPE_DESC)
 418               syspipe->out.d = oparentd;
 419             else
 420               syspipe->out.f = fdopen(oparentd, "w");
 421         }
 422
 423         if(mode & PIPE_READ){
 424             close(ochildd);
 425             if(mode & PIPE_DESC)
 426               syspipe->in.d = iparentd;
 427             else
 428               syspipe->in.f = fdopen(iparentd, "r");
 429         }
 430     }
 431     else{
 432         if(mode & (PIPE_WRITE | PIPE_READ)){
 433             if(mode & PIPE_WRITE){
 434                 close(oparentd);
 435                 close(ichildd);
 436             }
 437
 438             if(mode & PIPE_READ){
 439                 close(iparentd);
 440                 close(ochildd);
 441             }
 442         }
 443
 444         if(pipecb_f)                            /* let caller fixup display */
 445           (*pipecb_f)(syspipe, OSB_POST_OPEN, NULL);
 446
 447         if(outfile && *outfile){
 448             our_unlink(*outfile);
 449             free((void *) *outfile);
 450             *outfile = NULL;
 451         }
 452
 453         if(errfile && *errfile){
 454             our_unlink(*errfile);
 455             free((void *) *errfile);
 456             *errfile = NULL;
 457         }
 458
 459         if(piperr_f)
 460           (*piperr_f)(pipe_error_msg(command, "fork",
 461                                      error_description(errno)));
 462         zot_pipe(&syspipe);
 463     }
 464
 465 #endif /* UNIX */
 466
 467     return(syspipe);
 468 }
 469
 470
 471
 472 #ifndef _WINDOWS
 473 /*----------------------------------------------------------------------
 474     Return appropriate error message
 475
 476   Args: cmd -- command we were trying to exec
 477         op -- operation leading up to the exec
 478         res -- result of that operation
 479
 480  ----*/
 481 char *
 482 pipe_error_msg(char *cmd, char *op, char *res)
 483 {
 484     static char ebuf[512];
 485
 486     snprintf(ebuf, 256, "Pipe can't %.256s \"%.32sb\": %.223s",
 487              op ? op : "?", cmd ? cmd : "?", res ? res : "?");
 488
 489     return(ebuf);
 490 }
 491 #endif /* !_WINDOWS */
 492
 493
 494 /*----------------------------------------------------------------------
 495     Free resources associated with the given pipe struct
 496
 497   Args: syspipe -- address of pointer to struct to clean up
 498
 499  ----*/
 500 void
 501 zot_pipe(PIPE_S **syspipe)
 502 {
 503     if((*syspipe)->args){
 504         free((void *) (*syspipe)->args);
 505         (*syspipe)->args = NULL;
 506     }
 507
 508     if((*syspipe)->argv){
 509         free((void *) (*syspipe)->argv);
 510         (*syspipe)->argv = NULL;
 511     }
 512
 513     if((*syspipe)->tmp){
 514         free((void *) (*syspipe)->tmp);
 515         (*syspipe)->tmp = NULL;
 516     }
 517
 518 #ifdef  _WINDOWS
 519
 520     if((*syspipe)->outfile){
 521         free((void *) (*syspipe)->outfile);
 522         (*syspipe)->outfile = NULL;
 523     }
 524
 525     if((*syspipe)->command){
 526         free((void *) (*syspipe)->command);
 527         (*syspipe)->command = NULL;
 528     }
 529
 530 #endif /* _WINDOWS */
 531
 532     free((void *) *syspipe);
 533     *syspipe = NULL;
 534 }
 535
 536
 537
 538 /*
 539  * Returns: 0 if all went well, -1 otherwise
 540  */
 541 int
 542 pipe_close_write(PIPE_S *syspipe)
 543 {
 544     int rv = 0;
 545
 546     if(!syspipe || !syspipe->out.f)
 547       return -1;
 548
 549 #ifdef  _WINDOWS
 550
 551     {
 552         unsigned flags = 0;
 553
 554         if(syspipe->mode & PIPE_STDERR)
 555           flags |= MSWIN_EAW_CAPT_STDERR;
 556
 557         rv = fclose(syspipe->out.f);
 558         syspipe->out.f = NULL;
 559         if(syspipe->mode & PIPE_WRITE){
 560             /*
 561              * PIPE_WRITE should always be set if we're trying to close
 562              * the write end.
 563              * PIPE_WRITE can't start process till now,  all the others
 564              *  will have already run
 565              */
 566             if(pipe_mswin_exec_wrapper("pipe command", syspipe,
 567                                        flags, NULL, NULL))
 568               /* some horrible error just occurred */
 569               rv = -1;
 570             else
 571               syspipe->in.f = our_fopen(syspipe->outfile, "rb");
 572         }
 573         else
 574           rv = -1;
 575     }
 576
 577 #else  /* UNIX */
 578
 579     rv = fclose(syspipe->out.f) ? -1 : 0;
 580     syspipe->out.f = NULL;
 581
 582 #endif
 583     return(rv);
 584 }
 585
 586
 587
 588 /*----------------------------------------------------------------------
 589     Close pipe previously allocated and wait for child's death
 590
 591   Args: syspipe -- address of pointer to struct returned by open_system_pipe
 592         exitval -- return exit status here.
 593
 594   Returns:
 595     Two modes of return values for backcompat.
 596       If exitval == NULL
 597          returns exit status of child or -1 if invalid syspipe
 598       If exitval != NULL
 599          returns -1 if invalid syspipe or 0 if ok. In that case, exitval
 600          of child is returned in exitval
 601  ----*/
 602 int
 603 close_system_pipe(PIPE_S **syspipe, int *exitval, void (*pipecb_f) (PIPE_S *, int, void *))
 604 {
 605 #ifdef  _WINDOWS
 606     int rv = 0;
 607     unsigned flags = 0;
 608
 609     if(!(syspipe && *syspipe))
 610       return(-1);
 611
 612     if((*syspipe)->mode & PIPE_STDERR)
 613       flags |= MSWIN_EAW_CAPT_STDERR;
 614
 615     if(((*syspipe)->mode & PIPE_WRITE) && (*syspipe)->out.f){
 616         fclose((*syspipe)->out.f);
 617         /*
 618          * PIPE_WRITE can't start process till now,  all the others
 619          *  will have already run
 620          */
 621         if(pipe_mswin_exec_wrapper("pipe command", (*syspipe),
 622                                    flags, pipecb_f, NULL))
 623           /* some horrible error just occurred */
 624           rv = -1;
 625     }
 626     else if((*syspipe)->mode & PIPE_READ)
 627       if((*syspipe)->in.f)
 628         fclose((*syspipe)->in.f);
 629
 630     if(exitval){
 631         *exitval = (*syspipe)->exit_code;
 632         dprint((5, "Closed pipe: exitval=%d\n", *exitval));
 633     }
 634
 635     if((*syspipe)->infile)
 636       our_unlink((*syspipe)->infile);
 637
 638     if((*syspipe)->outfile && (*syspipe)->deloutfile)
 639       our_unlink((*syspipe)->outfile);
 640
 641     if(rv != -1 && !exitval)
 642       rv = (*syspipe)->exit_code;
 643
 644     zot_pipe(syspipe);
 645
 646 #ifdef  DEBUG
 647     if(!exitval){
 648         dprint((5, "Closed pipe: rv=%d\n", rv));
 649     }
 650 #endif /* DEBUG */
 651
 652     return(rv);
 653
 654 #else  /* UNIX */
 655     int status;
 656
 657     if(!(syspipe && *syspipe))
 658       return -1;
 659
 660     if(((*syspipe)->mode) & PIPE_WRITE){
 661         if(((*syspipe)->mode) & PIPE_DESC){
 662             if((*syspipe)->out.d >= 0)
 663               close((*syspipe)->out.d);
 664         }
 665         else if((*syspipe)->out.f)
 666           fclose((*syspipe)->out.f);
 667     }
 668
 669     if(((*syspipe)->mode) & PIPE_READ){
 670         if(((*syspipe)->mode) & PIPE_DESC){
 671             if((*syspipe)->in.d >= 0)
 672               close((*syspipe)->in.d);
 673         }
 674         else if((*syspipe)->in.f)
 675           fclose((*syspipe)->in.f);
 676     }
 677
 678     if(pipecb_f)
 679       (*pipecb_f)(*syspipe, OSB_PRE_CLOSE, NULL);
 680
 681     /* wait on the child */
 682     (void) process_reap((*syspipe)->pid, &status, PR_NONE);
 683
 684     /* restore original handlers... */
 685     (void) signal(SIGINT,  (*syspipe)->isig);
 686     (void) signal(SIGHUP,  (*syspipe)->hsig);
 687     (void) signal(SIGQUIT, (*syspipe)->qsig);
 688
 689     if((*syspipe)->timeout){
 690         (void)signal(SIGALRM, (*syspipe)->alrm);
 691         alarm((*syspipe)->old_timeo);
 692         child_pid = 0;
 693     }
 694
 695     if(pipecb_f)
 696       (*pipecb_f)(*syspipe, OSB_POST_CLOSE, NULL);
 697
 698     zot_pipe(syspipe);
 699
 700     if(exitval){
 701         *exitval = status;
 702         return 0;
 703     }
 704     else{
 705         return(status);
 706     }
 707 #endif /* UNIX */
 708 }
 709
 710
 711 /*
 712  * process_reap - manage child demise and return exit status
 713  *
 714  *   Args: pid   -- id of process to reap
 715  *         esp   -- pointer to exist status
 716  *         flags -- special reaping considerations
 717  *
 718  *   Returns:
 719  *         < 0 -- if there's a problem
 720  *         0   -- if no child to reap
 721  *         > 0 -- process id of the child
 722  */
 723 pid_t
 724 process_reap(pid_t pid, int *esp, int flags)
 725 {
 726 #ifdef  _WINDOWS
 727
 728     return 0;
 729
 730 #else /* UNIX */
 731     WAITSTATUS_T wstatus;
 732     pid_t        rv;
 733     int          wflags;
 734
 735 #if     HAVE_WAITPID
 736
 737     wflags = 0;
 738
 739 #ifdef  WNOHANG
 740     if(flags & PR_NOHANG)
 741       wflags |= WNOHANG;
 742 #endif
 743
 744     while (((rv = waitpid(pid, &wstatus, wflags)) < 0)  && (errno != ECHILD));
 745
 746 #elif   HAVE_WAIT4
 747
 748     wflags = 0;
 749
 750 #ifdef  WNOHANG
 751     if(flags & PR_NOHANG)
 752       wflags |= WNOHANG;
 753 #endif
 754
 755     while (((rv = wait4(pid,&wstatus,wflags,NULL)) < 0) && (errno != ECHILD));
 756
 757 #elif   HAVE_WAIT
 758
 759     while (((rv = wait(&wstatus)) != pid) && ((rv > 0) || (errno != ECHILD)));
 760
 761 #else
 762
 763     /* BUG: BAIL */
 764
 765 #endif
 766
 767     if(rv > 0)
 768       *esp = (WIFEXITED(wstatus)) ?  (int) WEXITSTATUS(wstatus) : -1;
 769
 770     return(rv);
 771 #endif /* UNIX */
 772 }
 773
 774
 775 #ifndef _WINDOWS
 776 RETSIGTYPE
 777 pipe_alarm(int sig)
 778 {
 779     if(child_pid)
 780       kill(child_pid, SIGINT);
 781 }
 782 #endif /* !_WINDOWS */
 783
 784
 785 #ifdef  _WINDOWS
 786 /*
 787  * Wrapper around mswin_exec_and_wait()
 788  */
 789 int
 790 pipe_mswin_exec_wrapper(char *whatsit,
 791                         PIPE_S *syspipe, unsigned flags,
 792                         void (*pipecb_f)(PIPE_S *, int, void *),
 793                         void (*piperr_f)(char *))
 794 {
 795     int rv;
 796
 797     flags |= MSWIN_EAW_CTRL_C_CANCELS;
 798
 799     if(pipecb_f)
 800       (*pipecb_f)(syspipe, OSB_PRE_OPEN, NULL);
 801
 802     rv = mswin_exec_and_wait(whatsit, syspipe->command,
 803                              syspipe->infile, syspipe->outfile,
 804                              &syspipe->exit_code, flags);
 805
 806     if(pipecb_f)
 807       (*pipecb_f)(syspipe, OSB_POST_OPEN, (void *)rv);
 808
 809     return rv;
 810 }
 811 #endif