usr.bin/mail/popen.c

   1 /*
   2  * Copyright (c) 1980, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 #if 0
  36 static char sccsid[] = "@(#)popen.c     8.1 (Berkeley) 6/6/93";
  37 #endif
  38 static const char rcsid[] =
  39   "$FreeBSD$";
  40 #endif /* not lint */
  41
  42 #include "rcv.h"
  43 #include <sys/wait.h>
  44 #include <fcntl.h>
  45 #include "extern.h"
  46
  47 #define READ 0
  48 #define WRITE 1
  49
  50 struct fp {
  51         FILE    *fp;
  52         int     pipe;
  53         int     pid;
  54         struct  fp *link;
  55 };
  56 static struct fp *fp_head;
  57
  58 struct child {
  59         int     pid;
  60         char    done;
  61         char    free;
  62         int     status;
  63         struct  child *link;
  64 };
  65 static struct child *child;
  66 static struct child *findchild __P((int));
  67 static void delchild __P((struct child *));
  68 static int file_pid __P((FILE *));
  69
  70 FILE *
  71 Fopen(path, mode)
  72         const char *path, *mode;
  73 {
  74         FILE *fp;
  75
  76         if ((fp = fopen(path, mode)) != NULL) {
  77                 register_file(fp, 0, 0);
  78                 (void)fcntl(fileno(fp), F_SETFD, 1);
  79         }
  80         return (fp);
  81 }
  82
  83 FILE *
  84 Fdopen(fd, mode)
  85         int fd;
  86         const char *mode;
  87 {
  88         FILE *fp;
  89
  90         if ((fp = fdopen(fd, mode)) != NULL) {
  91                 register_file(fp, 0, 0);
  92                 (void)fcntl(fileno(fp), F_SETFD, 1);
  93         }
  94         return (fp);
  95 }
  96
  97 int
  98 Fclose(fp)
  99         FILE *fp;
 100 {
 101         unregister_file(fp);
 102         return (fclose(fp));
 103 }
 104
 105 FILE *
 106 Popen(cmd, mode)
 107         char *cmd;
 108         const char *mode;
 109 {
 110         int p[2];
 111         int myside, hisside, fd0, fd1;
 112         int pid;
 113         FILE *fp;
 114
 115         if (pipe(p) < 0)
 116                 return (NULL);
 117         (void)fcntl(p[READ], F_SETFD, 1);
 118         (void)fcntl(p[WRITE], F_SETFD, 1);
 119         if (*mode == 'r') {
 120                 myside = p[READ];
 121                 fd0 = -1;
 122                 hisside = fd1 = p[WRITE];
 123         } else {
 124                 myside = p[WRITE];
 125                 hisside = fd0 = p[READ];
 126                 fd1 = -1;
 127         }
 128         if ((pid = start_command(cmd, 0, fd0, fd1, NULL, NULL, NULL)) < 0) {
 129                 (void)close(p[READ]);
 130                 (void)close(p[WRITE]);
 131                 return (NULL);
 132         }
 133         (void)close(hisside);
 134         if ((fp = fdopen(myside, mode)) != NULL)
 135                 register_file(fp, 1, pid);
 136         return (fp);
 137 }
 138
 139 int
 140 Pclose(ptr)
 141         FILE *ptr;
 142 {
 143         int i;
 144         int omask;
 145
 146         i = file_pid(ptr);
 147         unregister_file(ptr);
 148         (void)fclose(ptr);
 149         omask = sigblock(sigmask(SIGINT)|sigmask(SIGHUP));
 150         i = wait_child(i);
 151         (void)sigsetmask(omask);
 152         return (i);
 153 }
 154
 155 void
 156 close_all_files()
 157 {
 158
 159         while (fp_head != NULL)
 160                 if (fp_head->pipe)
 161                         (void)Pclose(fp_head->fp);
 162                 else
 163                         (void)Fclose(fp_head->fp);
 164 }
 165
 166 void
 167 register_file(fp, pipe, pid)
 168         FILE *fp;
 169         int pipe, pid;
 170 {
 171         struct fp *fpp;
 172
 173         if ((fpp = malloc(sizeof(*fpp))) == NULL)
 174                 err(1, "Out of memory");
 175         fpp->fp = fp;
 176         fpp->pipe = pipe;
 177         fpp->pid = pid;
 178         fpp->link = fp_head;
 179         fp_head = fpp;
 180 }
 181
 182 void
 183 unregister_file(fp)
 184         FILE *fp;
 185 {
 186         struct fp **pp, *p;
 187
 188         for (pp = &fp_head; (p = *pp) != NULL; pp = &p->link)
 189                 if (p->fp == fp) {
 190                         *pp = p->link;
 191                         (void)free(p);
 192                         return;
 193                 }
 194         errx(1, "Invalid file pointer");
 195         /*NOTREACHED*/
 196 }
 197
 198 int
 199 file_pid(fp)
 200         FILE *fp;
 201 {
 202         struct fp *p;
 203
 204         for (p = fp_head; p != NULL; p = p->link)
 205                 if (p->fp == fp)
 206                         return (p->pid);
 207         errx(1, "Invalid file pointer");
 208         /*NOTREACHED*/
 209 }
 210
 211 /*
 212  * Run a command without a shell, with optional arguments and splicing
 213  * of stdin and stdout.  The command name can be a sequence of words.
 214  * Signals must be handled by the caller.
 215  * "Mask" contains the signals to ignore in the new process.
 216  * SIGINT is enabled unless it's in the mask.
 217  */
 218 /*VARARGS4*/
 219 int
 220 run_command(cmd, mask, infd, outfd, a0, a1, a2)
 221         char *cmd;
 222         int mask, infd, outfd;
 223         char *a0, *a1, *a2;
 224 {
 225         int pid;
 226
 227         if ((pid = start_command(cmd, mask, infd, outfd, a0, a1, a2)) < 0)
 228                 return (-1);
 229         return (wait_command(pid));
 230 }
 231
 232 /*VARARGS4*/
 233 int
 234 start_command(cmd, mask, infd, outfd, a0, a1, a2)
 235         char *cmd;
 236         int mask, infd, outfd;
 237         char *a0, *a1, *a2;
 238 {
 239         int pid;
 240
 241         if ((pid = fork()) < 0) {
 242                 warn("fork");
 243                 return (-1);
 244         }
 245         if (pid == 0) {
 246                 char *argv[100];
 247                 int i = getrawlist(cmd, argv, sizeof(argv) / sizeof(*argv));
 248
 249                 if ((argv[i++] = a0) != NULL &&
 250                     (argv[i++] = a1) != NULL &&
 251                     (argv[i++] = a2) != NULL)
 252                         argv[i] = NULL;
 253                 prepare_child(mask, infd, outfd);
 254                 execvp(argv[0], argv);
 255                 warn("%s", argv[0]);
 256                 _exit(1);
 257         }
 258         return (pid);
 259 }
 260
 261 void
 262 prepare_child(mask, infd, outfd)
 263         int mask, infd, outfd;
 264 {
 265         int i;
 266
 267         /*
 268          * All file descriptors other than 0, 1, and 2 are supposed to be
 269          * close-on-exec.
 270          */
 271         if (infd >= 0)
 272                 dup2(infd, 0);
 273         if (outfd >= 0)
 274                 dup2(outfd, 1);
 275         for (i = 1; i <= NSIG; i++)
 276                 if (mask & sigmask(i))
 277                         (void)signal(i, SIG_IGN);
 278         if ((mask & sigmask(SIGINT)) == 0)
 279                 (void)signal(SIGINT, SIG_DFL);
 280         (void)sigsetmask(0);
 281 }
 282
 283 int
 284 wait_command(pid)
 285         int pid;
 286 {
 287
 288         if (wait_child(pid) < 0) {
 289                 printf("Fatal error in process.\n");
 290                 return (-1);
 291         }
 292         return (0);
 293 }
 294
 295 static struct child *
 296 findchild(pid)
 297         int pid;
 298 {
 299         struct child **cpp;
 300
 301         for (cpp = &child; *cpp != NULL && (*cpp)->pid != pid;
 302             cpp = &(*cpp)->link)
 303                         ;
 304         if (*cpp == NULL) {
 305                 *cpp = malloc(sizeof(struct child));
 306                 if (*cpp == NULL)
 307                         err(1, "Out of memory");
 308                 (*cpp)->pid = pid;
 309                 (*cpp)->done = (*cpp)->free = 0;
 310                 (*cpp)->link = NULL;
 311         }
 312         return (*cpp);
 313 }
 314
 315 static void
 316 delchild(cp)
 317         struct child *cp;
 318 {
 319         struct child **cpp;
 320
 321         for (cpp = &child; *cpp != cp; cpp = &(*cpp)->link)
 322                 ;
 323         *cpp = cp->link;
 324         (void)free(cp);
 325 }
 326
 327 /*ARGSUSED*/
 328 void
 329 sigchild(signo)
 330         int signo;
 331 {
 332         int pid;
 333         int status;
 334         struct child *cp;
 335
 336         while ((pid = waitpid((pid_t)-1, &status, WNOHANG)) > 0) {
 337                 cp = findchild(pid);
 338                 if (cp->free)
 339                         delchild(cp);
 340                 else {
 341                         cp->done = 1;
 342                         cp->status = status;
 343                 }
 344         }
 345 }
 346
 347 int wait_status;
 348
 349 /*
 350  * Wait for a specific child to die.
 351  */
 352 int
 353 wait_child(pid)
 354         int pid;
 355 {
 356         int mask = sigblock(sigmask(SIGCHLD));
 357         struct child *cp = findchild(pid);
 358
 359         while (!cp->done)
 360                 sigpause(mask);
 361         wait_status = cp->status;
 362         delchild(cp);
 363         (void)sigsetmask(mask);
 364         return ((WIFEXITED(wait_status) && WEXITSTATUS(wait_status)) ? -1 : 0);
 365 }
 366
 367 /*
 368  * Mark a child as don't care.
 369  */
 370 void
 371 free_child(pid)
 372         int pid;
 373 {
 374         int mask = sigblock(sigmask(SIGCHLD));
 375         struct child *cp = findchild(pid);
 376
 377         if (cp->done)
 378                 delchild(cp);
 379         else
 380                 cp->free = 1;
 381         (void)sigsetmask(mask);
 382 }