process.c

   1 #define _GNU_SOURCE
   2 #include "secnet.h"
   3 #include <unistd.h>
   4 #include <fcntl.h>
   5 #include <errno.h>
   6 #include <sys/wait.h>
   7 #include <string.h>
   8 #include "process.h"
   9
  10 /* Process handling - subprocesses, signals, etc. */
  11
  12 static bool_t signal_handling=False;
  13 static sigset_t emptyset, fullset;
  14 static sigset_t registered,pending;
  15
  16 struct child {
  17     pid_t pid;
  18     cstring_t desc;
  19     process_callback_fn *cb;
  20     void *cst;
  21     bool_t finished;
  22     struct child *next;
  23 };
  24
  25 static struct child *children=NULL;
  26
  27 struct signotify {
  28     int signum;
  29     signal_notify_fn *notify;
  30     void *cst;
  31     struct signotify *next;
  32 };
  33
  34 static struct signotify *sigs=NULL;
  35
  36 static int spw,spr; /* file descriptors for signal notification pipe */
  37
  38 /* Long-lived subprocesses can only be started once we've started
  39    signal processing so that we can catch SIGCHLD for them and report
  40    their exit status using the callback function.  We block SIGCHLD
  41    until signal processing has begun. */
  42 pid_t makesubproc(process_entry_fn *entry, process_callback_fn *cb,
  43                  void *est, void *cst, cstring_t desc)
  44 {
  45     struct child *c;
  46     pid_t p;
  47
  48     c=safe_malloc(sizeof(*c),"makesubproc");
  49     c->desc=desc;
  50     c->cb=cb;
  51     c->cst=cst;
  52
  53     if (!signal_handling) {
  54         fatal("makesubproc called before signal handling started");
  55     }
  56     p=fork();
  57     if (p==0) {
  58         /* Child process */
  59         afterfork();
  60         entry(est);
  61         abort();
  62     } else if (p==-1) {
  63         fatal_perror("makesubproc (%s): fork",desc);
  64     }
  65     c->pid=p;
  66     c->finished=False;
  67     c->next=children;
  68     children=c;
  69     return p;
  70 }
  71
  72 static signal_notify_fn sigchld_handler;
  73 static void sigchld_handler(void *st, int signum)
  74 {
  75     struct child *i,*n,**p;
  76     struct work {
  77         pid_t pid;
  78         process_callback_fn *cb;
  79         void *cst;
  80         int status;
  81         struct work *next;
  82     };
  83     struct work *w=NULL, *nw;
  84     pid_t rv;
  85     int status;
  86
  87     for (i=children; i; i=i->next) {
  88         rv=waitpid(i->pid,&status,WNOHANG);
  89         if (rv==-1) {
  90             fatal_perror("sigchld_handler: waitpid");
  91         }
  92         if (rv==i->pid) {
  93             i->finished=True;
  94
  95             nw=safe_malloc(sizeof(*nw),"sigchld_handler");
  96             nw->pid=i->pid;
  97             nw->cb=i->cb;
  98             nw->cst=i->cst;
  99             nw->status=status;
 100             nw->next=w;
 101             w=nw;
 102         }
 103     }
 104
 105     /* Remove all the finished tasks from the list of children */
 106     for (i=children, p=&children; i; i=n) {
 107         n=i->next;
 108         if (i->finished) {
 109             free(i);
 110             *p=n;
 111         } else {
 112             p=&i->next;
 113         }
 114     }
 115
 116     /* Notify as appropriate, then free the list */
 117     while (w) {
 118         w->cb(w->cst,w->pid,w->status);
 119         nw=w;
 120         w=w->next;
 121         free(nw);
 122     }
 123 }
 124
 125 int sys_cmd(const char *path, const char *arg, ...)
 126 {
 127     va_list ap;
 128     int rv, rc;
 129     pid_t c;
 130
 131     c=fork();
 132     if (c) {
 133         /* Parent -> wait for child */
 134         do {
 135             rc = waitpid(c,&rv,0);
 136         } while(rc < 0 && errno == EINTR);
 137         if (rc < 0)
 138             fatal_perror("sys_cmd: waitpid for %s", path);
 139         if (rc != c) /* OS has gone mad */
 140             fatal("sys_cmd: waitpid for %s returned wrong process ID!",
 141                   path);
 142         if (rv) {
 143             /* If the command failed report its exit status */
 144             lg_exitstatus(0,"sys_cmd",0,M_ERR,rv,path);
 145         }
 146     } else if (c==0) {
 147         char *args[100];
 148         int i;
 149         /* Child -> exec command */
 150         /* Really we ought to strcpy() the arguments into the args array,
 151            since the arguments are const char *.  Since we'll exit anyway
 152            if the execvp() fails this seems somewhat pointless, and
 153            increases the chance of the child process failing before it
 154            gets to exec(). */
 155         afterfork();
 156         va_start(ap,arg);
 157         args[0]=(char *)arg; /* program name */
 158         i=1;
 159         while ((args[i++]=va_arg(ap,char *)));
 160         execvp(path,args);
 161         fprintf(stderr, "sys_cmd(%s,%s,...): %s\n", path, arg, strerror(errno));
 162         _exit(1);
 163     } else {
 164         /* Error */
 165         fatal_perror("sys_cmd(%s,%s,...)", path, arg);
 166     }
 167
 168     return rv;
 169 }
 170
 171 static beforepoll_fn signal_beforepoll;
 172 static int signal_beforepoll(void *st, struct pollfd *fds, int *nfds_io,
 173                              int *timeout_io)
 174 {
 175     BEFOREPOLL_WANT_FDS(1);
 176     fds[0].fd=spr;
 177     fds[0].events=POLLIN;
 178     return 0;
 179 }
 180
 181 /* Bodge to work around Ubuntu's strict header files */
 182 static void discard(int anything) {}
 183
 184 static afterpoll_fn signal_afterpoll;
 185 static void signal_afterpoll(void *st, struct pollfd *fds, int nfds)
 186 {
 187     uint8_t buf[16];
 188     struct signotify *n;
 189     sigset_t todo,old;
 190
 191     if (nfds && (fds->revents & POLLIN)) {
 192         discard(read(spr,buf,16));
 193                           /* We don't actually care what we read; as
 194                              long as there was at least one byte
 195                              (which there was) we'll pick up the
 196                              signals in the pending set */
 197
 198         /* We reset 'pending' before processing any of the signals
 199            that were pending so that we don't miss any signals that
 200            are delivered partway-through processing (all we assume
 201            about signal notification routines is that they handle all
 202            the work available at their _start_ and only optionally any
 203            work that arrives part-way through their execution). */
 204         sigprocmask(SIG_SETMASK,&fullset,&old);
 205         todo=pending;
 206         sigemptyset(&pending);
 207         sigprocmask(SIG_SETMASK,&old,NULL);
 208
 209         for (n=sigs; n; n=n->next)
 210             if (sigismember(&todo,n->signum))
 211                 n->notify(n->cst,n->signum);
 212     }
 213 }
 214
 215 void afterfork(void)
 216 {
 217     struct signotify *n;
 218     sigset_t done;
 219     struct sigaction sa;
 220
 221     sigemptyset(&done);
 222     for (n=sigs; n; n=n->next)
 223         if (!sigismember(&done,n->signum)) {
 224             sigaddset(&done,n->signum);
 225             sa.sa_handler=SIG_DFL;
 226             sa.sa_mask=emptyset;
 227             sa.sa_flags=0;
 228             sigaction(n->signum,&sa,NULL);
 229         }
 230
 231     sigemptyset(&emptyset);
 232     sigprocmask(SIG_SETMASK,&emptyset,NULL);
 233 }
 234
 235 static void signal_handler(int signum)
 236 {
 237     int saved_errno;
 238     uint8_t thing=0;
 239     sigaddset(&pending,signum);
 240     /* XXX the write() may set errno, which can make the main program fail.
 241        However, signal handlers aren't allowed to modify anything which
 242        is not of type sig_atomic_t.  The world is broken. */
 243     /* I have decided to save and restore errno anyway; on most
 244        architectures on which secnet can run modifications to errno
 245        will be atomic, and it seems to be the lesser of the two
 246        evils. */
 247     saved_errno=errno;
 248     discard(write(spw,&thing,1));
 249                          /* We don't care if this fails (i.e. the pipe
 250                             is full) because the service routine will
 251                             spot the pending signal anyway */
 252     errno=saved_errno;
 253 }
 254
 255 static void register_signal_handler(struct signotify *s)
 256 {
 257     struct sigaction sa;
 258     int rv;
 259
 260     if (!signal_handling) return;
 261
 262     if (sigismember(&registered,s->signum)) return;
 263     sigaddset(&registered,s->signum);
 264
 265     sa.sa_handler=signal_handler;
 266     sa.sa_mask=fullset;
 267     sa.sa_flags=0;
 268     rv=sigaction(s->signum,&sa,NULL);
 269     if (rv!=0) {
 270         fatal_perror("register_signal_handler: sigaction(%d)",s->signum);
 271     }
 272 }
 273
 274 void request_signal_notification(int signum, signal_notify_fn *notify,
 275                                  void *cst)
 276 {
 277     struct signotify *s;
 278     sigset_t old;
 279
 280     s=safe_malloc(sizeof(*s),"request_signal_notification");
 281     s->signum=signum;
 282     s->notify=notify;
 283     s->cst=cst;
 284     s->next=sigs;
 285     sigprocmask(SIG_SETMASK,&fullset,&old);
 286     sigs=s;
 287     register_signal_handler(s);
 288     sigprocmask(SIG_SETMASK,&old,NULL);
 289 }
 290
 291 void start_signal_handling(void)
 292 {
 293     int p[2];
 294     struct signotify *i;
 295
 296     sigemptyset(&emptyset);
 297     sigfillset(&fullset);
 298     sigemptyset(&registered);
 299     sigemptyset(&pending);
 300
 301     pipe_cloexec(p);
 302     spw=p[1];
 303     spr=p[0];
 304     setnonblock(spw);
 305     setnonblock(spr);
 306
 307     register_for_poll(NULL,signal_beforepoll,signal_afterpoll,"signal");
 308     signal_handling=True;
 309
 310     /* Register signal handlers for all the signals we're interested in */
 311     for (i=sigs; i; i=i->next) {
 312         register_signal_handler(i);
 313     }
 314
 315     request_signal_notification(SIGCHLD,sigchld_handler,NULL);
 316 }