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 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   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. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE popen
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 #define READ               0
  43 #define WRITE              1
  44
  45 struct fp {
  46    struct fp   *link;
  47    int         omode;
  48    int         pid;
  49    enum {
  50       FP_RAW,
  51
  52 FP_IMAP = 1u<<3,
  53       FP_MAILDIR = 1u<<4,
  54       FP_HOOK = 1u<<5,
  55       FP_PIPE = 1u<<6,
  56       FP_MASK = (1u<<7) - 1,
  57       /* TODO FP_UNLINK: should be in a separated process so that unlinking
  58        * TODO the temporary "garbage" is "safe"(r than it is like that) */
  59       FP_UNLINK = 1u<<9,
  60       FP_TERMIOS = 1u<<10
  61    }           flags;
  62    long        offset;
  63    FILE        *fp;
  64    char        *realfile;
  65    char        *save_cmd;
  66    struct termios *fp_tios;
  67    n_sighdl_t fp_osigint;     /* Only if FP_TERMIOS */
  68 };
  69
  70 struct child {
  71    int         pid;
  72    char        done;
  73    char        free;
  74    int         status;
  75    struct child *link;
  76 };
  77
  78 static struct fp     *fp_head;
  79 static struct child  *_popen_child;
  80
  81 /* TODO Rather temporary: deal with job control with FD_PASS */
  82 static struct termios a_popen_tios;
  83 static sighandler_type a_popen_otstp, a_popen_ottin, a_popen_ottou;
  84 static volatile int a_popen_hadsig;
  85
  86 static int a_popen_scan_mode(char const *mode, int *omode);
  87 static void          register_file(FILE *fp, int omode, int pid,
  88                         int flags, char const *realfile, long offset,
  89                         char const *save_cmd, struct termios *tiosp,
  90                         n_sighdl_t osigint);
  91 static enum okay _file_save(struct fp *fpp);
  92 static int a_popen_file_load(int flags, int infd, int outfd,
  93             char const *load_cmd);
  94 static enum okay     unregister_file(FILE *fp, struct termios **tiosp,
  95                         n_sighdl_t *osigint);
  96 static int           file_pid(FILE *fp);
  97
  98 /* TODO Rather temporary: deal with job control with FD_PASS */
  99 static void a_popen_jobsigs_up(void);
 100 static void a_popen_jobsigs_down(void);
 101 static void a_popen_jobsig(int sig);
 102
 103 /* Handle SIGCHLD */
 104 static void a_popen_sigchld(int signo);
 105
 106 static struct child *a_popen_child_find(int pid, bool_t create);
 107 static void a_popen_child_del(struct child *cp);
 108
 109 static int
 110 a_popen_scan_mode(char const *mode, int *omode){
 111    static struct{
 112       char const mode[4];
 113       int omode;
 114    } const maps[] = {
 115       {"r", O_RDONLY},
 116       {"w", O_WRONLY | O_CREAT | n_O_NOFOLLOW | O_TRUNC},
 117       {"wx", O_WRONLY | O_CREAT | O_EXCL},
 118       {"a", O_WRONLY | O_APPEND | O_CREAT | n_O_NOFOLLOW},
 119       {"a+", O_RDWR | O_APPEND | O_CREAT | n_O_NOFOLLOW},
 120       {"r+", O_RDWR},
 121       {"w+", O_RDWR | O_CREAT | O_EXCL}
 122    };
 123    int i;
 124    NYD2_ENTER;
 125
 126    for(i = 0; UICMP(z, i, <, n_NELEM(maps)); ++i)
 127       if(!strcmp(maps[i].mode, mode)){
 128          *omode = maps[i].omode;
 129          i = 0;
 130          goto jleave;
 131       }
 132
 133    DBG( n_alert(_("Internal error: bad stdio open mode %s"), mode); )
 134    n_err_no = n_ERR_INVAL;
 135    *omode = 0; /* (silence CC) */
 136    i = -1;
 137 jleave:
 138    NYD2_LEAVE;
 139    return i;
 140 }
 141
 142 static void
 143 register_file(FILE *fp, int omode, int pid, int flags,
 144    char const *realfile, long offset, char const *save_cmd,
 145    struct termios *tiosp, n_sighdl_t osigint)
 146 {
 147    struct fp *fpp;
 148    NYD_ENTER;
 149
 150    assert(!(flags & FP_UNLINK) || realfile != NULL);
 151    assert(!(flags & FP_TERMIOS) || tiosp != NULL);
 152
 153    fpp = smalloc(sizeof *fpp);
 154    fpp->fp = fp;
 155    fpp->omode = omode;
 156    fpp->pid = pid;
 157    fpp->link = fp_head;
 158    fpp->flags = flags;
 159    fpp->realfile = (realfile != NULL) ? sstrdup(realfile) : NULL;
 160    fpp->save_cmd = (save_cmd != NULL) ? sstrdup(save_cmd) : NULL;
 161    fpp->fp_tios = tiosp;
 162    fpp->fp_osigint = osigint;
 163    fpp->offset = offset;
 164    fp_head = fpp;
 165    NYD_LEAVE;
 166 }
 167
 168 static enum okay
 169 _file_save(struct fp *fpp)
 170 {
 171    char const *cmd[3];
 172    int outfd;
 173    enum okay rv;
 174    NYD_ENTER;
 175
 176    if (fpp->omode == O_RDONLY) {
 177       rv = OKAY;
 178       goto jleave;
 179    }
 180    rv = STOP;
 181
 182    fflush(fpp->fp);
 183    clearerr(fpp->fp);
 184
 185    /* Ensure the I/O library doesn't optimize the fseek(3) away! */
 186    if(!n_real_seek(fpp->fp, fpp->offset, SEEK_SET)){
 187       outfd = n_err_no;
 188       n_err(_("Fatal: cannot restore file position and save %s: %s\n"),
 189          n_shexp_quote_cp(fpp->realfile, FAL0), n_err_to_doc(outfd));
 190       goto jleave;
 191    }
 192
 193 #ifdef HAVE_IMAP
 194    if ((fpp->flags & FP_MASK) == FP_IMAP) {
 195       rv = imap_append(fpp->realfile, fpp->fp, fpp->offset);
 196       goto jleave;
 197    }
 198 #endif
 199
 200    if ((fpp->flags & FP_MASK) == FP_MAILDIR) {
 201       rv = maildir_append(fpp->realfile, fpp->fp, fpp->offset);
 202       goto jleave;
 203    }
 204
 205    outfd = open(fpp->realfile,
 206          ((fpp->omode | O_CREAT | (fpp->omode & O_APPEND ? 0 : O_TRUNC) |
 207             n_O_NOFOLLOW) & ~O_EXCL), 0666);
 208    if (outfd == -1) {
 209       outfd = n_err_no;
 210       n_err(_("Fatal: cannot create %s: %s\n"),
 211          n_shexp_quote_cp(fpp->realfile, FAL0), n_err_to_doc(outfd));
 212       goto jleave;
 213    }
 214
 215    cmd[2] = NULL;
 216    switch(fpp->flags & FP_MASK){
 217    case FP_HOOK:
 218       cmd[0] = ok_vlook(SHELL);
 219       cmd[1] = "-c";
 220       cmd[2] = fpp->save_cmd;
 221       break;
 222    default:
 223       cmd[0] = "cat";
 224       cmd[1] = NULL;
 225       break;
 226    }
 227    if (n_child_run(cmd[0], 0, fileno(fpp->fp), outfd,
 228          cmd[1], cmd[2], NULL, NULL, NULL) >= 0)
 229       rv = OKAY;
 230
 231    close(outfd);
 232 jleave:
 233    NYD_LEAVE;
 234    return rv;
 235 }
 236
 237 static int
 238 a_popen_file_load(int flags, int infd, int outfd, char const *load_cmd){
 239    char const *cmd[3];
 240    int rv;
 241    NYD2_ENTER;
 242
 243    cmd[2] = NULL;
 244    switch(flags & FP_MASK){
 245    case FP_IMAP:
 246    case FP_MAILDIR:
 247       rv = 0;
 248       goto jleave;
 249    case FP_HOOK:
 250       cmd[0] = ok_vlook(SHELL);
 251       cmd[1] = "-c";
 252       cmd[2] = load_cmd;
 253       break;
 254    default:
 255       cmd[0] = "cat";
 256       cmd[1] = NULL;
 257       break;
 258    }
 259
 260    rv = n_child_run(cmd[0], 0, infd, outfd, cmd[1], cmd[2], NULL, NULL, NULL);
 261 jleave:
 262    NYD2_LEAVE;
 263    return rv;
 264 }
 265
 266 static enum okay
 267 unregister_file(FILE *fp, struct termios **tiosp, n_sighdl_t *osigint)
 268 {
 269    struct fp **pp, *p;
 270    enum okay rv = OKAY;
 271    NYD_ENTER;
 272
 273    if (tiosp)
 274       *tiosp = NULL;
 275
 276    for (pp = &fp_head; (p = *pp) != NULL; pp = &p->link)
 277       if (p->fp == fp) {
 278          switch (p->flags & FP_MASK) {
 279          case FP_RAW:
 280          case FP_PIPE:
 281             break;
 282          default:
 283             rv = _file_save(p);
 284             break;
 285          }
 286          if ((p->flags & FP_UNLINK) && unlink(p->realfile))
 287             rv = STOP;
 288
 289          *pp = p->link;
 290          if (p->save_cmd != NULL)
 291             free(p->save_cmd);
 292          if (p->realfile != NULL)
 293             free(p->realfile);
 294          if (p->flags & FP_TERMIOS) {
 295             if (tiosp != NULL) {
 296                *tiosp = p->fp_tios;
 297                *osigint = p->fp_osigint;
 298             } else
 299                free(p->fp_tios);
 300          }
 301          free(p);
 302          goto jleave;
 303       }
 304    DBGOR(n_panic, n_alert)(_("Invalid file pointer"));
 305    rv = STOP;
 306 jleave:
 307    NYD_LEAVE;
 308    return rv;
 309 }
 310
 311 static int
 312 file_pid(FILE *fp)
 313 {
 314    int rv;
 315    struct fp *p;
 316    NYD2_ENTER;
 317
 318    rv = -1;
 319    for (p = fp_head; p; p = p->link)
 320       if (p->fp == fp) {
 321          rv = p->pid;
 322          break;
 323       }
 324    NYD2_LEAVE;
 325    return rv;
 326 }
 327
 328 static void
 329 a_popen_jobsigs_up(void){
 330    sigset_t nset, oset;
 331    NYD2_ENTER;
 332
 333    sigfillset(&nset);
 334
 335    sigprocmask(SIG_BLOCK, &nset, &oset);
 336    a_popen_otstp = safe_signal(SIGTSTP, &a_popen_jobsig);
 337    a_popen_ottin = safe_signal(SIGTTIN, &a_popen_jobsig);
 338    a_popen_ottou = safe_signal(SIGTTOU, &a_popen_jobsig);
 339
 340    /* This assumes oset contains nothing but SIGCHLD, so to say */
 341    sigdelset(&oset, SIGTSTP);
 342    sigdelset(&oset, SIGTTIN);
 343    sigdelset(&oset, SIGTTOU);
 344    sigprocmask(SIG_SETMASK, &oset, NULL);
 345    NYD2_LEAVE;
 346 }
 347
 348 static void
 349 a_popen_jobsigs_down(void){
 350    sigset_t nset, oset;
 351    NYD2_ENTER;
 352
 353    sigfillset(&nset);
 354
 355    sigprocmask(SIG_BLOCK, &nset, &oset);
 356    safe_signal(SIGTSTP, a_popen_otstp);
 357    safe_signal(SIGTTIN, a_popen_ottin);
 358    safe_signal(SIGTTOU, a_popen_ottou);
 359
 360    sigaddset(&oset, SIGTSTP);
 361    sigaddset(&oset, SIGTTIN);
 362    sigaddset(&oset, SIGTTOU);
 363    sigprocmask(SIG_SETMASK, &oset, NULL);
 364    NYD2_LEAVE;
 365 }
 366
 367 static void
 368 a_popen_jobsig(int sig){
 369    sighandler_type oldact;
 370    sigset_t nset;
 371    bool_t hadsig;
 372    NYD_X; /* Signal handler */
 373
 374    hadsig = (a_popen_hadsig != 0);
 375    a_popen_hadsig = 1;
 376    if(!hadsig)
 377       n_TERMCAP_SUSPEND(TRU1);
 378
 379    oldact = safe_signal(sig, SIG_DFL);
 380
 381    sigemptyset(&nset);
 382    sigaddset(&nset, sig);
 383    sigprocmask(SIG_UNBLOCK, &nset, NULL);
 384    n_raise(sig);
 385    sigprocmask(SIG_BLOCK, &nset, NULL);
 386
 387    safe_signal(sig, oldact);
 388 }
 389
 390 static void
 391 a_popen_sigchld(int signo){
 392    pid_t pid;
 393    int status;
 394    struct child *cp;
 395    NYD_X; /* Signal handler */
 396    n_UNUSED(signo);
 397
 398    for (;;) {
 399       pid = waitpid(-1, &status, WNOHANG);
 400       if (pid <= 0) {
 401          if (pid == -1 && n_err_no == n_ERR_INTR)
 402             continue;
 403          break;
 404       }
 405
 406       if ((cp = a_popen_child_find(pid, FAL0)) != NULL) {
 407          cp->done = 1;
 408          if (cp->free)
 409             cp->pid = -1; /* XXX Was _delchild(cp);# */
 410          else {
 411             cp->status = status;
 412          }
 413       }
 414    }
 415 }
 416
 417 static struct child *
 418 a_popen_child_find(int pid, bool_t create){
 419    struct child **cpp, *cp;
 420    NYD2_ENTER;
 421
 422    for(cpp = &_popen_child; (cp = *cpp) != NULL && cp->pid != pid;
 423          cpp = &(*cpp)->link)
 424       ;
 425
 426    if(cp == NULL && create)
 427       (*cpp = cp = scalloc(1, sizeof *cp))->pid = pid;
 428    NYD2_LEAVE;
 429    return cp;
 430 }
 431
 432 static void
 433 a_popen_child_del(struct child *cp){
 434    struct child **cpp;
 435    NYD2_ENTER;
 436
 437    cpp = &_popen_child;
 438
 439    for(;;){
 440       if(*cpp == cp){
 441          *cpp = cp->link;
 442          free(cp);
 443          break;
 444       }
 445       if(*(cpp = &(*cpp)->link) == NULL){
 446          DBG( n_err("! a_popen_child_del(): implementation error\n"); )
 447          break;
 448       }
 449    }
 450    NYD2_LEAVE;
 451 }
 452
 453 FL void
 454 n_child_manager_start(void)
 455 {
 456    struct sigaction nact, oact;
 457    NYD_ENTER;
 458
 459    nact.sa_handler = &a_popen_sigchld;
 460    sigemptyset(&nact.sa_mask);
 461    nact.sa_flags = SA_RESTART
 462 #ifdef SA_NOCLDSTOP
 463          | SA_NOCLDSTOP
 464 #endif
 465          ;
 466    if (sigaction(SIGCHLD, &nact, &oact) != 0)
 467       n_panic(_("Cannot install signal handler for child process management"));
 468    NYD_LEAVE;
 469 }
 470
 471 FL FILE *
 472 safe_fopen(char const *file, char const *oflags, int *xflags)
 473 {
 474    int osflags, fd;
 475    FILE *fp = NULL;
 476    NYD2_ENTER; /* (only for Fopen() and once in go.c) */
 477
 478    if (a_popen_scan_mode(oflags, &osflags) < 0)
 479       goto jleave;
 480    osflags |= _O_CLOEXEC;
 481    if (xflags != NULL)
 482       *xflags = osflags;
 483
 484    if ((fd = open(file, osflags, 0666)) == -1)
 485       goto jleave;
 486    _CLOEXEC_SET(fd);
 487
 488    fp = fdopen(fd, oflags);
 489 jleave:
 490    NYD2_LEAVE;
 491    return fp;
 492 }
 493
 494 FL FILE *
 495 Fopen(char const *file, char const *oflags)
 496 {
 497    FILE *fp;
 498    int osflags;
 499    NYD_ENTER;
 500
 501    if ((fp = safe_fopen(file, oflags, &osflags)) != NULL)
 502       register_file(fp, osflags, 0, FP_RAW, NULL, 0L, NULL, NULL,NULL);
 503    NYD_LEAVE;
 504    return fp;
 505 }
 506
 507 FL FILE *
 508 Fdopen(int fd, char const *oflags, bool_t nocloexec)
 509 {
 510    FILE *fp;
 511    int osflags;
 512    NYD_ENTER;
 513
 514    a_popen_scan_mode(oflags, &osflags);
 515    if (!nocloexec)
 516       osflags |= _O_CLOEXEC; /* Ensured to be set by caller as documented! */
 517
 518    if ((fp = fdopen(fd, oflags)) != NULL)
 519       register_file(fp, osflags, 0, FP_RAW, NULL, 0L, NULL, NULL,NULL);
 520    NYD_LEAVE;
 521    return fp;
 522 }
 523
 524 FL int
 525 Fclose(FILE *fp)
 526 {
 527    int i = 0;
 528    NYD_ENTER;
 529
 530    if (unregister_file(fp, NULL, NULL) == OKAY)
 531       i |= 1;
 532    if (fclose(fp) == 0)
 533       i |= 2;
 534    NYD_LEAVE;
 535    return (i == 3 ? 0 : EOF);
 536 }
 537
 538 FL FILE *
 539 n_fopen_any(char const *file, char const *oflags, /* TODO should take flags */
 540       enum n_fopen_state *fs_or_null){ /* TODO as bits, return state */
 541    /* TODO Support file locking upon open time */
 542    long offset;
 543    enum protocol p;
 544    enum oflags rof;
 545    int osflags, flags, omode, infd;
 546    char const *cload, *csave;
 547    enum n_fopen_state fs;
 548    FILE *rv;
 549    NYD_ENTER;
 550
 551    rv = NULL;
 552    fs = n_FOPEN_STATE_NONE;
 553    cload = csave = NULL;
 554
 555    if(a_popen_scan_mode(oflags, &osflags) < 0)
 556       goto jleave;
 557
 558    flags = 0;
 559    rof = OF_RDWR | OF_UNLINK;
 560    if(osflags & O_APPEND)
 561       rof |= OF_APPEND;
 562    omode = (osflags == O_RDONLY) ? R_OK : R_OK | W_OK;
 563
 564    /* We don't want to find mbox.bz2 when doing "copy * mbox", but only for
 565     * "file mbox", so don't try hooks when writing */
 566    p = which_protocol(file, TRU1, ((omode & W_OK) == 0), &file);
 567    fs = (enum n_fopen_state)p;
 568    switch(p){
 569    default:
 570       goto jleave;
 571    case n_PROTO_IMAP:
 572 #ifdef HAVE_IMAP
 573       file = savecat("imap://", file);
 574       flags |= FP_IMAP;
 575       osflags = O_RDWR | O_APPEND | O_CREAT | n_O_NOFOLLOW;
 576       infd = -1;
 577       break;
 578 #else
 579       n_err_no = n_ERR_OPNOTSUPP;
 580       goto jleave;
 581 #endif
 582    case n_PROTO_MAILDIR:
 583       if(fs_or_null != NULL && !access(file, F_OK))
 584          fs |= n_FOPEN_STATE_EXISTS;
 585       flags |= FP_MAILDIR;
 586       osflags = O_RDWR | O_APPEND | O_CREAT | n_O_NOFOLLOW;
 587       infd = -1;
 588       break;
 589    case n_PROTO_FILE:{
 590       struct n_file_type ft;
 591
 592       if(!(osflags & O_EXCL) && fs_or_null != NULL && !access(file, F_OK))
 593          fs |= n_FOPEN_STATE_EXISTS;
 594
 595       if(n_filetype_exists(&ft, file)){
 596          flags |= FP_HOOK;
 597          cload = ft.ft_load_dat;
 598          csave = ft.ft_save_dat;
 599          /* Cause truncation for compressor/hook output files */
 600          osflags &= ~O_APPEND;
 601          rof &= ~OF_APPEND;
 602          if((infd = open(file, (omode & W_OK ? O_RDWR : O_RDONLY))) == -1){
 603             if(!(osflags & O_CREAT) || n_err_no != n_ERR_NOENT)
 604                goto jleave;
 605          }
 606          fs |= n_FOPEN_STATE_EXISTS;
 607       }else{
 608          /*flags |= FP_RAW;*/
 609          rv = Fopen(file, oflags);
 610          if((osflags & O_EXCL) && rv == NULL)
 611             fs |= n_FOPEN_STATE_EXISTS;
 612          goto jleave;
 613       }
 614    }  break;
 615    }
 616
 617    /* Note rv is not yet register_file()d, fclose() it in error path! */
 618    if((rv = Ftmp(NULL, "fopenany", rof)) == NULL){
 619       n_perr(_("tmpfile"), 0);
 620       goto jerr;
 621    }
 622
 623    if(flags & (FP_IMAP | FP_MAILDIR))
 624       ;
 625    else if(infd >= 0){
 626       if(a_popen_file_load(flags, infd, fileno(rv), cload) < 0){
 627 jerr:
 628          if(rv != NULL)
 629             fclose(rv);
 630          rv = NULL;
 631          if(infd >= 0)
 632             close(infd);
 633          goto jleave;
 634       }
 635    }else{
 636       if((infd = creat(file, 0666)) == -1){
 637          fclose(rv);
 638          rv = NULL;
 639          goto jleave;
 640       }
 641    }
 642
 643    if(infd >= 0)
 644       close(infd);
 645    fflush(rv);
 646
 647    if(!(osflags & O_APPEND))
 648       rewind(rv);
 649    if((offset = ftell(rv)) == -1){
 650       Fclose(rv);
 651       rv = NULL;
 652       goto jleave;
 653    }
 654
 655    register_file(rv, osflags, 0, flags, file, offset, csave, NULL,NULL);
 656 jleave:
 657    if(fs_or_null != NULL)
 658       *fs_or_null = fs;
 659    NYD_LEAVE;
 660    return rv;
 661 }
 662
 663 FL FILE *
 664 Ftmp(char **fn, char const *namehint, enum oflags oflags)
 665 {
 666    /* The 8 is arbitrary but leaves room for a six character suffix (the
 667     * POSIX minimum path length is 14, though we don't check that XXX).
 668     * 8 should be more than sufficient given that we use base64url encoding
 669     * for our random string */
 670    enum {_RANDCHARS = 8u};
 671
 672    char *cp_base, *cp;
 673    size_t maxname, xlen, i;
 674    char const *tmpdir;
 675    int osoflags, fd, e;
 676    bool_t relesigs;
 677    FILE *fp;
 678    NYD_ENTER;
 679
 680    assert(namehint != NULL);
 681    assert((oflags & OF_WRONLY) || (oflags & OF_RDWR));
 682    assert(!(oflags & OF_RDONLY));
 683    assert(!(oflags & OF_REGISTER_UNLINK) || (oflags & OF_REGISTER));
 684
 685    fp = NULL;
 686    relesigs = FAL0;
 687    e = 0;
 688    tmpdir = ok_vlook(TMPDIR);
 689    maxname = NAME_MAX;
 690 #ifdef HAVE_PATHCONF
 691    {  long pc;
 692
 693       if ((pc = pathconf(tmpdir, _PC_NAME_MAX)) != -1)
 694          maxname = (size_t)pc;
 695    }
 696 #endif
 697
 698    if ((oflags & OF_SUFFIX) && *namehint != '\0') {
 699       if ((xlen = strlen(namehint)) > maxname - _RANDCHARS) {
 700          n_err_no = n_ERR_NAMETOOLONG;
 701          goto jleave;
 702       }
 703    } else
 704       xlen = 0;
 705
 706    /* Prepare the template string once, then iterate over the random range */
 707    cp_base =
 708    cp = smalloc(strlen(tmpdir) + 1 + maxname +1);
 709    cp = sstpcpy(cp, tmpdir);
 710    *cp++ = '/';
 711    {
 712       char *x = sstpcpy(cp, VAL_UAGENT);
 713       *x++ = '-';
 714       if (!(oflags & OF_SUFFIX))
 715          x = sstpcpy(x, namehint);
 716
 717       i = PTR2SIZE(x - cp);
 718       if (i > maxname - xlen - _RANDCHARS) {
 719          size_t j = maxname - xlen - _RANDCHARS;
 720          x -= i - j;
 721          i = j;
 722       }
 723
 724       if ((oflags & OF_SUFFIX) && xlen > 0)
 725          memcpy(x + _RANDCHARS, namehint, xlen);
 726
 727       x[xlen + _RANDCHARS] = '\0';
 728       cp = x;
 729    }
 730
 731    osoflags = O_CREAT | O_EXCL | _O_CLOEXEC;
 732    osoflags |= (oflags & OF_WRONLY) ? O_WRONLY : O_RDWR;
 733    if (oflags & OF_APPEND)
 734       osoflags |= O_APPEND;
 735
 736    for (i = 0;; ++i) {
 737       memcpy(cp, n_random_create_cp(_RANDCHARS, NULL), _RANDCHARS);
 738
 739       hold_all_sigs();
 740       relesigs = TRU1;
 741
 742       if ((fd = open(cp_base, osoflags, 0600)) != -1) {
 743          _CLOEXEC_SET(fd);
 744          break;
 745       }
 746       if (i >= FTMP_OPEN_TRIES) {
 747          e = n_err_no;
 748          goto jfree;
 749       }
 750       relesigs = FAL0;
 751       rele_all_sigs();
 752    }
 753
 754    if (oflags & OF_REGISTER) {
 755       char const *osflags = (oflags & OF_RDWR ? "w+" : "w");
 756       int osflagbits;
 757
 758       a_popen_scan_mode(osflags, &osflagbits); /* TODO osoflags&xy ?!!? */
 759       if ((fp = fdopen(fd, osflags)) != NULL)
 760          register_file(fp, osflagbits | _O_CLOEXEC, 0,
 761             (FP_RAW | (oflags & OF_REGISTER_UNLINK ? FP_UNLINK : 0)),
 762             cp_base, 0L, NULL, NULL,NULL);
 763    } else
 764       fp = fdopen(fd, (oflags & OF_RDWR ? "w+" : "w"));
 765
 766    if (fp == NULL || (oflags & OF_UNLINK)) {
 767       e = n_err_no;
 768       unlink(cp_base);
 769       goto jfree;
 770    }
 771
 772    if (fn != NULL)
 773       *fn = cp_base;
 774    else
 775       free(cp_base);
 776 jleave:
 777    if (relesigs && (fp == NULL || !(oflags & OF_HOLDSIGS)))
 778       rele_all_sigs();
 779    if (fp == NULL)
 780       n_err_no = e;
 781    NYD_LEAVE;
 782    return fp;
 783 jfree:
 784    if ((cp = cp_base) != NULL)
 785       free(cp);
 786    goto jleave;
 787 }
 788
 789 FL void
 790 Ftmp_release(char **fn)
 791 {
 792    char *cp;
 793    NYD_ENTER;
 794
 795    cp = *fn;
 796    *fn = NULL;
 797    if (cp != NULL) {
 798       unlink(cp);
 799       rele_all_sigs();
 800       free(cp);
 801    }
 802    NYD_LEAVE;
 803 }
 804
 805 FL void
 806 Ftmp_free(char **fn) /* TODO DROP: OF_REGISTER_FREEPATH! */
 807 {
 808    char *cp;
 809    NYD_ENTER;
 810
 811    cp = *fn;
 812    *fn = NULL;
 813    if (cp != NULL)
 814       free(cp);
 815    NYD_LEAVE;
 816 }
 817
 818 FL bool_t
 819 pipe_cloexec(int fd[2]){
 820    bool_t rv;
 821    NYD_ENTER;
 822
 823    rv = FAL0;
 824
 825 #ifdef HAVE_PIPE2
 826    if(pipe2(fd, O_CLOEXEC) != -1)
 827       rv = TRU1;
 828 #else
 829    if(pipe(fd) != -1){
 830       n_fd_cloexec_set(fd[0]);
 831       n_fd_cloexec_set(fd[1]);
 832       rv = TRU1;
 833    }
 834 #endif
 835    NYD_LEAVE;
 836    return rv;
 837 }
 838
 839 FL FILE *
 840 Popen(char const *cmd, char const *mode, char const *sh,
 841    char const **env_addon, int newfd1)
 842 {
 843    int p[2], myside, hisside, fd0, fd1, pid;
 844    sigset_t nset;
 845    char mod[2];
 846    n_sighdl_t osigint;
 847    struct termios *tiosp;
 848    FILE *rv;
 849    NYD_ENTER;
 850
 851    /* First clean up child structures */
 852    /* C99 */{
 853       struct child **cpp, *cp;
 854
 855       hold_all_sigs();
 856       for (cpp = &_popen_child; *cpp != NULL;) {
 857          if ((*cpp)->pid == -1) {
 858             cp = *cpp;
 859             *cpp = cp->link;
 860             free(cp);
 861          } else
 862             cpp = &(*cpp)->link;
 863       }
 864       rele_all_sigs();
 865    }
 866
 867    rv = NULL;
 868    tiosp = NULL;
 869    n_UNINIT(osigint, SIG_ERR);
 870    mod[0] = '0', mod[1] = '\0';
 871
 872    if (!pipe_cloexec(p))
 873       goto jleave;
 874
 875    if (*mode == 'r') {
 876       myside = p[READ];
 877       fd0 = n_CHILD_FD_PASS;
 878       hisside = fd1 = p[WRITE];
 879       mod[0] = *mode;
 880    } else if (*mode == 'W') {
 881       myside = p[WRITE];
 882       hisside = fd0 = p[READ];
 883       fd1 = newfd1;
 884       mod[0] = 'w';
 885    } else {
 886       myside = p[WRITE];
 887       hisside = fd0 = p[READ];
 888       fd1 = n_CHILD_FD_PASS;
 889       mod[0] = 'w';
 890    }
 891
 892    /* In interactive mode both STDIN and STDOUT point to the terminal.  If we
 893     * pass through the TTY restore terminal attributes after pipe returns.
 894     * XXX It shouldn't matter which FD we actually use in this case */
 895    if ((n_psonce & n_PSO_INTERACTIVE) && (fd0 == n_CHILD_FD_PASS ||
 896          fd1 == n_CHILD_FD_PASS)) {
 897       osigint = n_signal(SIGINT, SIG_IGN);
 898       tiosp = smalloc(sizeof *tiosp);
 899       tcgetattr(STDIN_FILENO, tiosp);
 900       n_TERMCAP_SUSPEND(TRU1);
 901    }
 902
 903    sigemptyset(&nset);
 904
 905    if (cmd == (char*)-1) {
 906       if ((pid = n_child_fork()) == -1)
 907          n_perr(_("fork"), 0);
 908       else if (pid == 0) {
 909          union {char const *ccp; int (*ptf)(void); int es;} u;
 910          n_child_prepare(&nset, fd0, fd1);
 911          close(p[READ]);
 912          close(p[WRITE]);
 913          /* TODO should close all other open FDs except stds and reset memory */
 914          /* Standard I/O drives me insane!  All we need is a sync operation
 915           * that causes n_stdin to forget about any read buffer it may have.
 916           * We cannot use fflush(3), this works with Musl and Solaris, but not
 917           * with GlibC.  (For at least pipes.)  We cannot use fdreopen(),
 918           * because this function does not exist!  Luckily (!!!) we only use
 919           * n_stdin not stdin in our child, otherwise all bets were off!
 920           * TODO (Unless we would fiddle around with FILE* directly:
 921           * TODO #ifdef __GLIBC__
 922           * TODO   n_stdin->_IO_read_ptr = n_stdin->_IO_read_end;
 923           * TODO #elif *BSD*
 924           * TODO   n_stdin->_r = 0;
 925           * TODO #elif n_OS_SOLARIS || n_OS_SUNOS
 926           * TODO   n_stdin->_cnt = 0;
 927           * TODO #endif
 928           * TODO ) which should have additional config test for sure! */
 929          n_stdin = fdopen(STDIN_FILENO, "r");
 930          /*n_stdout = fdopen(STDOUT_FILENO, "w");*/
 931          /*n_stderr = fdopen(STDERR_FILENO, "w");*/
 932          u.ccp = sh;
 933          u.es = (*u.ptf)();
 934          /*fflush(NULL);*/
 935          _exit(u.es);
 936       }
 937    } else if (sh == NULL) {
 938       pid = n_child_start(cmd, &nset, fd0, fd1, NULL, NULL, NULL, env_addon);
 939    } else {
 940       pid = n_child_start(sh, &nset, fd0, fd1, "-c", cmd, NULL, env_addon);
 941    }
 942    if (pid < 0) {
 943       close(p[READ]);
 944       close(p[WRITE]);
 945       goto jleave;
 946    }
 947    close(hisside);
 948    if ((rv = fdopen(myside, mod)) != NULL)
 949       register_file(rv, 0, pid,
 950          (tiosp == NULL ? FP_PIPE : FP_PIPE | FP_TERMIOS),
 951          NULL, 0L, NULL, tiosp, osigint);
 952    else
 953       close(myside);
 954 jleave:
 955    if(rv == NULL && tiosp != NULL){
 956       n_TERMCAP_RESUME(TRU1);
 957       tcsetattr(STDIN_FILENO, TCSAFLUSH, tiosp);
 958       n_free(tiosp);
 959       n_signal(SIGINT, osigint);
 960    }
 961    NYD_LEAVE;
 962    return rv;
 963 }
 964
 965 FL bool_t
 966 Pclose(FILE *ptr, bool_t dowait)
 967 {
 968    n_sighdl_t osigint;
 969    struct termios *tiosp;
 970    int pid;
 971    bool_t rv = FAL0;
 972    NYD_ENTER;
 973
 974    pid = file_pid(ptr);
 975    if(pid < 0)
 976       goto jleave;
 977
 978    unregister_file(ptr, &tiosp, &osigint);
 979    fclose(ptr);
 980
 981    if(dowait){
 982       hold_all_sigs();
 983       rv = n_child_wait(pid, NULL);
 984       if(tiosp != NULL){
 985          n_TERMCAP_RESUME(TRU1);
 986          tcsetattr(STDIN_FILENO, TCSAFLUSH, tiosp);
 987          n_signal(SIGINT, osigint);
 988       }
 989       rele_all_sigs();
 990    }else{
 991       n_child_free(pid);
 992       rv = TRU1;
 993    }
 994
 995    if(tiosp != NULL)
 996       free(tiosp);
 997 jleave:
 998    NYD_LEAVE;
 999    return rv;
1000 }
1001
1002 VL int
1003 n_psignal(FILE *fp, int sig){
1004    int rv;
1005    NYD2_ENTER;
1006
1007    if((rv = file_pid(fp)) >= 0){
1008       struct child *cp;
1009
1010       if((cp = a_popen_child_find(rv, FAL0)) != NULL){
1011          if((rv = kill(rv, sig)) != 0)
1012             rv = n_err_no;
1013       }else
1014          rv = -1;
1015    }
1016    NYD2_LEAVE;
1017    return rv;
1018 }
1019
1020 FL FILE *
1021 n_pager_open(void)
1022 {
1023    char const *env_add[2], *pager;
1024    FILE *rv;
1025    NYD_ENTER;
1026
1027    assert(n_psonce & n_PSO_INTERACTIVE);
1028
1029    pager = n_pager_get(env_add + 0);
1030    env_add[1] = NULL;
1031
1032    if ((rv = Popen(pager, "w", NULL, env_add, n_CHILD_FD_PASS)) == NULL)
1033       n_perr(pager, 0);
1034    NYD_LEAVE;
1035    return rv;
1036 }
1037
1038 FL bool_t
1039 n_pager_close(FILE *fp)
1040 {
1041    sighandler_type sh;
1042    bool_t rv;
1043    NYD_ENTER;
1044
1045    sh = safe_signal(SIGPIPE, SIG_IGN);
1046    rv = Pclose(fp, TRU1);
1047    safe_signal(SIGPIPE, sh);
1048    NYD_LEAVE;
1049    return rv;
1050 }
1051
1052 FL void
1053 close_all_files(void)
1054 {
1055    NYD_ENTER;
1056    while (fp_head != NULL)
1057       if ((fp_head->flags & FP_MASK) == FP_PIPE)
1058          Pclose(fp_head->fp, TRU1);
1059       else
1060          Fclose(fp_head->fp);
1061    NYD_LEAVE;
1062 }
1063
1064 /* TODO The entire n_child_ series should be replaced with an object, but
1065  * TODO at least have carrier arguments.  We anyway need a command manager
1066  * TODO that keeps track and knows how to handle job control ++++! */
1067
1068 FL int
1069 n_child_run(char const *cmd, sigset_t *mask_or_null, int infd, int outfd,
1070    char const *a0_or_null, char const *a1_or_null, char const *a2_or_null,
1071    char const **env_addon_or_null, int *wait_status_or_null)
1072 {
1073    sigset_t nset, oset;
1074    sighandler_type soldint;
1075    int rv, e;
1076    enum {a_NONE = 0, a_INTIGN = 1<<0, a_TTY = 1<<1} f;
1077    NYD_ENTER;
1078
1079    f = a_NONE;
1080    n_UNINIT(soldint, SIG_ERR);
1081
1082    /* TODO Of course this is a joke given that during a "p*" the PAGER may
1083     * TODO be up and running while we play around like this... but i guess
1084     * TODO this can't be helped at all unless we perform complete and true
1085     * TODO process group separation and ensure we don't deadlock us out
1086     * TODO via TTY jobcontrol signal storms (could this really happen?).
1087     * TODO Or have a built-in pager.  Or query any necessity BEFORE we start
1088     * TODO any action, and shall we find we need to run programs dump it
1089     * TODO all into a temporary file which is then passed through to the
1090     * TODO PAGER.  Ugh.  That still won't help for "needsterminal" anyway */
1091    if(infd == n_CHILD_FD_PASS || outfd == n_CHILD_FD_PASS){
1092       soldint = safe_signal(SIGINT, SIG_IGN);
1093       f = a_INTIGN;
1094
1095       if(n_psonce & n_PSO_INTERACTIVE){
1096          f |= a_TTY;
1097          tcgetattr((n_psonce & n_PSO_TTYIN ? STDIN_FILENO : STDOUT_FILENO),
1098             &a_popen_tios);
1099          n_TERMCAP_SUSPEND(FAL0);
1100          sigfillset(&nset);
1101          sigdelset(&nset, SIGCHLD);
1102          sigdelset(&nset, SIGINT);
1103          /* sigdelset(&nset, SIGPIPE); TODO would need a handler */
1104          sigprocmask(SIG_BLOCK, &nset, &oset);
1105          a_popen_hadsig = 0;
1106          a_popen_jobsigs_up();
1107       }
1108    }
1109
1110    if((rv = n_child_start(cmd, mask_or_null, infd, outfd, a0_or_null,
1111          a1_or_null, a2_or_null, env_addon_or_null)) < 0){
1112       e = n_err_no;
1113       rv = -1;
1114    }else{
1115       int ws;
1116
1117       e = 0;
1118       if(n_child_wait(rv, &ws))
1119          rv = 0;
1120       else if(wait_status_or_null == NULL || !WIFEXITED(ws)){
1121          if(ok_blook(bsdcompat) || ok_blook(bsdmsgs))
1122             n_err(_("Fatal error in process\n"));
1123          e = n_ERR_CHILD;
1124          rv = -1;
1125       }
1126       if(wait_status_or_null != NULL)
1127          *wait_status_or_null = ws;
1128    }
1129
1130    if(f & a_TTY){
1131       a_popen_jobsigs_down();
1132       n_TERMCAP_RESUME(a_popen_hadsig ? TRU1 : FAL0);
1133       tcsetattr(((n_psonce & n_PSO_TTYIN) ? STDIN_FILENO : STDOUT_FILENO),
1134          ((n_psonce & n_PSO_TTYIN) ? TCSAFLUSH : TCSADRAIN), &a_popen_tios);
1135       sigprocmask(SIG_SETMASK, &oset, NULL);
1136    }
1137    if(f & a_INTIGN){
1138       if(soldint != SIG_IGN)
1139          safe_signal(SIGINT, soldint);
1140    }
1141
1142    if(e != 0)
1143       n_err_no = e;
1144    NYD_LEAVE;
1145    return rv;
1146 }
1147
1148 FL int
1149 n_child_start(char const *cmd, sigset_t *mask_or_null, int infd, int outfd,
1150    char const *a0_or_null, char const *a1_or_null, char const *a2_or_null,
1151    char const **env_addon_or_null)
1152 {
1153    int rv, e;
1154    NYD_ENTER;
1155
1156    if ((rv = n_child_fork()) == -1) {
1157       e = n_err_no;
1158       n_perr(_("fork"), 0);
1159       n_err_no = e;
1160       rv = -1;
1161    } else if (rv == 0) {
1162       char *argv[128];
1163       int i;
1164
1165       if (env_addon_or_null != NULL) {
1166          extern char **environ;
1167          size_t ei, ei_orig, ai, ai_orig;
1168          char **env;
1169
1170          /* TODO note we don't check the POSIX limit:
1171           * the total space used to store the environment and the arguments to
1172           * the process is limited to {ARG_MAX} bytes */
1173          for (ei = 0; environ[ei] != NULL; ++ei)
1174             ;
1175          ei_orig = ei;
1176          for (ai = 0; env_addon_or_null[ai] != NULL; ++ai)
1177             ;
1178          ai_orig = ai;
1179          env = ac_alloc(sizeof(*env) * (ei + ai +1));
1180          memcpy(env, environ, sizeof(*env) * ei);
1181
1182          /* Replace all those keys that yet exist */
1183          while (ai-- > 0) {
1184             char const *ee, *kvs;
1185             size_t kl;
1186
1187             ee = env_addon_or_null[ai];
1188             kvs = strchr(ee, '=');
1189             assert(kvs != NULL);
1190             kl = PTR2SIZE(kvs - ee);
1191             assert(kl > 0);
1192             for (ei = ei_orig; ei-- > 0;) {
1193                char const *ekvs = strchr(env[ei], '=');
1194                if (ekvs != NULL && kl == PTR2SIZE(ekvs - env[ei]) &&
1195                      !memcmp(ee, env[ei], kl)) {
1196                   env[ei] = n_UNCONST(ee);
1197                   env_addon_or_null[ai] = NULL;
1198                   break;
1199                }
1200             }
1201          }
1202
1203          /* And append the rest */
1204          for (ei = ei_orig, ai = ai_orig; ai-- > 0;)
1205             if (env_addon_or_null[ai] != NULL)
1206                env[ei++] = n_UNCONST(env_addon_or_null[ai]);
1207
1208          env[ei] = NULL;
1209          environ = env;
1210       }
1211
1212       i = (int)getrawlist(TRU1, argv, n_NELEM(argv), cmd, strlen(cmd));
1213
1214       if ((argv[i++] = n_UNCONST(a0_or_null)) != NULL &&
1215             (argv[i++] = n_UNCONST(a1_or_null)) != NULL &&
1216             (argv[i++] = n_UNCONST(a2_or_null)) != NULL)
1217          argv[i] = NULL;
1218       n_child_prepare(mask_or_null, infd, outfd);
1219       execvp(argv[0], argv);
1220       perror(argv[0]);
1221       _exit(n_EXIT_ERR);
1222    }
1223    NYD_LEAVE;
1224    return rv;
1225 }
1226
1227 FL int
1228 n_child_fork(void){
1229    struct child *cp;
1230    int pid;
1231    NYD2_ENTER;
1232
1233    cp = a_popen_child_find(0, TRU1);
1234
1235    if((cp->pid = pid = fork()) == -1){
1236       a_popen_child_del(cp);
1237       n_perr(_("fork"), 0);
1238    }
1239    NYD2_LEAVE;
1240    return pid;
1241 }
1242
1243 FL void
1244 n_child_prepare(sigset_t *nset_or_null, int infd, int outfd)
1245 {
1246    int i;
1247    sigset_t fset;
1248    NYD_ENTER;
1249
1250    /* All file descriptors other than 0, 1, and 2 are supposed to be cloexec */
1251    /* TODO WHAT IS WITH STDERR_FILENO DAMN? */
1252    if ((i = (infd == n_CHILD_FD_NULL)))
1253       infd = open(n_path_devnull, O_RDONLY);
1254    if (infd >= 0) {
1255       dup2(infd, STDIN_FILENO);
1256       if (i)
1257          close(infd);
1258    }
1259
1260    if ((i = (outfd == n_CHILD_FD_NULL)))
1261       outfd = open(n_path_devnull, O_WRONLY);
1262    if (outfd >= 0) {
1263       dup2(outfd, STDOUT_FILENO);
1264       if (i)
1265          close(outfd);
1266    }
1267
1268    if (nset_or_null != NULL) {
1269       for (i = 1; i < NSIG; ++i)
1270          if (sigismember(nset_or_null, i))
1271             safe_signal(i, SIG_IGN);
1272       if (!sigismember(nset_or_null, SIGINT))
1273          safe_signal(SIGINT, SIG_DFL);
1274    }
1275
1276    sigemptyset(&fset);
1277    sigprocmask(SIG_SETMASK, &fset, NULL);
1278    NYD_LEAVE;
1279 }
1280
1281 FL void
1282 n_child_free(int pid){
1283    sigset_t nset, oset;
1284    struct child *cp;
1285    NYD2_ENTER;
1286
1287    sigemptyset(&nset);
1288    sigaddset(&nset, SIGCHLD);
1289    sigprocmask(SIG_BLOCK, &nset, &oset);
1290
1291    if((cp = a_popen_child_find(pid, FAL0)) != NULL){
1292       if(cp->done)
1293          a_popen_child_del(cp);
1294       else
1295          cp->free = TRU1;
1296    }
1297
1298    sigprocmask(SIG_SETMASK, &oset, NULL);
1299    NYD2_LEAVE;
1300 }
1301
1302 FL bool_t
1303 n_child_wait(int pid, int *wait_status_or_null){
1304 #if !n_SIGSUSPEND_NOT_WAITPID
1305    sigset_t oset;
1306 #endif
1307    sigset_t nset;
1308    struct child *cp;
1309    int ws;
1310    bool_t rv;
1311    NYD_ENTER;
1312
1313 #if !n_SIGSUSPEND_NOT_WAITPID
1314    sigemptyset(&nset);
1315    sigaddset(&nset, SIGCHLD);
1316    sigprocmask(SIG_BLOCK, &nset, &oset);
1317 #endif
1318
1319    if((cp = a_popen_child_find(pid, FAL0)) != NULL){
1320 #if n_SIGSUSPEND_NOT_WAITPID
1321       sigfillset(&nset);
1322       sigdelset(&nset, SIGCHLD);
1323       while(!cp->done)
1324          sigsuspend(&nset); /* TODO we should allow more than SIGCHLD!! */
1325       ws = cp->status;
1326 #else
1327       waitpid(pid, &ws, 0);
1328 #endif
1329       a_popen_child_del(cp);
1330    }else
1331       ws = 0;
1332
1333 #if !n_SIGSUSPEND_NOT_WAITPID
1334    sigprocmask(SIG_SETMASK, &oset, NULL);
1335 #endif
1336
1337    if(wait_status_or_null != NULL)
1338       *wait_status_or_null = ws;
1339    rv = (WIFEXITED(ws) && WEXITSTATUS(ws) == 0);
1340    NYD_LEAVE;
1341    return rv;
1342 }
1343
1344 /* s-it-mode */