popen.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Handling of pipes, child processes, temporary files, file enwrapping.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  * The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by the University of
  22  *    California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef HAVE_AMALGAMATION
  41 # include "nail.h"
  42 #endif
  43
  44 #include <sys/wait.h>
  45
  46 #include <fcntl.h>
  47
  48 #define READ               0
  49 #define WRITE              1
  50
  51 #ifndef O_CLOEXEC
  52 # define _OUR_CLOEXEC
  53 # define O_CLOEXEC         0
  54 # define _SET_CLOEXEC(FD)  do fcntl((FD), F_SETFD, FD_CLOEXEC); while (0)
  55 #else
  56 # define _SET_CLOEXEC(FD)  do {} while (0)
  57 #endif
  58
  59 struct fp {
  60    FILE        *fp;
  61    struct fp   *link;
  62    char        *realfile;
  63    long        offset;
  64    int         omode;
  65    int         pipe;
  66    int         pid;
  67    enum {
  68       FP_RAW      = 0,
  69       FP_GZIP     = 1<<0,
  70       FP_XZ       = 1<<1,
  71       FP_BZIP2    = 1<<2,
  72       FP_IMAP     = 1<<3,
  73       FP_MAILDIR  = 1<<4,
  74       FP_MASK     = (1<<5) - 1,
  75       FP_READONLY = 1<<5
  76    }           compressed;
  77 };
  78
  79 struct child {
  80    int         pid;
  81    char        done;
  82    char        free;
  83    int         status;
  84    struct child *link;
  85 };
  86
  87 static struct fp     *fp_head;
  88 static struct child  *_popen_child;
  89
  90 static int           scan_mode(char const *mode, int *omode);
  91 static void          register_file(FILE *fp, int omode, int ispipe, int pid,
  92                         int compressed, char const *realfile, long offset);
  93 static enum okay     _compress(struct fp *fpp);
  94 static int           _decompress(int compression, int infd, int outfd);
  95 static enum okay     unregister_file(FILE *fp);
  96 static int           file_pid(FILE *fp);
  97 static int           wait_command(int pid);
  98 static struct child *findchild(int pid);
  99 static void          delchild(struct child *cp);
 100
 101 static int
 102 scan_mode(char const *mode, int *omode)
 103 {
 104    static struct {
 105       char const  mode[4];
 106       int         omode;
 107    } const maps[] = {
 108       {"r", O_RDONLY},
 109       {"w", O_WRONLY | O_CREAT | O_TRUNC},
 110       {"wx", O_WRONLY | O_CREAT | O_EXCL},
 111       {"a", O_WRONLY | O_APPEND | O_CREAT},
 112       {"a+", O_RDWR | O_APPEND},
 113       {"r+", O_RDWR},
 114       {"w+", O_RDWR | O_CREAT | O_EXCL}
 115    };
 116
 117    int i;
 118    NYD_ENTER;
 119
 120    for (i = 0; UICMP(z, i, <, NELEM(maps)); ++i)
 121       if (!strcmp(maps[i].mode, mode)) {
 122          *omode = maps[i].omode;
 123          i = 0;
 124          goto jleave;
 125       }
 126
 127    fprintf(stderr, tr(152, "Internal error: bad stdio open mode %s\n"), mode);
 128    errno = EINVAL;
 129    *omode = 0; /* (silence CC) */
 130    i = -1;
 131 jleave:
 132    NYD_LEAVE;
 133    return i;
 134 }
 135
 136 static void
 137 register_file(FILE *fp, int omode, int ispipe, int pid, int compressed,
 138    char const *realfile, long offset)
 139 {
 140    struct fp *fpp;
 141    NYD_ENTER;
 142
 143    fpp = smalloc(sizeof *fpp);
 144    fpp->fp = fp;
 145    fpp->omode = omode;
 146    fpp->pipe = ispipe;
 147    fpp->pid = pid;
 148    fpp->link = fp_head;
 149    fpp->compressed = compressed;
 150    fpp->realfile = realfile ? sstrdup(realfile) : NULL;
 151    fpp->offset = offset;
 152    fp_head = fpp;
 153    NYD_LEAVE;
 154 }
 155
 156 static enum okay
 157 _compress(struct fp *fpp)
 158 {
 159    char const *cmd[2];
 160    int outfd;
 161    enum okay rv;
 162    NYD_ENTER;
 163
 164    if (fpp->omode == O_RDONLY) {
 165       rv = OKAY;
 166       goto jleave;
 167    }
 168    rv = STOP;
 169
 170    fflush(fpp->fp);
 171    clearerr(fpp->fp);
 172    if (fseek(fpp->fp, fpp->offset, SEEK_SET) < 0)
 173       goto jleave;
 174
 175 #ifdef HAVE_IMAP
 176    if ((fpp->compressed & FP_MASK) == FP_IMAP) {
 177       rv = imap_append(fpp->realfile, fpp->fp);
 178       goto jleave;
 179    }
 180 #endif
 181    if ((fpp->compressed & FP_MASK) == FP_MAILDIR) {
 182       rv = maildir_append(fpp->realfile, fpp->fp);
 183       goto jleave;
 184    }
 185
 186    outfd = open(fpp->realfile, (fpp->omode | O_CREAT) & ~O_EXCL, 0666);
 187    if (outfd < 0) {
 188       fprintf(stderr, "Fatal: cannot create ");
 189       perror(fpp->realfile);
 190       goto jleave;
 191    }
 192    if ((fpp->omode & O_APPEND) == 0)
 193       ftruncate(outfd, 0);
 194    switch (fpp->compressed & FP_MASK) {
 195    case FP_GZIP:
 196       cmd[0] = "gzip";  cmd[1] = "-c"; break;
 197    case FP_BZIP2:
 198       cmd[0] = "bzip2"; cmd[1] = "-c"; break;
 199    case FP_XZ:
 200       cmd[0] = "xz";    cmd[1] = "-c"; break;
 201    default:
 202       cmd[0] = "cat";   cmd[1] = NULL; break;
 203    }
 204    if (run_command(cmd[0], 0, fileno(fpp->fp), outfd, cmd[1], NULL, NULL) >= 0)
 205       rv = OKAY;
 206    close(outfd);
 207 jleave:
 208    NYD_LEAVE;
 209    return rv;
 210 }
 211
 212 static int
 213 _decompress(int compression, int infd, int outfd)
 214 {
 215    char const *cmd[2];
 216    int rv;
 217    NYD_ENTER;
 218
 219    switch (compression & FP_MASK) {
 220    case FP_GZIP:     cmd[0] = "gzip";  cmd[1] = "-cd"; break;
 221    case FP_BZIP2:    cmd[0] = "bzip2"; cmd[1] = "-cd"; break;
 222    case FP_XZ:       cmd[0] = "xz";    cmd[1] = "-cd"; break;
 223    default:          cmd[0] = "cat";   cmd[1] = NULL;  break;
 224    case FP_IMAP:
 225    case FP_MAILDIR:
 226       rv = 0;
 227       goto jleave;
 228    }
 229    rv = run_command(cmd[0], 0, infd, outfd, cmd[1], NULL, NULL);
 230 jleave:
 231    NYD_LEAVE;
 232    return rv;
 233 }
 234
 235 static enum okay
 236 unregister_file(FILE *fp)
 237 {
 238    struct fp **pp, *p;
 239    enum okay rv = OKAY;
 240    NYD_ENTER;
 241
 242    for (pp = &fp_head; (p = *pp) != NULL; pp = &p->link)
 243       if (p->fp == fp) {
 244          if ((p->compressed & FP_MASK) != FP_RAW) /* TODO ;} */
 245             rv = _compress(p);
 246          *pp = p->link;
 247          free(p);
 248          goto jleave;
 249       }
 250 #ifdef HAVE_DEBUG
 251    panic
 252 #else
 253    alert
 254 #endif
 255       (tr(153, "Invalid file pointer"));
 256    rv = STOP;
 257 jleave:
 258    NYD_LEAVE;
 259    return rv;
 260 }
 261
 262 static int
 263 file_pid(FILE *fp)
 264 {
 265    int rv;
 266    struct fp *p;
 267    NYD_ENTER;
 268
 269    rv = -1;
 270    for (p = fp_head; p; p = p->link)
 271       if (p->fp == fp) {
 272          rv = p->pid;
 273          break;
 274       }
 275    NYD_LEAVE;
 276    return rv;
 277 }
 278
 279 static int
 280 wait_command(int pid)
 281 {
 282    int rv = 0;
 283    NYD_ENTER;
 284
 285    if (!wait_child(pid, NULL)) {
 286       if (ok_blook(bsdcompat) || ok_blook(bsdmsgs))
 287          fprintf(stderr, tr(154, "Fatal error in process.\n"));
 288       rv = -1;
 289    }
 290    NYD_LEAVE;
 291    return rv;
 292 }
 293
 294 static struct child *
 295 findchild(int pid)
 296 {
 297    struct child **cpp;
 298    NYD_ENTER;
 299
 300    for (cpp = &_popen_child; *cpp != NULL && (*cpp)->pid != pid;
 301          cpp = &(*cpp)->link)
 302       ;
 303    if (*cpp == NULL) {
 304       *cpp = smalloc(sizeof **cpp);
 305       (*cpp)->pid = pid;
 306       (*cpp)->done = (*cpp)->free = 0;
 307       (*cpp)->link = NULL;
 308    }
 309    NYD_LEAVE;
 310    return *cpp;
 311 }
 312
 313 static void
 314 delchild(struct child *cp)
 315 {
 316    struct child **cpp;
 317    NYD_ENTER;
 318
 319    for (cpp = &_popen_child; *cpp != cp; cpp = &(*cpp)->link)
 320       ;
 321    *cpp = cp->link;
 322    free(cp);
 323    NYD_LEAVE;
 324 }
 325
 326 FL FILE *
 327 safe_fopen(char const *file, char const *oflags, int *xflags)
 328 {
 329    int osflags, fd;
 330    FILE *fp = NULL;
 331    NYD_ENTER;
 332
 333    if (scan_mode(oflags, &osflags) < 0)
 334       goto jleave;
 335    osflags |= O_CLOEXEC;
 336    if (xflags != NULL)
 337       *xflags = osflags;
 338
 339    if ((fd = open(file, osflags, 0666)) < 0)
 340       goto jleave;
 341    _SET_CLOEXEC(fd);
 342
 343    fp = fdopen(fd, oflags);
 344 jleave:
 345    NYD_LEAVE;
 346    return fp;
 347 }
 348
 349 FL FILE *
 350 Fopen(char const *file, char const *oflags)
 351 {
 352    FILE *fp;
 353    int osflags;
 354    NYD_ENTER;
 355
 356    if ((fp = safe_fopen(file, oflags, &osflags)) != NULL)
 357       register_file(fp, osflags, 0, 0, FP_RAW, NULL, 0L);
 358    NYD_LEAVE;
 359    return fp;
 360 }
 361
 362 FL FILE *
 363 Fdopen(int fd, char const *oflags)
 364 {
 365    FILE *fp;
 366    int osflags;
 367    NYD_ENTER;
 368
 369    scan_mode(oflags, &osflags);
 370    osflags |= O_CLOEXEC;
 371
 372    if ((fp = fdopen(fd, oflags)) != NULL)
 373       register_file(fp, osflags, 0, 0, FP_RAW, NULL, 0L);
 374    NYD_LEAVE;
 375    return fp;
 376 }
 377
 378 FL int
 379 Fclose(FILE *fp)
 380 {
 381    int i = 0;
 382    NYD_ENTER;
 383
 384    if (unregister_file(fp) == OKAY)
 385       i |= 1;
 386    if (fclose(fp) == 0)
 387       i |= 2;
 388    NYD_LEAVE;
 389    return i == 3 ? 0 : EOF;
 390 }
 391
 392 FL FILE *
 393 Zopen(char const *file, char const *oflags, int *compression) /* FIXME MESS! */
 394 {
 395    FILE *rv = NULL;
 396    int _compression, osflags, mode, infd;
 397    enum oflags rof;
 398    long offset;
 399    enum protocol p;
 400    NYD_ENTER;
 401
 402    if (compression == NULL)
 403       compression = &_compression;
 404
 405    if (scan_mode(oflags, &osflags) < 0)
 406       goto jleave;
 407    rof = OF_RDWR | OF_UNLINK;
 408    if (osflags & O_APPEND)
 409       rof |= OF_APPEND;
 410    if (osflags == O_RDONLY) {
 411       mode = R_OK;
 412       *compression = FP_READONLY;
 413    } else {
 414       mode = R_OK | W_OK;
 415       *compression = 0;
 416    }
 417
 418    /* TODO ???? */
 419    if ((osflags & O_APPEND) && ((p = which_protocol(file)) == PROTO_IMAP ||
 420          p == PROTO_MAILDIR)) {
 421       *compression |= (p == PROTO_IMAP) ? FP_IMAP : FP_MAILDIR;
 422       osflags = O_RDWR | O_APPEND | O_CREAT;
 423       infd = -1;
 424    } else {
 425       char const *ext;
 426
 427       if ((ext = strrchr(file, '.')) != NULL) {
 428          if (!strcmp(ext, ".gz"))
 429             *compression |= FP_GZIP;
 430          else if (!strcmp(ext, ".xz"))
 431             *compression |= FP_XZ;
 432          else if (!strcmp(ext, ".bz2"))
 433             *compression |= FP_BZIP2;
 434          else
 435             goto jraw;
 436       } else {
 437 jraw:
 438          *compression |= FP_RAW;
 439          rv = Fopen(file, oflags);
 440          goto jleave;
 441       }
 442       if ((infd = open(file, (mode & W_OK) ? O_RDWR : O_RDONLY)) == -1 &&
 443             (!(osflags & O_CREAT) || errno != ENOENT))
 444          goto jleave;
 445    }
 446
 447    if ((rv = Ftmp(NULL, "zopen", rof, 0600)) == NULL) {
 448       perror(tr(167, "tmpfile"));
 449       goto jerr;
 450    }
 451    if (infd >= 0 || (*compression & FP_MASK) == FP_IMAP ||
 452          (*compression & FP_MASK) == FP_MAILDIR) {
 453       if (_decompress(*compression, infd, fileno(rv)) < 0) {
 454 jerr:
 455          if (rv != NULL)
 456             Fclose(rv);
 457          rv = NULL;
 458          if (infd >= 0)
 459             close(infd);
 460          goto jleave;
 461       }
 462    } else {
 463       if ((infd = creat(file, 0666)) == -1) {
 464          Fclose(rv);
 465          rv = NULL;
 466          goto jleave;
 467       }
 468    }
 469    if (infd >= 0)
 470       close(infd);
 471    fflush(rv);
 472
 473    if (!(osflags & O_APPEND))
 474       rewind(rv);
 475    if ((offset = ftell(rv)) == -1) {
 476       Fclose(rv);
 477       rv = NULL;
 478       goto jleave;
 479    }
 480    register_file(rv, osflags, 0, 0, *compression, file, offset);
 481 jleave:
 482    NYD_LEAVE;
 483    return rv;
 484 }
 485
 486 FL FILE *
 487 Ftmp(char **fn, char const *prefix, enum oflags oflags, int mode)
 488 {
 489    FILE *fp = NULL;
 490    char *cp_base, *cp;
 491    int fd;
 492    NYD_ENTER;
 493
 494    cp_base =
 495    cp = smalloc(strlen(tempdir) + 1 + sizeof("mail") + strlen(prefix) + 7 +1);
 496    cp = sstpcpy(cp, tempdir);
 497    *cp++ = '/';
 498    cp = sstpcpy(cp, "mail");
 499    if (*prefix) {
 500       *cp++ = '-';
 501       cp = sstpcpy(cp, prefix);
 502    }
 503    /* TODO Ftmp(): unroll our own creation loop with atoi(random()) */
 504    sstpcpy(cp, ".XXXXXX");
 505
 506    hold_all_sigs();
 507 #ifdef HAVE_MKSTEMP
 508    if ((fd = mkstemp(cp_base)) == -1)
 509       goto jfree;
 510    if (mode != (S_IRUSR | S_IWUSR) && fchmod(fd, mode) == -1)
 511       goto jclose;
 512    if (oflags & OF_APPEND) {
 513       int f;
 514
 515       if ((f = fcntl(fd, F_GETFL)) == -1 ||
 516             fcntl(fd, F_SETFL, f | O_APPEND) == -1) {
 517 jclose:
 518          close(fd);
 519          goto junlink;
 520       }
 521    }
 522    if (!(oflags & OF_REGISTER))
 523       fcntl(fd, F_SETFD, FD_CLOEXEC);
 524 #else
 525    if (mktemp(cp_base) == NULL)
 526       goto jfree;
 527    if ((fd = open(cp_base, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC |
 528          (oflags & OF_APPEND ? O_APPEND : 0), mode)) < 0)
 529       goto junlink;
 530    if (!(oflags & OF_REGISTER))
 531       _SET_CLOEXEC(fd);
 532 #endif
 533
 534    fp = (*((oflags & OF_REGISTER) ? &Fdopen : &fdopen))(fd,
 535          (oflags & OF_RDWR ? "w+" : "w"));
 536    if (fp == NULL || (oflags & OF_UNLINK)) {
 537 junlink:
 538       unlink(cp_base);
 539       goto jfree;
 540    }
 541
 542    if (fn != NULL)
 543       *fn = cp_base;
 544 jleave:
 545    if (fp == NULL || !(oflags & OF_HOLDSIGS))
 546       rele_all_sigs();
 547    NYD_LEAVE;
 548    return fp;
 549 jfree:
 550    if ((cp = cp_base) != NULL)
 551       free(cp);
 552    goto jleave;
 553 }
 554
 555 FL void
 556 Ftmp_release(char **fn)
 557 {
 558    char *cp;
 559    NYD_ENTER;
 560
 561    cp = *fn;
 562    *fn = NULL;
 563    if (cp != NULL) {
 564       unlink(cp);
 565       rele_all_sigs();
 566       free(cp);
 567    }
 568    NYD_LEAVE;
 569 }
 570
 571 FL void
 572 Ftmp_free(char **fn)
 573 {
 574    char *cp;
 575    NYD_ENTER;
 576
 577    cp = *fn;
 578    *fn = NULL;
 579    if (cp != NULL)
 580       free(cp);
 581    NYD_LEAVE;
 582 }
 583
 584 FL bool_t
 585 pipe_cloexec(int fd[2])
 586 {
 587    bool_t rv = FAL0;
 588    NYD_ENTER;
 589
 590    if (pipe(fd) < 0)
 591       goto jleave;
 592    fcntl(fd[0], F_SETFD, FD_CLOEXEC);
 593    fcntl(fd[1], F_SETFD, FD_CLOEXEC);
 594    rv = TRU1;
 595 jleave:
 596    NYD_LEAVE;
 597    return rv;
 598 }
 599
 600 FL FILE *
 601 Popen(char const *cmd, char const *mode, char const *sh, int newfd1)
 602 {
 603    int p[2], myside, hisside, fd0, fd1, pid;
 604    char mod[2] = { '0', '\0' };
 605    sigset_t nset;
 606    FILE *rv = NULL;
 607    NYD_ENTER;
 608
 609    if (!pipe_cloexec(p))
 610       goto jleave;
 611
 612    if (*mode == 'r') {
 613       myside = p[READ];
 614       fd0 = -1;
 615       hisside = fd1 = p[WRITE];
 616       mod[0] = *mode;
 617    } else if (*mode == 'W') {
 618       myside = p[WRITE];
 619       hisside = fd0 = p[READ];
 620       fd1 = newfd1;
 621       mod[0] = 'w';
 622    } else {
 623       myside = p[WRITE];
 624       hisside = fd0 = p[READ];
 625       fd1 = -1;
 626       mod[0] = 'w';
 627    }
 628    sigemptyset(&nset);
 629    if (sh == NULL) {
 630       pid = start_command(cmd, &nset, fd0, fd1, NULL, NULL, NULL);
 631    } else {
 632       pid = start_command(sh, &nset, fd0, fd1, "-c", cmd, NULL);
 633    }
 634    if (pid < 0) {
 635       close(p[READ]);
 636       close(p[WRITE]);
 637       goto jleave;
 638    }
 639    close(hisside);
 640    if ((rv = fdopen(myside, mod)) != NULL)
 641       register_file(rv, 0, 1, pid, FP_RAW, NULL, 0L);
 642 jleave:
 643    NYD_LEAVE;
 644    return rv;
 645 }
 646
 647 FL bool_t
 648 Pclose(FILE *ptr, bool_t dowait)
 649 {
 650    sigset_t nset, oset;
 651    int pid;
 652    bool_t rv = FAL0;
 653    NYD_ENTER;
 654
 655    pid = file_pid(ptr);
 656    if (pid < 0)
 657       goto jleave;
 658    unregister_file(ptr);
 659    fclose(ptr);
 660    if (dowait) {
 661       sigemptyset(&nset);
 662       sigaddset(&nset, SIGINT);
 663       sigaddset(&nset, SIGHUP);
 664       sigprocmask(SIG_BLOCK, &nset, &oset);
 665       rv = wait_child(pid, NULL);
 666       sigprocmask(SIG_SETMASK, &oset, NULL);
 667    } else {
 668       free_child(pid);
 669       rv = TRU1;
 670    }
 671 jleave:
 672    NYD_LEAVE;
 673    return rv;
 674 }
 675
 676 FL void
 677 close_all_files(void)
 678 {
 679    NYD_ENTER;
 680    while (fp_head != NULL)
 681       if (fp_head->pipe)
 682          Pclose(fp_head->fp, TRU1);
 683       else
 684          Fclose(fp_head->fp);
 685    NYD_LEAVE;
 686 }
 687
 688 FL int
 689 run_command(char const *cmd, sigset_t *mask, int infd, int outfd,
 690    char const *a0, char const *a1, char const *a2)
 691 {
 692    int rv;
 693    NYD_ENTER;
 694
 695    if ((rv = start_command(cmd, mask, infd, outfd, a0, a1, a2)) < 0)
 696       rv = -1;
 697    else
 698       rv = wait_command(rv);
 699    NYD_LEAVE;
 700    return rv;
 701 }
 702
 703 FL int
 704 start_command(char const *cmd, sigset_t *mask, int infd, int outfd,
 705    char const *a0, char const *a1, char const *a2)
 706 {
 707    int rv;
 708    NYD_ENTER;
 709
 710    if ((rv = fork()) < 0) {
 711       perror("fork");
 712       rv = -1;
 713    } else if (rv == 0) {
 714       char *argv[100];
 715       int i = getrawlist(cmd, strlen(cmd), argv, NELEM(argv), 0);
 716
 717       if ((argv[i++] = UNCONST(a0)) != NULL &&
 718           (argv[i++] = UNCONST(a1)) != NULL &&
 719           (argv[i++] = UNCONST(a2)) != NULL)
 720          argv[i] = NULL;
 721       prepare_child(mask, infd, outfd);
 722       execvp(argv[0], argv);
 723       perror(argv[0]);
 724       _exit(1);
 725    }
 726    NYD_LEAVE;
 727    return rv;
 728 }
 729
 730 FL void
 731 prepare_child(sigset_t *nset, int infd, int outfd)
 732 {
 733    int i;
 734    sigset_t fset;
 735    NYD_ENTER;
 736
 737    /* All file descriptors other than 0, 1, and 2 are supposed to be cloexec */
 738    if (infd >= 0)
 739       dup2(infd, 0);
 740    if (outfd >= 0)
 741       dup2(outfd, 1);
 742
 743    if (nset) {
 744       for (i = 1; i < NSIG; ++i)
 745          if (sigismember(nset, i))
 746             safe_signal(i, SIG_IGN);
 747       if (!sigismember(nset, SIGINT))
 748          safe_signal(SIGINT, SIG_DFL);
 749    }
 750
 751    sigemptyset(&fset);
 752    sigprocmask(SIG_SETMASK, &fset, NULL);
 753    NYD_LEAVE;
 754 }
 755
 756 FL void
 757 sigchild(int signo)
 758 {
 759    int pid, status;
 760    struct child *cp;
 761    NYD_X; /* Signal handler */
 762    UNUSED(signo);
 763
 764 jagain:
 765    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
 766       cp = findchild(pid);
 767       if (cp->free)
 768          delchild(cp);
 769       else {
 770          cp->done = 1;
 771          cp->status = status;
 772       }
 773    }
 774    if (pid == -1 && errno == EINTR)
 775       goto jagain;
 776 }
 777
 778 FL void
 779 free_child(int pid)
 780 {
 781    sigset_t nset, oset;
 782    struct child *cp;
 783    NYD_ENTER;
 784
 785    sigemptyset(&nset);
 786    sigaddset(&nset, SIGCHLD);
 787    sigprocmask(SIG_BLOCK, &nset, &oset);
 788
 789    cp = findchild(pid);
 790    if (cp->done)
 791       delchild(cp);
 792    else
 793       cp->free = 1;
 794
 795    sigprocmask(SIG_SETMASK, &oset, NULL);
 796    NYD_LEAVE;
 797 }
 798
 799 FL bool_t
 800 wait_child(int pid, int *wait_status)
 801 {
 802    sigset_t nset, oset;
 803    struct child *cp;
 804    int ws;
 805    bool_t rv;
 806    NYD_ENTER;
 807
 808    sigemptyset(&nset);
 809    sigaddset(&nset, SIGCHLD);
 810    sigprocmask(SIG_BLOCK, &nset, &oset);
 811
 812    cp = findchild(pid);
 813    while (!cp->done)
 814       sigsuspend(&oset);
 815    ws = cp->status;
 816    delchild(cp);
 817
 818    sigprocmask(SIG_SETMASK, &oset, NULL);
 819
 820    if (wait_status != NULL)
 821       *wait_status = ws;
 822    rv = (WIFEXITED(ws) && WEXITSTATUS(ws) == 0);
 823    NYD_LEAVE;
 824    return rv;
 825 }
 826
 827 #ifdef _OUR_CLOEXEC
 828 # undef O_CLOEXEC
 829 # undef _OUR_CLOEXEC
 830 #endif
 831 #undef _SET_CLOEXEC
 832
 833 /* vim:set fenc=utf-8:s-it-mode */