process.c

   1 /*
   2  * userv - process.c
   3  * daemon code to process one request (is parent of service process)
   4  *
   5  * Copyright (C)1996-1999,2001,2003 Ian Jackson
   6  *
   7  * This is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with userv; if not, write to the Free Software
  19  * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*
  23  * We do some horrible asynchronous stuff with signals.
  24  *
  25  * The following objects &c. are used in signal handlers and so
  26  * must be protected by calls to blocksignals if they are used in
  27  * the main program:
  28  *  the syslog() family of calls, and the associated
  29  *    syslogopenfacility variable
  30  *  swfile (stdio stream)
  31  *
  32  * The following objects are used in the main program unprotected
  33  * and so must not be used in signal handlers:
  34  *  srfile
  35  *
  36  * child and childtokill are used for communication between the
  37  * main thread and the signal handlers; none of the signal handlers
  38  * return so errno is OK too.
  39  */
  40
  41 #include <stdio.h>
  42 #include <stdarg.h>
  43 #include <unistd.h>
  44 #include <assert.h>
  45 #include <signal.h>
  46 #include <string.h>
  47 #include <stdlib.h>
  48 #include <errno.h>
  49 #include <syslog.h>
  50 #include <pwd.h>
  51 #include <grp.h>
  52 #include <limits.h>
  53 #include <fcntl.h>
  54 #include <sys/wait.h>
  55 #include <sys/time.h>
  56 #include <sys/resource.h>
  57 #include <sys/types.h>
  58 #include <sys/stat.h>
  59 #include <sys/socket.h>
  60 #include <sys/un.h>
  61
  62 #include "config.h"
  63 #include "common.h"
  64 #include "both.h"
  65 #include "daemon.h"
  66 #include "lib.h"
  67 #include "tokens.h"
  68
  69 /* NB: defaults for the execution state are not set here, but in
  70  * the RESET_CONFIGURATION #define in daemon.h. */
  71 struct request_msg request_mbuf;
  72 struct keyvaluepair *defvararray;
  73 struct fdstate *fdarray;
  74 int fdarraysize, fdarrayused;
  75 int restfdwantstate= tokv_word_rejectfd, restfdwantrw;
  76 int service_ngids;
  77 char **argarray;
  78 char *serviceuser, *service, *loginname, *cwd;
  79 char *overridedata, *userrcfile;
  80 char *serviceuser_dir, *serviceuser_shell, *callinguser_shell;
  81 gid_t *calling_gids, *service_gids;
  82 uid_t serviceuser_uid=-1;
  83 const char **calling_groups, **service_groups;
  84 char *execpath, **execargs;
  85 int execute;
  86 int setenvironment, suppressargs, disconnecthup;
  87 builtinserviceexec_fnt *execbuiltin;
  88 int syslogopenfacility=-1;
  89
  90 static FILE *swfile, *srfile;
  91 static pid_t child=-1, childtokill=-1;
  92 static pid_t mypid;
  93
  94 /* Function shared with servexec.c: */
  95
  96 int synchread(int fd, int ch) {
  97   char synchmsg;
  98   int r;
  99
 100   for (;;) {
 101     r= read(fd,&synchmsg,1);
 102     if (r==1) break;
 103     if (r==0) { errno= ECONNRESET; return -1; }
 104     assert(r<0);
 105     if (errno!=EINTR) return -1;
 106   };
 107   assert(synchmsg==ch);
 108   return 0;
 109 }
 110
 111 const char *defaultpath(void) {
 112   return serviceuser_uid ? DEFAULTPATH_USER : DEFAULTPATH_ROOT;
 113 }
 114
 115 /* General-purpose functions; these do nothing special about signals */
 116
 117 static void blocksignals(void) {
 118   int r;
 119   sigset_t set;
 120
 121   sigemptyset(&set);
 122   sigaddset(&set,SIGCHLD);
 123   sigaddset(&set,SIGPIPE);
 124   r= sigprocmask(SIG_BLOCK,&set,0); assert(!r);
 125 }
 126
 127 static void xfwriteerror(void) {
 128   if (errno != EPIPE) syscallerror("writing to client");
 129   blocksignals();
 130   ensurelogopen(USERVD_LOGFACILITY);
 131   syslog(LOG_INFO,"client went away (broken pipe)");
 132   disconnect(8);
 133 }
 134
 135 static void xfwrite(const void *p, size_t sz, FILE *file) {
 136   size_t nr;
 137   nr= fwrite(p,1,sz,file);
 138   if (nr != sz) xfwriteerror();
 139 }
 140
 141 static void xfflush(FILE *file) {
 142   if (fflush(file)) xfwriteerror();
 143 }
 144
 145 /* Functions which may be called only from the main thread.  These may
 146  * use main-thread objects and must block signals before using signal
 147  * handler objects.
 148  */
 149
 150 static void xfread(void *p, size_t sz) {
 151   size_t nr;
 152   nr= working_fread(p,sz,srfile); if (nr == sz) return;
 153   if (ferror(srfile)) syscallerror("reading from client");
 154   blocksignals();
 155   assert(feof(srfile));
 156   syslog(LOG_INFO,"client went away (unexpected EOF)");
 157   swfile= 0;
 158   disconnect(8);
 159 }
 160
 161 static char *xfreadsetstring(int l) {
 162   char *s;
 163   assert(l<=MAX_GENERAL_STRING);
 164   s= xmalloc(l+1);
 165   xfread(s,sizeof(*s)*l);
 166   s[l]= 0;
 167   return s;
 168 }
 169
 170 static char *xfreadstring(void) {
 171   int l;
 172   xfread(&l,sizeof(l));
 173   return xfreadsetstring(l);
 174 }
 175
 176 static void getevent(struct event_msg *event_r) {
 177   int fd;
 178
 179   for (;;) {
 180     xfread(event_r,sizeof(struct event_msg));
 181     switch (event_r->type) {
 182     case et_closereadfd:
 183       fd= event_r->data.closereadfd.fd;
 184       if (fd >= fdarrayused) {
 185         blocksignals();
 186         syslog(LOG_ERR,"client sent bad file descriptor %d to close (max %d)",
 187                fd,fdarrayused-1);
 188         disconnect(20);
 189       }
 190       if (fdarray[fd].holdfd!=-1) {
 191         if (close(fdarray[fd].holdfd)) syscallerror("cannot close holding fd");
 192         fdarray[fd].holdfd= -1;
 193       }
 194       break;
 195     case et_disconnect:
 196       blocksignals();
 197       syslog(LOG_INFO,"client disconnected");
 198       disconnect(4);
 199     default:
 200       return;
 201     }
 202   }
 203 }
 204
 205 /* Functions which may be called either from signal handlers or from
 206  * the main thread.  They block signals in case they are on the main
 207  * thread, and may only use signal handler objects.  None of them
 208  * return.  If they did they'd have to restore the signal mask.
 209  */
 210
 211 void miscerror(const char *what) {
 212   blocksignals();
 213   syslog(LOG_ERR,"failure: %s",what);
 214   disconnect(16);
 215 }
 216
 217 void syscallerror(const char *what) {
 218   int e;
 219
 220   e= errno;
 221   blocksignals();
 222   syslog(LOG_ERR,"system call failure: %s: %s",what,strerror(e));
 223   disconnect(16);
 224 }
 225
 226 /* Functions which may be called from signal handlers.  These
 227  * may use signal-handler objects.  The main program may only
 228  * call them with signals blocked, and they may not use any
 229  * main-thread objects.
 230  */
 231
 232 void ensurelogopen(int wantfacility) {
 233   if (syslogopenfacility==wantfacility) return;
 234   if (syslogopenfacility!=-1) closelog();
 235   openlog(USERVD_LOGIDENT,LOG_NDELAY|LOG_PID,wantfacility);
 236   syslogopenfacility= wantfacility;
 237 }
 238
 239 void NONRETURNING disconnect(int exitstatus) {
 240   /* This function can sometimes indirectly call itself (eg,
 241    * xfwrite, syscallerror can cause it to be called).  So, all
 242    * the global variables indicating need for action are reset
 243    * before the action is taken so that if it fails it isn't
 244    * attempted again.
 245    */
 246   struct progress_msg progress_mbuf;
 247   FILE *swfilereal;
 248   pid_t orgtokill;
 249   int r;
 250
 251   if (childtokill!=-1 && disconnecthup) {
 252     orgtokill= childtokill;
 253     childtokill= -1;
 254     if (disconnecthup) {
 255       r= kill(-orgtokill,SIGHUP);
 256       if (r && errno!=EPERM && errno!=ESRCH)
 257         syscallerror("sending SIGHUP to service process group");
 258     }
 259     child= -1;
 260   }
 261   if (swfile) {
 262     swfilereal= swfile;
 263     swfile= 0;
 264     memset(&progress_mbuf,0,sizeof(progress_mbuf));
 265     progress_mbuf.magic= PROGRESS_MAGIC;
 266     progress_mbuf.type= pt_failed;
 267     xfwrite(&progress_mbuf,sizeof(progress_mbuf),swfilereal);
 268     xfflush(swfilereal);
 269   }
 270
 271   _exit(exitstatus);
 272 }
 273
 274 static void reporttermination(int status) {
 275   struct progress_msg progress_mbuf;
 276
 277   memset(&progress_mbuf,0,sizeof(progress_mbuf));
 278   progress_mbuf.magic= PROGRESS_MAGIC;
 279   progress_mbuf.type= pt_terminated;
 280   progress_mbuf.data.terminated.status= status;
 281   xfwrite(&progress_mbuf,sizeof(progress_mbuf),swfile);
 282   xfflush(swfile);
 283 }
 284
 285 static void NONRETURNING sighandler_chld(int ignored) {
 286   int status;
 287   pid_t returned;
 288
 289   returned= wait3(&status,WNOHANG,0);
 290   if (returned==-1) syscallerror("wait for child failed");
 291   if (!returned) syscallerror("spurious sigchld");
 292   if (returned!=child) syscallerror("spurious child process");
 293   child= childtokill= -1;
 294
 295   reporttermination(status);
 296   syslog(LOG_INFO,"service completed (status %d %d)",(status>>8)&0x0ff,status&0x0ff);
 297   _exit(0);
 298 }
 299
 300 /* Functions which are called only during setup, before
 301  * the signal asynchronicity starts.  They can do anything they like.
 302  */
 303
 304 void ensurefdarray(int fd) {
 305   if (fd < fdarrayused) return;
 306   if (fd >= fdarraysize) {
 307     fdarraysize= ((fd+2)<<1);
 308     fdarray= xrealloc(fdarray,sizeof(struct fdstate)*fdarraysize);
 309   }
 310   while (fd >= fdarrayused) {
 311     fdarray[fdarrayused].iswrite= -1;
 312     fdarray[fdarrayused].realfd= -1;
 313     fdarray[fdarrayused].holdfd= -1;
 314     fdarray[fdarrayused].wantstate= restfdwantstate;
 315     fdarray[fdarrayused].wantrw= restfdwantrw;
 316     fdarrayused++;
 317   }
 318 }
 319
 320 static void NONRETURNING generalfailure(const char *prefix, int reserveerrno,
 321                                         int errnoval, const char *fmt, va_list al) {
 322   char errmsg[MAX_ERRMSG_LEN];
 323
 324   if (prefix) {
 325     strnycpy(errmsg,prefix,sizeof(errmsg));
 326     strnytcat(errmsg,": ",sizeof(errmsg));
 327   } else {
 328     errmsg[0]= 0;
 329   }
 330   vsnytprintfcat(errmsg,sizeof(errmsg)-reserveerrno,fmt,al);
 331   if (reserveerrno) {
 332     strnytcat(errmsg,": ",sizeof(errmsg));
 333     strnytcat(errmsg,strerror(errnoval),sizeof(errmsg));
 334   }
 335   senderrmsgstderr(errmsg);
 336   syslog(LOG_INFO,"service failed (%s)",errmsg);
 337   disconnect(12);
 338 }
 339
 340 static void NONRETURNPRINTFFORMAT(1,2) failure(const char *fmt, ...) {
 341   va_list al;
 342
 343   va_start(al,fmt);
 344   generalfailure(0,0,0,fmt,al);
 345 }
 346
 347 static void NONRETURNPRINTFFORMAT(1,2) syscallfailure(const char *fmt, ...) {
 348   va_list al;
 349   int e;
 350
 351   e= errno;
 352   va_start(al,fmt);
 353   generalfailure("system call failed",ERRMSG_RESERVE_ERRNO,e,fmt,al);
 354 }
 355
 356 void senderrmsgstderr(const char *errmsg) {
 357   struct progress_msg progress_mbuf;
 358   unsigned long ul;
 359   int l;
 360
 361   l= strlen(errmsg);
 362   memset(&progress_mbuf,0,sizeof(progress_mbuf));
 363   progress_mbuf.magic= PROGRESS_MAGIC;
 364   progress_mbuf.type= pt_errmsg;
 365   progress_mbuf.data.errmsg.messagelen= l;
 366   xfwrite(&progress_mbuf,sizeof(progress_mbuf),swfile);
 367   xfwrite(errmsg,l,swfile);
 368   ul= PROGRESS_ERRMSG_END_MAGIC;
 369   xfwrite(&ul,sizeof(ul),swfile);
 370   xfflush(swfile);
 371 }
 372
 373 /* The per-request main program and its subfunctions. */
 374
 375 static void setup_comms(int sfd) {
 376   static char swbuf[BUFSIZ];
 377   static char srbuf[BUFSIZ];
 378
 379   struct sigaction sig;
 380
 381   ensurelogopen(USERVD_LOGFACILITY);
 382   syslog(LOG_DEBUG,"call connected");
 383
 384   mypid= getpid(); if (mypid == -1) syscallerror("getpid");
 385
 386   sig.sa_handler= SIG_IGN;
 387   sigemptyset(&sig.sa_mask);
 388   sig.sa_flags= 0;
 389   if (sigaction(SIGPIPE,&sig,0)) syscallerror("cannot ignore sigpipe");
 390
 391   srfile= fdopen(sfd,"r");
 392   if (!srfile) syscallerror("turn socket fd into reading FILE*");
 393   if (setvbuf(srfile,srbuf,_IOFBF,sizeof(srbuf)))
 394     syscallerror("set buffering on socket reads");
 395
 396   swfile= fdopen(sfd,"w");
 397   if (!swfile) syscallerror("turn socket fd into writing FILE*");
 398   if (setvbuf(swfile,swbuf,_IOFBF,sizeof(swbuf)))
 399     syscallerror("set buffering on socket writes");
 400 }
 401
 402 static void send_opening(void) {
 403   struct opening_msg opening_mbuf;
 404
 405   memset(&opening_mbuf,0,sizeof(opening_mbuf));
 406   opening_mbuf.magic= OPENING_MAGIC;
 407   memcpy(opening_mbuf.protocolchecksumversion,protocolchecksumversion,PCSUMSIZE);
 408   opening_mbuf.overlordpid= overlordpid;
 409   opening_mbuf.serverpid= mypid;
 410   xfwrite(&opening_mbuf,sizeof(opening_mbuf),swfile);
 411   xfflush(swfile);
 412 }
 413
 414 static void receive_request(void) {
 415   int i, fd;
 416   unsigned long ul;
 417
 418   xfread(&request_mbuf,sizeof(request_mbuf));
 419   serviceuser= xfreadsetstring(request_mbuf.serviceuserlen);
 420   service= xfreadsetstring(request_mbuf.servicelen);
 421   assert(request_mbuf.spoofed==0 || request_mbuf.spoofed==1);
 422   loginname= xfreadsetstring(request_mbuf.loginnamelen);
 423   cwd= xfreadsetstring(request_mbuf.cwdlen);
 424   if (request_mbuf.overridelen >= 0) {
 425     assert(request_mbuf.overridelen <= MAX_OVERRIDE_LEN);
 426     overridedata= xfreadsetstring(request_mbuf.overridelen);
 427   } else {
 428     assert(request_mbuf.overridelen == -1);
 429     overridedata= 0;
 430   }
 431   assert(request_mbuf.ngids <= MAX_GIDS);
 432   calling_gids= xmalloc(sizeof(gid_t)*request_mbuf.ngids);
 433   xfread(calling_gids,sizeof(gid_t)*request_mbuf.ngids);
 434
 435   fdarraysize= 4; fdarray= xmalloc(sizeof(struct fdstate)*fdarraysize);
 436   fdarrayused= 1; fdarray[0].iswrite= -1;
 437   fdarray[0].wantstate= tokv_word_rejectfd;
 438   assert(request_mbuf.nreadfds+request_mbuf.nwritefds <= MAX_ALLOW_FD+1);
 439   for (i=0; i<request_mbuf.nreadfds+request_mbuf.nwritefds; i++) {
 440     xfread(&fd,sizeof(int));
 441     assert(fd <= MAX_ALLOW_FD);
 442     ensurefdarray(fd);
 443     assert(fdarray[fd].iswrite == -1);
 444     fdarray[fd].iswrite= (i>=request_mbuf.nreadfds);
 445   }
 446   /* fdarray[].iswrite now set; rest is still blank
 447    * (ie want reject read, no realfd holdfd). */
 448
 449   assert(request_mbuf.nargs <= MAX_ARGSDEFVAR);
 450   argarray= xmalloc(sizeof(char*)*(request_mbuf.nargs));
 451   for (i=0; i<request_mbuf.nargs; i++) argarray[i]= xfreadstring();
 452   assert(request_mbuf.nvars <= MAX_ARGSDEFVAR);
 453   defvararray= xmalloc(sizeof(struct keyvaluepair)*request_mbuf.nvars);
 454   for (i=0; i<request_mbuf.nvars; i++) {
 455     defvararray[i].key= xfreadstring();
 456     assert(defvararray[i].key[0]);
 457     defvararray[i].value= xfreadstring();
 458   }
 459   xfread(&ul,sizeof(ul));
 460   assert(ul == REQUEST_END_MAGIC);
 461 }
 462
 463 static void establish_pipes(void) {
 464   int fd, tempfd;
 465   char pipepathbuf[PIPEMAXLEN+2];
 466
 467   for (fd=0; fd<fdarrayused; fd++) {
 468     if (fdarray[fd].iswrite == -1) continue;
 469     pipepathbuf[sizeof(pipepathbuf)-2]= 0;
 470     snyprintf(pipepathbuf,sizeof(pipepathbuf),PIPEFORMAT,
 471               (unsigned long)request_mbuf.clientpid,(unsigned long)mypid,fd);
 472     assert(!pipepathbuf[sizeof(pipepathbuf)-2]);
 473     tempfd= open(pipepathbuf,O_RDWR);
 474     if (tempfd<0) syscallerror("prelim open pipe");
 475     if (fdarray[fd].iswrite) {
 476       fdarray[fd].holdfd= -1;
 477       fdarray[fd].realfd= open(pipepathbuf, O_WRONLY);
 478     } else {
 479       fdarray[fd].holdfd= open(pipepathbuf, O_WRONLY);
 480       if (fdarray[fd].holdfd<0) syscallerror("hold open pipe");
 481       fdarray[fd].realfd= open(pipepathbuf, O_RDONLY);
 482     }
 483     if (fdarray[fd].realfd<0) syscallerror("real open pipe");
 484     if (unlink(pipepathbuf)) syscallerror("unlink pipe");
 485     if (close(tempfd)) syscallerror("close prelim fd onto pipe");
 486   }
 487   /* Now fdarray[].realfd is pipe end for service in case service
 488    * wants it.  If it's an input pipe, then .holdfd is the other
 489    * (writing) end of the pipe - we keep it around so that the service
 490    * doesn't get an apparently clean EOF if the caller disappears (eg
 491    * due to a file read error) or the like (ie so that on disconnect
 492    * we can guarantee to send the service SIGHUP before it gets EOF on
 493    * the input fd).  Otherwise, .holdfd=-1.
 494    */
 495 }
 496
 497 static void groupnames(int ngids, gid_t *gids, const char ***names_r) {
 498   const char **names;
 499   struct group *gr;
 500   int i;
 501
 502   names= xmalloc(sizeof(char*)*ngids);
 503   for (i=0; i<ngids; i++) {
 504     gr= getgrgid(gids[i]);
 505     if (!gr) miscerror("get group entry");
 506     names[i]= xstrsave(gr->gr_name);
 507   }
 508   *names_r= names;
 509 }
 510
 511 static void lookup_uidsgids(void) {
 512   struct passwd *pw;
 513
 514   pw= getpwnam(loginname);
 515   if (!pw) miscerror("look up calling user");
 516   assert(!strcmp(pw->pw_name,loginname));
 517   callinguser_shell= xstrsave(pw->pw_shell);
 518
 519   pw= getpwnam(serviceuser);
 520   if (!pw) miscerror("look up service user");
 521   assert(!strcmp(pw->pw_name,serviceuser));
 522   serviceuser_dir= xstrsave(nondebug_serviceuserdir(pw->pw_dir));
 523   serviceuser_shell= xstrsave(pw->pw_shell);
 524   serviceuser_uid= pw->pw_uid;
 525
 526   if (setregid(pw->pw_gid,pw->pw_gid)) syscallerror("setregid 1");
 527   if (initgroups(pw->pw_name,pw->pw_gid)) syscallerror("initgroups");
 528   if (setreuid(pw->pw_uid,pw->pw_uid)) syscallerror("setreuid 1");
 529   if (setreuid(pw->pw_uid,pw->pw_uid)) syscallerror("setreuid 2");
 530   if (pw->pw_uid) {
 531     if (!setreuid(pw->pw_uid,0)) miscerror("setreuid 3 unexpectedly succeeded");
 532     if (errno != EPERM) syscallerror("setreuid 3 failed in unexpected way");
 533   }
 534   if (setregid(pw->pw_gid,pw->pw_gid)) syscallerror("setregid 2");
 535
 536   service_ngids= getgroups(0,0); if (service_ngids == -1) syscallerror("getgroups(0,0)");
 537   if (service_ngids > MAX_GIDS) miscerror("service user is in far too many groups");
 538   service_gids= xmalloc(sizeof(gid_t)*(service_ngids+1));
 539   service_gids[0]= pw->pw_gid;
 540   if (getgroups(service_ngids,service_gids+1) != service_ngids)
 541     syscallerror("getgroups(size,list)");
 542
 543   groupnames(request_mbuf.ngids,calling_gids,&calling_groups);
 544   groupnames(service_ngids,service_gids,&service_groups);
 545 }
 546
 547 static void findinpath(char *program) {
 548   char *part, *exectry;
 549   const char *string, *delim, *nextstring;
 550   struct stat stab;
 551   int r, partsize;
 552
 553   if (strchr(program,'/')) {
 554     r= stat(program,&stab);
 555     if (r) syscallfailure("failed check for program (containing slash) `%s'",program);
 556     execpath= program;
 557   } else {
 558     string= getenv("PATH");
 559     if (!string) string= defaultpath();
 560     while (string) {
 561       delim= strchr(string,':');
 562       if (delim) {
 563         if (delim-string > MAX_GENERAL_STRING)
 564           failure("execute-from-path, but PATH component too long");
 565         partsize= delim-string;
 566         nextstring= delim+1;
 567       } else {
 568         partsize= strlen(string);
 569         nextstring= 0;
 570       }
 571       part= xstrsubsave(string,partsize);
 572       exectry= part[0] ? xstrcat3save(part,"/",program) : xstrsave(program);
 573       free(part);
 574       r= stat(exectry,&stab);
 575       if (!r) { execpath= exectry; break; }
 576       free(exectry);
 577       string= nextstring;
 578     }
 579     if (!execpath) failure("program `%s' not found on default PATH",program);
 580   }
 581 }
 582
 583 static void check_find_executable(void) {
 584   struct stat stab;
 585   int r;
 586
 587   switch (execute) {
 588   case tokv_word_reject:
 589     failure("request rejected");
 590   case tokv_word_execute:
 591     findinpath(execpath);
 592     break;
 593   case tokv_word_executefromdirectory:
 594     r= stat(execpath,&stab);
 595     if (r) syscallfailure("checking for executable in directory, `%s'",execpath);
 596     break;
 597   case tokv_word_executebuiltin:
 598     break;
 599   case tokv_word_executefrompath:
 600     findinpath(service);
 601     break;
 602   default:
 603     abort();
 604   }
 605 }
 606
 607 static void makenonexistentfd(int fd) {
 608   if (fdarray[fd].realfd == -1) {
 609     assert(fdarray[fd].holdfd == -1);
 610   } else {
 611     if (close(fdarray[fd].realfd))
 612       syscallfailure("close unwanted file descriptor %d",fd);
 613     fdarray[fd].realfd= -1;
 614
 615     if (fdarray[fd].holdfd != -1) {
 616       if (close(fdarray[fd].holdfd))
 617         syscallfailure("close unwanted hold descriptor for %d",fd);
 618       fdarray[fd].holdfd= -1;
 619     }
 620   }
 621 }
 622
 623 static void makenullfd(int fd) {
 624   fdarray[fd].realfd= open("/dev/null",
 625                            fdarray[fd].wantrw == tokv_word_read ? O_RDONLY :
 626                            fdarray[fd].wantrw == tokv_word_write ? O_WRONLY :
 627                            0);
 628   if (fdarray[fd].realfd<0)
 629     syscallfailure("cannot open /dev/null for null or allowed, unprovided fd");
 630 }
 631
 632 static void check_fds(void) {
 633   int fd;
 634
 635   assert(fdarrayused>=2);
 636   if (!(fdarray[2].wantstate == tokv_word_requirefd ||
 637         fdarray[2].wantstate == tokv_word_allowfd) ||
 638       fdarray[2].wantrw != tokv_word_write)
 639     failure("must have stderr (fd 2), but file descriptor setup in "
 640             "configuration does not have it or not for writing");
 641
 642   for (fd=0; fd<fdarrayused; fd++) {
 643     switch (fdarray[fd].wantstate) {
 644     case tokv_word_rejectfd:
 645       if (fdarray[fd].realfd != -1)
 646         failure("file descriptor %d provided but rejected",fd);
 647       break;
 648     case tokv_word_ignorefd:
 649       makenonexistentfd(fd);
 650       break;
 651     case tokv_word_nullfd:
 652       makenonexistentfd(fd);
 653       makenullfd(fd);
 654       break;
 655     case tokv_word_requirefd:
 656       if (fdarray[fd].realfd == -1)
 657         failure("file descriptor %d required but not provided",fd);
 658       /* fall through */
 659     case tokv_word_allowfd:
 660       if (fdarray[fd].realfd == -1) {
 661         assert(fdarray[fd].holdfd == -1);
 662         makenullfd(fd);
 663       } else {
 664         if (fdarray[fd].iswrite) {
 665           if (fdarray[fd].wantrw == tokv_word_read)
 666             failure("file descriptor %d provided write, wanted read",fd);
 667         } else {
 668           if (fdarray[fd].wantrw == tokv_word_write)
 669             failure("file descriptor %d provided read, wanted write",fd);
 670         }
 671       }
 672     }
 673   }
 674   /* Now fdarray[].realfd is exactly what service wants: pipe end or
 675    * /dev/null or -1.  If .realfd is not -1 then .holdfd may be the fd
 676    * for the writing end of the corresponding pipe.
 677    */
 678 }
 679
 680 static void send_progress_ok(void) {
 681   struct progress_msg progress_mbuf;
 682
 683   memset(&progress_mbuf,0,sizeof(progress_mbuf));
 684   progress_mbuf.magic= PROGRESS_MAGIC;
 685   progress_mbuf.type= pt_ok;
 686   xfwrite(&progress_mbuf,sizeof(progress_mbuf),swfile);
 687   xfflush(swfile);
 688 }
 689
 690 static void fork_service_synch(void) {
 691   pid_t newchild;
 692   struct sigaction sig;
 693   int r, synchsocket[2];
 694   char synchmsg;
 695
 696   r= socketpair(AF_UNIX,SOCK_STREAM,0,synchsocket);
 697   if (r) syscallerror("cannot create socket for synch");
 698
 699   /* Danger here.  Firstly, we start handling signals asynchronously.
 700    * Secondly after we fork the service we want it to put
 701    * itself in a separate process group so that we can kill it and all
 702    * its children - but, we mustn't kill the whole pgrp before it has
 703    * done that (or we kill ourselves) and it mustn't fork until it
 704    * knows that we are going to kill it the right way ...
 705    */
 706   sig.sa_handler= sighandler_chld;
 707   sigemptyset(&sig.sa_mask);
 708   sigaddset(&sig.sa_mask,SIGCHLD);
 709   sig.sa_flags= 0;
 710   if (sigaction(SIGCHLD,&sig,0)) syscallerror("cannot set sigchld handler");
 711
 712   newchild= fork();
 713   if (newchild == -1) syscallerror("cannot fork to invoke service");
 714   if (!newchild) execservice(synchsocket,fileno(swfile));
 715   childtokill= child= newchild;
 716
 717   if (close(synchsocket[1])) syscallerror("cannot close other end of synch socket");
 718
 719   r= synchread(synchsocket[0],'y');
 720   if (r) syscallerror("read synch byte from child");
 721
 722   childtokill= -child;
 723
 724   synchmsg= 'g';
 725   r= write(synchsocket[0],&synchmsg,1);
 726   if (r!=1) syscallerror("write synch byte to child");
 727
 728   if (close(synchsocket[0])) syscallerror("cannot close my end of synch socket");
 729 }
 730
 731 void servicerequest(int sfd) {
 732   struct event_msg event_mbuf;
 733   int r;
 734
 735   setup_comms(sfd);
 736   send_opening();
 737   receive_request();
 738   if (request_mbuf.clientpid == (pid_t)-1) _exit(2);
 739   establish_pipes();
 740   lookup_uidsgids();
 741   debug_dumprequest(mypid);
 742   syslog(LOG_INFO,"%s %s -> %s %c %s",
 743          request_mbuf.spoofed ? "spoof" : "user",
 744          loginname, serviceuser, overridedata?'!':':', service);
 745
 746   if (overridedata)
 747     r= parse_string(TOPLEVEL_OVERRIDDEN_CONFIGURATION,
 748                     "<builtin toplevel override configuration>",1);
 749   else
 750     r= parse_string(TOPLEVEL_CONFIGURATION,
 751                     "<builtin toplevel configuration>",1);
 752
 753   ensurelogopen(USERVD_LOGFACILITY);
 754   if (r == tokv_error) failure("error encountered while parsing configuration");
 755   assert(r == tokv_quit);
 756
 757   debug_dumpexecsettings();
 758
 759   check_find_executable();
 760   check_fds();
 761   send_progress_ok();
 762
 763   getevent(&event_mbuf);
 764   assert(event_mbuf.type == et_confirm);
 765
 766   if (execbuiltin == bisexec_shutdown && !serviceuser_uid) {
 767     /* The check for the uid is just so we can give a nice
 768      * error message (in the actual code for bisexec_shutdown).
 769      * If this is spoofed somehow then the unlink() will simply fail.
 770      */
 771     r= unlink(RENDEZVOUSPATH);
 772     if (r) syscallfailure("remove rendezvous socket %s",RENDEZVOUSPATH);
 773     syslog(LOG_NOTICE,"arranging for termination, due to client request");
 774     reporttermination(0);
 775     _exit(10);
 776   }
 777
 778   fork_service_synch();
 779
 780   getevent(&event_mbuf);
 781   abort();
 782 }