dbus/dbus-spawn.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-spawn.c Wrapper around fork/exec
   3  *
   4  * Copyright (C) 2002, 2003, 2004  Red Hat, Inc.
   5  * Copyright (C) 2003 CodeFactory AB
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24 #include "dbus-spawn.h"
  25 #include "dbus-sysdeps.h"
  26 #include "dbus-internals.h"
  27 #include "dbus-test.h"
  28 #include "dbus-protocol.h"
  29
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <signal.h>
  33 #include <sys/wait.h>
  34 #include <errno.h>
  35 #include <stdlib.h>
  36
  37 /**
  38  * @addtogroup DBusInternalsUtils
  39  * @{
  40  */
  41
  42 /*
  43  * I'm pretty sure this whole spawn file could be made simpler,
  44  * if you thought about it a bit.
  45  */
  46
  47 /**
  48  * Enumeration for status of a read()
  49  */
  50 typedef enum
  51 {
  52   READ_STATUS_OK,    /**< Read succeeded */
  53   READ_STATUS_ERROR, /**< Some kind of error */
  54   READ_STATUS_EOF    /**< EOF returned */
  55 } ReadStatus;
  56
  57 static ReadStatus
  58 read_ints (int        fd,
  59            int       *buf,
  60            int        n_ints_in_buf,
  61            int       *n_ints_read,
  62            DBusError *error)
  63 {
  64   size_t bytes = 0;
  65   ReadStatus retval;
  66
  67   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  68
  69   retval = READ_STATUS_OK;
  70
  71   while (TRUE)
  72     {
  73       size_t chunk;
  74       size_t to_read;
  75
  76       to_read = sizeof (int) * n_ints_in_buf - bytes;
  77
  78       if (to_read == 0)
  79         break;
  80
  81     again:
  82
  83       chunk = read (fd,
  84                     ((char*)buf) + bytes,
  85                     to_read);
  86
  87       if (chunk < 0 && errno == EINTR)
  88         goto again;
  89
  90       if (chunk < 0)
  91         {
  92           dbus_set_error (error,
  93                           DBUS_ERROR_SPAWN_FAILED,
  94                           "Failed to read from child pipe (%s)",
  95                           _dbus_strerror (errno));
  96
  97           retval = READ_STATUS_ERROR;
  98           break;
  99         }
 100       else if (chunk == 0)
 101         {
 102           retval = READ_STATUS_EOF;
 103           break; /* EOF */
 104         }
 105       else /* chunk > 0 */
 106         bytes += chunk;
 107     }
 108
 109   *n_ints_read = (int)(bytes / sizeof(int));
 110
 111   return retval;
 112 }
 113
 114 static ReadStatus
 115 read_pid (int        fd,
 116           pid_t     *buf,
 117           DBusError *error)
 118 {
 119   size_t bytes = 0;
 120   ReadStatus retval;
 121
 122   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 123
 124   retval = READ_STATUS_OK;
 125
 126   while (TRUE)
 127     {
 128       size_t chunk;
 129       size_t to_read;
 130
 131       to_read = sizeof (pid_t) - bytes;
 132
 133       if (to_read == 0)
 134         break;
 135
 136     again:
 137
 138       chunk = read (fd,
 139                     ((char*)buf) + bytes,
 140                     to_read);
 141       if (chunk < 0 && errno == EINTR)
 142         goto again;
 143
 144       if (chunk < 0)
 145         {
 146           dbus_set_error (error,
 147                           DBUS_ERROR_SPAWN_FAILED,
 148                           "Failed to read from child pipe (%s)",
 149                           _dbus_strerror (errno));
 150
 151           retval = READ_STATUS_ERROR;
 152           break;
 153         }
 154       else if (chunk == 0)
 155         {
 156           retval = READ_STATUS_EOF;
 157           break; /* EOF */
 158         }
 159       else /* chunk > 0 */
 160         bytes += chunk;
 161     }
 162
 163   return retval;
 164 }
 165
 166 /* The implementation uses an intermediate child between the main process
 167  * and the grandchild. The grandchild is our spawned process. The intermediate
 168  * child is a babysitter process; it keeps track of when the grandchild
 169  * exits/crashes, and reaps the grandchild.
 170  */
 171
 172 /* Messages from children to parents */
 173 enum
 174 {
 175   CHILD_EXITED,            /* This message is followed by the exit status int */
 176   CHILD_FORK_FAILED,       /* Followed by errno */
 177   CHILD_EXEC_FAILED,       /* Followed by errno */
 178   CHILD_PID                /* Followed by pid_t */
 179 };
 180
 181 /**
 182  * Babysitter implementation details
 183  */
 184 struct DBusBabysitter
 185 {
 186   int refcount; /**< Reference count */
 187
 188   char *executable; /**< executable name to use in error messages */
 189
 190   int socket_to_babysitter; /**< Connection to the babysitter process */
 191   int error_pipe_from_child; /**< Connection to the process that does the exec() */
 192
 193   pid_t sitter_pid;  /**< PID Of the babysitter */
 194   pid_t grandchild_pid; /**< PID of the grandchild */
 195
 196   DBusWatchList *watches; /**< Watches */
 197
 198   DBusWatch *error_watch; /**< Error pipe watch */
 199   DBusWatch *sitter_watch; /**< Sitter pipe watch */
 200
 201   int errnum; /**< Error number */
 202   int status; /**< Exit status code */
 203   unsigned int have_child_status : 1; /**< True if child status has been reaped */
 204   unsigned int have_fork_errnum : 1; /**< True if we have an error code from fork() */
 205   unsigned int have_exec_errnum : 1; /**< True if we have an error code from exec() */
 206 };
 207
 208 static DBusBabysitter*
 209 _dbus_babysitter_new (void)
 210 {
 211   DBusBabysitter *sitter;
 212
 213   sitter = dbus_new0 (DBusBabysitter, 1);
 214   if (sitter == NULL)
 215     return NULL;
 216
 217   sitter->refcount = 1;
 218
 219   sitter->socket_to_babysitter = -1;
 220   sitter->error_pipe_from_child = -1;
 221
 222   sitter->sitter_pid = -1;
 223   sitter->grandchild_pid = -1;
 224
 225   sitter->watches = _dbus_watch_list_new ();
 226   if (sitter->watches == NULL)
 227     goto failed;
 228
 229   return sitter;
 230
 231  failed:
 232   _dbus_babysitter_unref (sitter);
 233   return NULL;
 234 }
 235
 236 /**
 237  * Increment the reference count on the babysitter object.
 238  *
 239  * @param sitter the babysitter
 240  * @returns the babysitter
 241  */
 242 DBusBabysitter *
 243 _dbus_babysitter_ref (DBusBabysitter *sitter)
 244 {
 245   _dbus_assert (sitter != NULL);
 246   _dbus_assert (sitter->refcount > 0);
 247
 248   sitter->refcount += 1;
 249
 250   return sitter;
 251 }
 252
 253 /**
 254  * Decrement the reference count on the babysitter object.
 255  *
 256  * @param sitter the babysitter
 257  */
 258 void
 259 _dbus_babysitter_unref (DBusBabysitter *sitter)
 260 {
 261   _dbus_assert (sitter != NULL);
 262   _dbus_assert (sitter->refcount > 0);
 263
 264   sitter->refcount -= 1;
 265   if (sitter->refcount == 0)
 266     {
 267       if (sitter->socket_to_babysitter >= 0)
 268         {
 269           close (sitter->socket_to_babysitter);
 270           sitter->socket_to_babysitter = -1;
 271         }
 272
 273       if (sitter->error_pipe_from_child >= 0)
 274         {
 275           close (sitter->error_pipe_from_child);
 276           sitter->error_pipe_from_child = -1;
 277         }
 278
 279       if (sitter->sitter_pid != -1)
 280         {
 281           int status;
 282           int ret;
 283
 284           /* Reap the babysitter */
 285         again:
 286           ret = waitpid (sitter->sitter_pid, &status, 0);
 287           if (ret < 0)
 288             {
 289               if (errno == EINTR)
 290                 goto again;
 291               else if (errno == ECHILD)
 292                 _dbus_warn ("Babysitter process not available to be reaped; should not happen\n");
 293               else
 294                 _dbus_warn ("Unexpected error %d in waitpid() for babysitter: %s\n",
 295                             errno, _dbus_strerror (errno));
 296             }
 297           else
 298             {
 299               _dbus_verbose ("Reaped %ld, waiting for babysitter %ld\n",
 300                              (long) ret, (long) sitter->sitter_pid);
 301
 302               if (WIFEXITED (sitter->status))
 303                 _dbus_verbose ("Babysitter exited with status %d\n",
 304                                WEXITSTATUS (sitter->status));
 305               else if (WIFSIGNALED (sitter->status))
 306                 _dbus_verbose ("Babysitter received signal %d\n",
 307                                WTERMSIG (sitter->status));
 308               else
 309                 _dbus_verbose ("Babysitter exited abnormally\n");
 310             }
 311
 312           sitter->sitter_pid = -1;
 313         }
 314
 315       if (sitter->error_watch)
 316         {
 317           _dbus_watch_invalidate (sitter->error_watch);
 318           _dbus_watch_unref (sitter->error_watch);
 319           sitter->error_watch = NULL;
 320         }
 321
 322       if (sitter->sitter_watch)
 323         {
 324           _dbus_watch_invalidate (sitter->sitter_watch);
 325           _dbus_watch_unref (sitter->sitter_watch);
 326           sitter->sitter_watch = NULL;
 327         }
 328
 329       if (sitter->watches)
 330         _dbus_watch_list_free (sitter->watches);
 331
 332       dbus_free (sitter->executable);
 333
 334       dbus_free (sitter);
 335     }
 336 }
 337
 338 static ReadStatus
 339 read_data (DBusBabysitter *sitter,
 340            int             fd)
 341 {
 342   int what;
 343   int got;
 344   DBusError error;
 345   ReadStatus r;
 346
 347   dbus_error_init (&error);
 348
 349   r = read_ints (fd, &what, 1, &got, &error);
 350
 351   switch (r)
 352     {
 353     case READ_STATUS_ERROR:
 354       _dbus_warn ("Failed to read data from fd %d: %s\n", fd, error.message);
 355       dbus_error_free (&error);
 356       return r;
 357
 358     case READ_STATUS_EOF:
 359       return r;
 360
 361     case READ_STATUS_OK:
 362       break;
 363     }
 364
 365   if (got == 1)
 366     {
 367       switch (what)
 368         {
 369         case CHILD_EXITED:
 370         case CHILD_FORK_FAILED:
 371         case CHILD_EXEC_FAILED:
 372           {
 373             int arg;
 374
 375             r = read_ints (fd, &arg, 1, &got, &error);
 376
 377             switch (r)
 378               {
 379               case READ_STATUS_ERROR:
 380                 _dbus_warn ("Failed to read arg from fd %d: %s\n", fd, error.message);
 381                 dbus_error_free (&error);
 382                 return r;
 383               case READ_STATUS_EOF:
 384                 return r;
 385               case READ_STATUS_OK:
 386                 break;
 387               }
 388
 389             if (got == 1)
 390               {
 391                 if (what == CHILD_EXITED)
 392                   {
 393                     sitter->have_child_status = TRUE;
 394                     sitter->status = arg;
 395                     _dbus_verbose ("recorded child status exited = %d signaled = %d exitstatus = %d termsig = %d\n",
 396                                    WIFEXITED (sitter->status), WIFSIGNALED (sitter->status),
 397                                    WEXITSTATUS (sitter->status), WTERMSIG (sitter->status));
 398                   }
 399                 else if (what == CHILD_FORK_FAILED)
 400                   {
 401                     sitter->have_fork_errnum = TRUE;
 402                     sitter->errnum = arg;
 403                     _dbus_verbose ("recorded fork errnum %d\n", sitter->errnum);
 404                   }
 405                 else if (what == CHILD_EXEC_FAILED)
 406                   {
 407                     sitter->have_exec_errnum = TRUE;
 408                     sitter->errnum = arg;
 409                     _dbus_verbose ("recorded exec errnum %d\n", sitter->errnum);
 410                   }
 411               }
 412           }
 413           break;
 414         case CHILD_PID:
 415           {
 416             pid_t pid = -1;
 417
 418             r = read_pid (fd, &pid, &error);
 419
 420             switch (r)
 421               {
 422               case READ_STATUS_ERROR:
 423                 _dbus_warn ("Failed to read PID from fd %d: %s\n", fd, error.message);
 424                 dbus_error_free (&error);
 425                 return r;
 426               case READ_STATUS_EOF:
 427                 return r;
 428               case READ_STATUS_OK:
 429                 break;
 430               }
 431
 432             sitter->grandchild_pid = pid;
 433
 434             _dbus_verbose ("recorded grandchild pid %d\n", sitter->grandchild_pid);
 435           }
 436           break;
 437         default:
 438           _dbus_warn ("Unknown message received from babysitter process\n");
 439           break;
 440         }
 441     }
 442
 443   return r;
 444 }
 445
 446 static void
 447 close_socket_to_babysitter (DBusBabysitter *sitter)
 448 {
 449   _dbus_verbose ("Closing babysitter\n");
 450   close (sitter->socket_to_babysitter);
 451   sitter->socket_to_babysitter = -1;
 452 }
 453
 454 static void
 455 close_error_pipe_from_child (DBusBabysitter *sitter)
 456 {
 457   _dbus_verbose ("Closing child error\n");
 458   close (sitter->error_pipe_from_child);
 459   sitter->error_pipe_from_child = -1;
 460 }
 461
 462 static void
 463 handle_babysitter_socket (DBusBabysitter *sitter,
 464                           int             revents)
 465 {
 466   /* Even if we have POLLHUP, we want to keep reading
 467    * data until POLLIN goes away; so this function only
 468    * looks at HUP/ERR if no IN is set.
 469    */
 470   if (revents & _DBUS_POLLIN)
 471     {
 472       _dbus_verbose ("Reading data from babysitter\n");
 473       if (read_data (sitter, sitter->socket_to_babysitter) != READ_STATUS_OK)
 474         close_socket_to_babysitter (sitter);
 475     }
 476   else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
 477     {
 478       close_socket_to_babysitter (sitter);
 479     }
 480 }
 481
 482 static void
 483 handle_error_pipe (DBusBabysitter *sitter,
 484                    int             revents)
 485 {
 486   if (revents & _DBUS_POLLIN)
 487     {
 488       _dbus_verbose ("Reading data from child error\n");
 489       if (read_data (sitter, sitter->error_pipe_from_child) != READ_STATUS_OK)
 490         close_error_pipe_from_child (sitter);
 491     }
 492   else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
 493     {
 494       close_error_pipe_from_child (sitter);
 495     }
 496 }
 497
 498 /* returns whether there were any poll events handled */
 499 static dbus_bool_t
 500 babysitter_iteration (DBusBabysitter *sitter,
 501                       dbus_bool_t     block)
 502 {
 503   DBusPollFD fds[2];
 504   int i;
 505   dbus_bool_t descriptors_ready;
 506
 507   descriptors_ready = FALSE;
 508
 509   i = 0;
 510
 511   if (sitter->error_pipe_from_child >= 0)
 512     {
 513       fds[i].fd = sitter->error_pipe_from_child;
 514       fds[i].events = _DBUS_POLLIN;
 515       fds[i].revents = 0;
 516       ++i;
 517     }
 518
 519   if (sitter->socket_to_babysitter >= 0)
 520     {
 521       fds[i].fd = sitter->socket_to_babysitter;
 522       fds[i].events = _DBUS_POLLIN;
 523       fds[i].revents = 0;
 524       ++i;
 525     }
 526
 527   if (i > 0)
 528     {
 529       int ret;
 530
 531       ret = _dbus_poll (fds, i, 0);
 532       if (ret == 0 && block)
 533         ret = _dbus_poll (fds, i, -1);
 534
 535       if (ret > 0)
 536         {
 537           descriptors_ready = TRUE;
 538
 539           while (i > 0)
 540             {
 541               --i;
 542               if (fds[i].fd == sitter->error_pipe_from_child)
 543                 handle_error_pipe (sitter, fds[i].revents);
 544               else if (fds[i].fd == sitter->socket_to_babysitter)
 545                 handle_babysitter_socket (sitter, fds[i].revents);
 546             }
 547         }
 548     }
 549
 550   return descriptors_ready;
 551 }
 552
 553 /**
 554  * Macro returns #TRUE if the babysitter still has live sockets open to the
 555  * babysitter child or the grandchild.
 556  */
 557 #define LIVE_CHILDREN(sitter) ((sitter)->socket_to_babysitter >= 0 || (sitter)->error_pipe_from_child >= 0)
 558
 559 /**
 560  * Blocks until the babysitter process gives us the PID of the spawned grandchild,
 561  * then kills the spawned grandchild.
 562  *
 563  * @param sitter the babysitter object
 564  */
 565 void
 566 _dbus_babysitter_kill_child (DBusBabysitter *sitter)
 567 {
 568   /* be sure we have the PID of the child */
 569   while (LIVE_CHILDREN (sitter) &&
 570          sitter->grandchild_pid == -1)
 571     babysitter_iteration (sitter, TRUE);
 572
 573   _dbus_verbose ("Got child PID %ld for killing\n",
 574                  (long) sitter->grandchild_pid);
 575
 576   if (sitter->grandchild_pid == -1)
 577     return; /* child is already dead, or we're so hosed we'll never recover */
 578
 579   kill (sitter->grandchild_pid, SIGKILL);
 580 }
 581
 582 /**
 583  * Checks whether the child has exited, without blocking.
 584  *
 585  * @param sitter the babysitter
 586  */
 587 dbus_bool_t
 588 _dbus_babysitter_get_child_exited (DBusBabysitter *sitter)
 589 {
 590
 591   /* Be sure we're up-to-date */
 592   while (LIVE_CHILDREN (sitter) &&
 593          babysitter_iteration (sitter, FALSE))
 594     ;
 595
 596   /* We will have exited the babysitter when the child has exited */
 597   return sitter->socket_to_babysitter < 0;
 598 }
 599
 600 /**
 601  * Sets the #DBusError with an explanation of why the spawned
 602  * child process exited (on a signal, or whatever). If
 603  * the child process has not exited, does nothing (error
 604  * will remain unset).
 605  *
 606  * @param sitter the babysitter
 607  * @param error an error to fill in
 608  */
 609 void
 610 _dbus_babysitter_set_child_exit_error (DBusBabysitter *sitter,
 611                                        DBusError      *error)
 612 {
 613   if (!_dbus_babysitter_get_child_exited (sitter))
 614     return;
 615
 616   /* Note that if exec fails, we will also get a child status
 617    * from the babysitter saying the child exited,
 618    * so we need to give priority to the exec error
 619    */
 620   if (sitter->have_exec_errnum)
 621     {
 622       dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
 623                       "Failed to execute program %s: %s",
 624                       sitter->executable, _dbus_strerror (sitter->errnum));
 625     }
 626   else if (sitter->have_fork_errnum)
 627     {
 628       dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
 629                       "Failed to fork a new process %s: %s",
 630                       sitter->executable, _dbus_strerror (sitter->errnum));
 631     }
 632   else if (sitter->have_child_status)
 633     {
 634       if (WIFEXITED (sitter->status))
 635         dbus_set_error (error, DBUS_ERROR_SPAWN_CHILD_EXITED,
 636                         "Process %s exited with status %d",
 637                         sitter->executable, WEXITSTATUS (sitter->status));
 638       else if (WIFSIGNALED (sitter->status))
 639         dbus_set_error (error, DBUS_ERROR_SPAWN_CHILD_SIGNALED,
 640                         "Process %s received signal %d",
 641                         sitter->executable, WTERMSIG (sitter->status));
 642       else
 643         dbus_set_error (error, DBUS_ERROR_FAILED,
 644                         "Process %s exited abnormally",
 645                         sitter->executable);
 646     }
 647   else
 648     {
 649       dbus_set_error (error, DBUS_ERROR_FAILED,
 650                       "Process %s exited, reason unknown",
 651                       sitter->executable);
 652     }
 653 }
 654
 655 /**
 656  * Sets watch functions to notify us when the
 657  * babysitter object needs to read/write file descriptors.
 658  *
 659  * @param sitter the babysitter
 660  * @param add_function function to begin monitoring a new descriptor.
 661  * @param remove_function function to stop monitoring a descriptor.
 662  * @param toggled_function function to notify when the watch is enabled/disabled
 663  * @param data data to pass to add_function and remove_function.
 664  * @param free_data_function function to be called to free the data.
 665  * @returns #FALSE on failure (no memory)
 666  */
 667 dbus_bool_t
 668 _dbus_babysitter_set_watch_functions (DBusBabysitter            *sitter,
 669                                       DBusAddWatchFunction       add_function,
 670                                       DBusRemoveWatchFunction    remove_function,
 671                                       DBusWatchToggledFunction   toggled_function,
 672                                       void                      *data,
 673                                       DBusFreeFunction           free_data_function)
 674 {
 675   return _dbus_watch_list_set_functions (sitter->watches,
 676                                          add_function,
 677                                          remove_function,
 678                                          toggled_function,
 679                                          data,
 680                                          free_data_function);
 681 }
 682
 683 static dbus_bool_t
 684 handle_watch (DBusWatch       *watch,
 685               unsigned int     condition,
 686               void            *data)
 687 {
 688   DBusBabysitter *sitter = data;
 689   int revents;
 690   int fd;
 691
 692   revents = 0;
 693   if (condition & DBUS_WATCH_READABLE)
 694     revents |= _DBUS_POLLIN;
 695   if (condition & DBUS_WATCH_ERROR)
 696     revents |= _DBUS_POLLERR;
 697   if (condition & DBUS_WATCH_HANGUP)
 698     revents |= _DBUS_POLLHUP;
 699
 700   fd = dbus_watch_get_fd (watch);
 701
 702   if (fd == sitter->error_pipe_from_child)
 703     handle_error_pipe (sitter, revents);
 704   else if (fd == sitter->socket_to_babysitter)
 705     handle_babysitter_socket (sitter, revents);
 706
 707   while (LIVE_CHILDREN (sitter) &&
 708          babysitter_iteration (sitter, FALSE))
 709     ;
 710
 711   return TRUE;
 712 }
 713
 714 /** Helps remember which end of the pipe is which */
 715 #define READ_END 0
 716 /** Helps remember which end of the pipe is which */
 717 #define WRITE_END 1
 718
 719
 720 /* Avoids a danger in threaded situations (calling close()
 721  * on a file descriptor twice, and another thread has
 722  * re-opened it since the first close)
 723  */
 724 static int
 725 close_and_invalidate (int *fd)
 726 {
 727   int ret;
 728
 729   if (*fd < 0)
 730     return -1;
 731   else
 732     {
 733       ret = close (*fd);
 734       *fd = -1;
 735     }
 736
 737   return ret;
 738 }
 739
 740 static dbus_bool_t
 741 make_pipe (int         p[2],
 742            DBusError  *error)
 743 {
 744   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 745
 746   if (pipe (p) < 0)
 747     {
 748       dbus_set_error (error,
 749                       DBUS_ERROR_SPAWN_FAILED,
 750                       "Failed to create pipe for communicating with child process (%s)",
 751                       _dbus_strerror (errno));
 752       return FALSE;
 753     }
 754
 755   return TRUE;
 756 }
 757
 758 static void
 759 do_write (int fd, const void *buf, size_t count)
 760 {
 761   size_t bytes_written;
 762   int ret;
 763
 764   bytes_written = 0;
 765
 766  again:
 767
 768   ret = write (fd, ((const char*)buf) + bytes_written, count - bytes_written);
 769
 770   if (ret < 0)
 771     {
 772       if (errno == EINTR)
 773         goto again;
 774       else
 775         {
 776           _dbus_warn ("Failed to write data to pipe!\n");
 777           exit (1); /* give up, we suck */
 778         }
 779     }
 780   else
 781     bytes_written += ret;
 782
 783   if (bytes_written < count)
 784     goto again;
 785 }
 786
 787 static void
 788 write_err_and_exit (int fd, int msg)
 789 {
 790   int en = errno;
 791
 792   do_write (fd, &msg, sizeof (msg));
 793   do_write (fd, &en, sizeof (en));
 794
 795   exit (1);
 796 }
 797
 798 static void
 799 write_pid (int fd, pid_t pid)
 800 {
 801   int msg = CHILD_PID;
 802
 803   do_write (fd, &msg, sizeof (msg));
 804   do_write (fd, &pid, sizeof (pid));
 805 }
 806
 807 static void
 808 write_status_and_exit (int fd, int status)
 809 {
 810   int msg = CHILD_EXITED;
 811
 812   do_write (fd, &msg, sizeof (msg));
 813   do_write (fd, &status, sizeof (status));
 814
 815   exit (0);
 816 }
 817
 818 static void
 819 do_exec (int                       child_err_report_fd,
 820          char                    **argv,
 821          DBusSpawnChildSetupFunc   child_setup,
 822          void                     *user_data)
 823 {
 824 #ifdef DBUS_BUILD_TESTS
 825   int i, max_open;
 826 #endif
 827
 828   _dbus_verbose_reset ();
 829   _dbus_verbose ("Child process has PID %lu\n",
 830                  _dbus_getpid ());
 831
 832   if (child_setup)
 833     (* child_setup) (user_data);
 834
 835 #ifdef DBUS_BUILD_TESTS
 836   max_open = sysconf (_SC_OPEN_MAX);
 837
 838   for (i = 3; i < max_open; i++)
 839     {
 840       int retval;
 841
 842       if (i == child_err_report_fd)
 843         continue;
 844
 845       retval = fcntl (i, F_GETFD);
 846
 847       if (retval != -1 && !(retval & FD_CLOEXEC))
 848         _dbus_warn ("Fd %d did not have the close-on-exec flag set!\n", i);
 849     }
 850 #endif
 851
 852   execv (argv[0], argv);
 853
 854   /* Exec failed */
 855   write_err_and_exit (child_err_report_fd,
 856                       CHILD_EXEC_FAILED);
 857 }
 858
 859 static void
 860 check_babysit_events (pid_t grandchild_pid,
 861                       int   parent_pipe,
 862                       int   revents)
 863 {
 864   pid_t ret;
 865   int status;
 866
 867   ret = waitpid (grandchild_pid, &status, WNOHANG);
 868
 869   if (ret == 0)
 870     {
 871       _dbus_verbose ("no child exited\n");
 872
 873       ; /* no child exited */
 874     }
 875   else if (ret < 0)
 876     {
 877       /* This isn't supposed to happen. */
 878       _dbus_warn ("unexpected waitpid() failure in check_babysit_events(): %s\n",
 879                   _dbus_strerror (errno));
 880       exit (1);
 881     }
 882   else if (ret == grandchild_pid)
 883     {
 884       /* Child exited */
 885       _dbus_verbose ("reaped child pid %ld\n", (long) ret);
 886
 887       write_status_and_exit (parent_pipe, status);
 888     }
 889   else
 890     {
 891       _dbus_warn ("waitpid() reaped pid %d that we've never heard of\n",
 892                   (int) ret);
 893       exit (1);
 894     }
 895
 896   if (revents & _DBUS_POLLIN)
 897     {
 898       _dbus_verbose ("babysitter got POLLIN from parent pipe\n");
 899     }
 900
 901   if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
 902     {
 903       /* Parent is gone, so we just exit */
 904       _dbus_verbose ("babysitter got POLLERR or POLLHUP from parent\n");
 905       exit (0);
 906     }
 907 }
 908
 909 static int babysit_sigchld_pipe = -1;
 910
 911 static void
 912 babysit_signal_handler (int signo)
 913 {
 914   char b = '\0';
 915  again:
 916   write (babysit_sigchld_pipe, &b, 1);
 917   if (errno == EINTR)
 918     goto again;
 919 }
 920
 921 static void
 922 babysit (pid_t grandchild_pid,
 923          int   parent_pipe)
 924 {
 925   int sigchld_pipe[2];
 926
 927   /* We don't exec, so we keep parent state, such as the pid that
 928    * _dbus_verbose() uses. Reset the pid here.
 929    */
 930   _dbus_verbose_reset ();
 931
 932   /* I thought SIGCHLD would just wake up the poll, but
 933    * that didn't seem to work, so added this pipe.
 934    * Probably the pipe is more likely to work on busted
 935    * operating systems anyhow.
 936    */
 937   if (pipe (sigchld_pipe) < 0)
 938     {
 939       _dbus_warn ("Not enough file descriptors to create pipe in babysitter process\n");
 940       exit (1);
 941     }
 942
 943   babysit_sigchld_pipe = sigchld_pipe[WRITE_END];
 944
 945   _dbus_set_signal_handler (SIGCHLD, babysit_signal_handler);
 946
 947   write_pid (parent_pipe, grandchild_pid);
 948
 949   check_babysit_events (grandchild_pid, parent_pipe, 0);
 950
 951   while (TRUE)
 952     {
 953       DBusPollFD pfds[2];
 954
 955       pfds[0].fd = parent_pipe;
 956       pfds[0].events = _DBUS_POLLIN;
 957       pfds[0].revents = 0;
 958
 959       pfds[1].fd = sigchld_pipe[READ_END];
 960       pfds[1].events = _DBUS_POLLIN;
 961       pfds[1].revents = 0;
 962
 963       _dbus_poll (pfds, _DBUS_N_ELEMENTS (pfds), -1);
 964
 965       if (pfds[0].revents != 0)
 966         {
 967           check_babysit_events (grandchild_pid, parent_pipe, pfds[0].revents);
 968         }
 969       else if (pfds[1].revents & _DBUS_POLLIN)
 970         {
 971           char b;
 972           read (sigchld_pipe[READ_END], &b, 1);
 973           /* do waitpid check */
 974           check_babysit_events (grandchild_pid, parent_pipe, 0);
 975         }
 976     }
 977
 978   exit (1);
 979 }
 980
 981 /**
 982  * Spawns a new process. The executable name and argv[0]
 983  * are the same, both are provided in argv[0]. The child_setup
 984  * function is passed the given user_data and is run in the child
 985  * just before calling exec().
 986  *
 987  * Also creates a "babysitter" which tracks the status of the
 988  * child process, advising the parent if the child exits.
 989  * If the spawn fails, no babysitter is created.
 990  * If sitter_p is #NULL, no babysitter is kept.
 991  *
 992  * @param sitter_p return location for babysitter or #NULL
 993  * @param argv the executable and arguments
 994  * @param child_setup function to call in child pre-exec()
 995  * @param user_data user data for setup function
 996  * @param error error object to be filled in if function fails
 997  * @returns #TRUE on success, #FALSE if error is filled in
 998  */
 999 dbus_bool_t
1000 _dbus_spawn_async_with_babysitter (DBusBabysitter          **sitter_p,
1001                                    char                    **argv,
1002                                    DBusSpawnChildSetupFunc   child_setup,
1003                                    void                     *user_data,
1004                                    DBusError                *error)
1005 {
1006   DBusBabysitter *sitter;
1007   int child_err_report_pipe[2] = { -1, -1 };
1008   int babysitter_pipe[2] = { -1, -1 };
1009   pid_t pid;
1010
1011   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1012
1013   *sitter_p = NULL;
1014   sitter = NULL;
1015
1016   sitter = _dbus_babysitter_new ();
1017   if (sitter == NULL)
1018     {
1019       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1020       return FALSE;
1021     }
1022
1023   sitter->executable = _dbus_strdup (argv[0]);
1024   if (sitter->executable == NULL)
1025     {
1026       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1027       goto cleanup_and_fail;
1028     }
1029
1030   if (!make_pipe (child_err_report_pipe, error))
1031     goto cleanup_and_fail;
1032
1033   _dbus_fd_set_close_on_exec (child_err_report_pipe[READ_END]);
1034
1035   if (!_dbus_full_duplex_pipe (&babysitter_pipe[0], &babysitter_pipe[1], TRUE, error))
1036     goto cleanup_and_fail;
1037
1038   _dbus_fd_set_close_on_exec (babysitter_pipe[0]);
1039   _dbus_fd_set_close_on_exec (babysitter_pipe[1]);
1040
1041   /* Setting up the babysitter is only useful in the parent,
1042    * but we don't want to run out of memory and fail
1043    * after we've already forked, since then we'd leak
1044    * child processes everywhere.
1045    */
1046   sitter->error_watch = _dbus_watch_new (child_err_report_pipe[READ_END],
1047                                          DBUS_WATCH_READABLE,
1048                                          TRUE, handle_watch, sitter, NULL);
1049   if (sitter->error_watch == NULL)
1050     {
1051       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1052       goto cleanup_and_fail;
1053     }
1054
1055   if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->error_watch))
1056     {
1057       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1058       goto cleanup_and_fail;
1059     }
1060
1061   sitter->sitter_watch = _dbus_watch_new (babysitter_pipe[0],
1062                                           DBUS_WATCH_READABLE,
1063                                           TRUE, handle_watch, sitter, NULL);
1064   if (sitter->sitter_watch == NULL)
1065     {
1066       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1067       goto cleanup_and_fail;
1068     }
1069
1070   if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->sitter_watch))
1071     {
1072       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1073       goto cleanup_and_fail;
1074     }
1075
1076   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1077
1078   pid = fork ();
1079
1080   if (pid < 0)
1081     {
1082       dbus_set_error (error,
1083                       DBUS_ERROR_SPAWN_FORK_FAILED,
1084                       "Failed to fork (%s)",
1085                       _dbus_strerror (errno));
1086       goto cleanup_and_fail;
1087     }
1088   else if (pid == 0)
1089     {
1090       /* Immediate child, this is the babysitter process. */
1091       int grandchild_pid;
1092
1093       /* Be sure we crash if the parent exits
1094        * and we write to the err_report_pipe
1095        */
1096       signal (SIGPIPE, SIG_DFL);
1097
1098       /* Close the parent's end of the pipes. */
1099       close_and_invalidate (&child_err_report_pipe[READ_END]);
1100       close_and_invalidate (&babysitter_pipe[0]);
1101
1102       /* Create the child that will exec () */
1103       grandchild_pid = fork ();
1104
1105       if (grandchild_pid < 0)
1106         {
1107           write_err_and_exit (babysitter_pipe[1],
1108                               CHILD_FORK_FAILED);
1109           _dbus_assert_not_reached ("Got to code after write_err_and_exit()");
1110         }
1111       else if (grandchild_pid == 0)
1112         {
1113           do_exec (child_err_report_pipe[WRITE_END],
1114                    argv,
1115                    child_setup, user_data);
1116           _dbus_assert_not_reached ("Got to code after exec() - should have exited on error");
1117         }
1118       else
1119         {
1120           babysit (grandchild_pid, babysitter_pipe[1]);
1121           _dbus_assert_not_reached ("Got to code after babysit()");
1122         }
1123     }
1124   else
1125     {
1126       /* Close the uncared-about ends of the pipes */
1127       close_and_invalidate (&child_err_report_pipe[WRITE_END]);
1128       close_and_invalidate (&babysitter_pipe[1]);
1129
1130       sitter->socket_to_babysitter = babysitter_pipe[0];
1131       babysitter_pipe[0] = -1;
1132
1133       sitter->error_pipe_from_child = child_err_report_pipe[READ_END];
1134       child_err_report_pipe[READ_END] = -1;
1135
1136       sitter->sitter_pid = pid;
1137
1138       if (sitter_p != NULL)
1139         *sitter_p = sitter;
1140       else
1141         _dbus_babysitter_unref (sitter);
1142
1143       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1144
1145       return TRUE;
1146     }
1147
1148  cleanup_and_fail:
1149
1150   _DBUS_ASSERT_ERROR_IS_SET (error);
1151
1152   close_and_invalidate (&child_err_report_pipe[READ_END]);
1153   close_and_invalidate (&child_err_report_pipe[WRITE_END]);
1154   close_and_invalidate (&babysitter_pipe[0]);
1155   close_and_invalidate (&babysitter_pipe[1]);
1156
1157   if (sitter != NULL)
1158     _dbus_babysitter_unref (sitter);
1159
1160   return FALSE;
1161 }
1162
1163 /** @} */
1164
1165 #ifdef DBUS_BUILD_TESTS
1166
1167 static void
1168 _dbus_babysitter_block_for_child_exit (DBusBabysitter *sitter)
1169 {
1170   while (LIVE_CHILDREN (sitter))
1171     babysitter_iteration (sitter, TRUE);
1172 }
1173
1174 static dbus_bool_t
1175 check_spawn_nonexistent (void *data)
1176 {
1177   char *argv[4] = { NULL, NULL, NULL, NULL };
1178   DBusBabysitter *sitter;
1179   DBusError error;
1180
1181   sitter = NULL;
1182
1183   dbus_error_init (&error);
1184
1185   /*** Test launching nonexistent binary */
1186
1187   argv[0] = "/this/does/not/exist/32542sdgafgafdg";
1188   if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1189                                          NULL, NULL,
1190                                          &error))
1191     {
1192       _dbus_babysitter_block_for_child_exit (sitter);
1193       _dbus_babysitter_set_child_exit_error (sitter, &error);
1194     }
1195
1196   if (sitter)
1197     _dbus_babysitter_unref (sitter);
1198
1199   if (!dbus_error_is_set (&error))
1200     {
1201       _dbus_warn ("Did not get an error launching nonexistent executable\n");
1202       return FALSE;
1203     }
1204
1205   if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1206         dbus_error_has_name (&error, DBUS_ERROR_SPAWN_EXEC_FAILED)))
1207     {
1208       _dbus_warn ("Not expecting error when launching nonexistent executable: %s: %s\n",
1209                   error.name, error.message);
1210       dbus_error_free (&error);
1211       return FALSE;
1212     }
1213
1214   dbus_error_free (&error);
1215
1216   return TRUE;
1217 }
1218
1219 static dbus_bool_t
1220 check_spawn_segfault (void *data)
1221 {
1222   char *argv[4] = { NULL, NULL, NULL, NULL };
1223   DBusBabysitter *sitter;
1224   DBusError error;
1225
1226   sitter = NULL;
1227
1228   dbus_error_init (&error);
1229
1230   /*** Test launching segfault binary */
1231
1232   argv[0] = TEST_SEGFAULT_BINARY;
1233   if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1234                                          NULL, NULL,
1235                                          &error))
1236     {
1237       _dbus_babysitter_block_for_child_exit (sitter);
1238       _dbus_babysitter_set_child_exit_error (sitter, &error);
1239     }
1240
1241   if (sitter)
1242     _dbus_babysitter_unref (sitter);
1243
1244   if (!dbus_error_is_set (&error))
1245     {
1246       _dbus_warn ("Did not get an error launching segfaulting binary\n");
1247       return FALSE;
1248     }
1249
1250   if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1251         dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_SIGNALED)))
1252     {
1253       _dbus_warn ("Not expecting error when launching segfaulting executable: %s: %s\n",
1254                   error.name, error.message);
1255       dbus_error_free (&error);
1256       return FALSE;
1257     }
1258
1259   dbus_error_free (&error);
1260
1261   return TRUE;
1262 }
1263
1264 static dbus_bool_t
1265 check_spawn_exit (void *data)
1266 {
1267   char *argv[4] = { NULL, NULL, NULL, NULL };
1268   DBusBabysitter *sitter;
1269   DBusError error;
1270
1271   sitter = NULL;
1272
1273   dbus_error_init (&error);
1274
1275   /*** Test launching exit failure binary */
1276
1277   argv[0] = TEST_EXIT_BINARY;
1278   if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1279                                          NULL, NULL,
1280                                          &error))
1281     {
1282       _dbus_babysitter_block_for_child_exit (sitter);
1283       _dbus_babysitter_set_child_exit_error (sitter, &error);
1284     }
1285
1286   if (sitter)
1287     _dbus_babysitter_unref (sitter);
1288
1289   if (!dbus_error_is_set (&error))
1290     {
1291       _dbus_warn ("Did not get an error launching binary that exited with failure code\n");
1292       return FALSE;
1293     }
1294
1295   if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1296         dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_EXITED)))
1297     {
1298       _dbus_warn ("Not expecting error when launching exiting executable: %s: %s\n",
1299                   error.name, error.message);
1300       dbus_error_free (&error);
1301       return FALSE;
1302     }
1303
1304   dbus_error_free (&error);
1305
1306   return TRUE;
1307 }
1308
1309 static dbus_bool_t
1310 check_spawn_and_kill (void *data)
1311 {
1312   char *argv[4] = { NULL, NULL, NULL, NULL };
1313   DBusBabysitter *sitter;
1314   DBusError error;
1315
1316   sitter = NULL;
1317
1318   dbus_error_init (&error);
1319
1320   /*** Test launching sleeping binary then killing it */
1321
1322   argv[0] = TEST_SLEEP_FOREVER_BINARY;
1323   if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1324                                          NULL, NULL,
1325                                          &error))
1326     {
1327       _dbus_babysitter_kill_child (sitter);
1328
1329       _dbus_babysitter_block_for_child_exit (sitter);
1330
1331       _dbus_babysitter_set_child_exit_error (sitter, &error);
1332     }
1333
1334   if (sitter)
1335     _dbus_babysitter_unref (sitter);
1336
1337   if (!dbus_error_is_set (&error))
1338     {
1339       _dbus_warn ("Did not get an error after killing spawned binary\n");
1340       return FALSE;
1341     }
1342
1343   if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1344         dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_SIGNALED)))
1345     {
1346       _dbus_warn ("Not expecting error when killing executable: %s: %s\n",
1347                   error.name, error.message);
1348       dbus_error_free (&error);
1349       return FALSE;
1350     }
1351
1352   dbus_error_free (&error);
1353
1354   return TRUE;
1355 }
1356
1357 dbus_bool_t
1358 _dbus_spawn_test (const char *test_data_dir)
1359 {
1360   if (!_dbus_test_oom_handling ("spawn_nonexistent",
1361                                 check_spawn_nonexistent,
1362                                 NULL))
1363     return FALSE;
1364
1365   if (!_dbus_test_oom_handling ("spawn_segfault",
1366                                 check_spawn_segfault,
1367                                 NULL))
1368     return FALSE;
1369
1370   if (!_dbus_test_oom_handling ("spawn_exit",
1371                                 check_spawn_exit,
1372                                 NULL))
1373     return FALSE;
1374
1375   if (!_dbus_test_oom_handling ("spawn_and_kill",
1376                                 check_spawn_and_kill,
1377                                 NULL))
1378     return FALSE;
1379
1380   return TRUE;
1381 }
1382 #endif