D-Bus  1.6.8
dbus-spawn.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 #include <config.h>
26 
27 #include "dbus-spawn.h"
28 #include "dbus-sysdeps-unix.h"
29 #include "dbus-internals.h"
30 #include "dbus-test.h"
31 #include "dbus-protocol.h"
32 
33 #include <unistd.h>
34 #include <fcntl.h>
35 #include <signal.h>
36 #include <sys/wait.h>
37 #include <stdlib.h>
38 #ifdef HAVE_ERRNO_H
39 #include <errno.h>
40 #endif
41 
42 extern char **environ;
43 
49 /*
50  * I'm pretty sure this whole spawn file could be made simpler,
51  * if you thought about it a bit.
52  */
53 
57 typedef enum
58 {
62 } ReadStatus;
63 
64 static ReadStatus
65 read_ints (int fd,
66  int *buf,
67  int n_ints_in_buf,
68  int *n_ints_read,
69  DBusError *error)
70 {
71  size_t bytes = 0;
72  ReadStatus retval;
73 
74  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
75 
76  retval = READ_STATUS_OK;
77 
78  while (TRUE)
79  {
80  ssize_t chunk;
81  size_t to_read;
82 
83  to_read = sizeof (int) * n_ints_in_buf - bytes;
84 
85  if (to_read == 0)
86  break;
87 
88  again:
89 
90  chunk = read (fd,
91  ((char*)buf) + bytes,
92  to_read);
93 
94  if (chunk < 0 && errno == EINTR)
95  goto again;
96 
97  if (chunk < 0)
98  {
99  dbus_set_error (error,
101  "Failed to read from child pipe (%s)",
102  _dbus_strerror (errno));
103 
104  retval = READ_STATUS_ERROR;
105  break;
106  }
107  else if (chunk == 0)
108  {
109  retval = READ_STATUS_EOF;
110  break; /* EOF */
111  }
112  else /* chunk > 0 */
113  bytes += chunk;
114  }
115 
116  *n_ints_read = (int)(bytes / sizeof(int));
117 
118  return retval;
119 }
120 
121 static ReadStatus
122 read_pid (int fd,
123  pid_t *buf,
124  DBusError *error)
125 {
126  size_t bytes = 0;
127  ReadStatus retval;
128 
129  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
130 
131  retval = READ_STATUS_OK;
132 
133  while (TRUE)
134  {
135  ssize_t chunk;
136  size_t to_read;
137 
138  to_read = sizeof (pid_t) - bytes;
139 
140  if (to_read == 0)
141  break;
142 
143  again:
144 
145  chunk = read (fd,
146  ((char*)buf) + bytes,
147  to_read);
148  if (chunk < 0 && errno == EINTR)
149  goto again;
150 
151  if (chunk < 0)
152  {
153  dbus_set_error (error,
155  "Failed to read from child pipe (%s)",
156  _dbus_strerror (errno));
157 
158  retval = READ_STATUS_ERROR;
159  break;
160  }
161  else if (chunk == 0)
162  {
163  retval = READ_STATUS_EOF;
164  break; /* EOF */
165  }
166  else /* chunk > 0 */
167  bytes += chunk;
168  }
169 
170  return retval;
171 }
172 
173 /* The implementation uses an intermediate child between the main process
174  * and the grandchild. The grandchild is our spawned process. The intermediate
175  * child is a babysitter process; it keeps track of when the grandchild
176  * exits/crashes, and reaps the grandchild.
177  */
178 
179 /* Messages from children to parents */
180 enum
181 {
182  CHILD_EXITED, /* This message is followed by the exit status int */
183  CHILD_FORK_FAILED, /* Followed by errno */
184  CHILD_EXEC_FAILED, /* Followed by errno */
185  CHILD_PID /* Followed by pid_t */
186 };
187 
191 struct DBusBabysitter
192 {
193  int refcount;
195  char *executable;
200  pid_t sitter_pid;
208  DBusBabysitterFinishedFunc finished_cb;
209  void *finished_data;
210 
211  int errnum;
212  int status;
213  unsigned int have_child_status : 1;
214  unsigned int have_fork_errnum : 1;
215  unsigned int have_exec_errnum : 1;
216 };
217 
218 static DBusBabysitter*
219 _dbus_babysitter_new (void)
220 {
221  DBusBabysitter *sitter;
222 
223  sitter = dbus_new0 (DBusBabysitter, 1);
224  if (sitter == NULL)
225  return NULL;
226 
227  sitter->refcount = 1;
228 
229  sitter->socket_to_babysitter = -1;
230  sitter->error_pipe_from_child = -1;
231 
232  sitter->sitter_pid = -1;
233  sitter->grandchild_pid = -1;
234 
235  sitter->watches = _dbus_watch_list_new ();
236  if (sitter->watches == NULL)
237  goto failed;
238 
239  return sitter;
240 
241  failed:
242  _dbus_babysitter_unref (sitter);
243  return NULL;
244 }
245 
254 {
255  _dbus_assert (sitter != NULL);
256  _dbus_assert (sitter->refcount > 0);
257 
258  sitter->refcount += 1;
259 
260  return sitter;
261 }
262 
263 static void close_socket_to_babysitter (DBusBabysitter *sitter);
264 static void close_error_pipe_from_child (DBusBabysitter *sitter);
265 
274 void
276 {
277  _dbus_assert (sitter != NULL);
278  _dbus_assert (sitter->refcount > 0);
279 
280  sitter->refcount -= 1;
281  if (sitter->refcount == 0)
282  {
283  /* If we haven't forked other babysitters
284  * since this babysitter and socket were
285  * created then this close will cause the
286  * babysitter to wake up from poll with
287  * a hangup and then the babysitter will
288  * quit itself.
289  */
290  close_socket_to_babysitter (sitter);
291 
292  close_error_pipe_from_child (sitter);
293 
294  if (sitter->sitter_pid > 0)
295  {
296  int status;
297  int ret;
298 
299  /* It's possible the babysitter died on its own above
300  * from the close, or was killed randomly
301  * by some other process, so first try to reap it
302  */
303  ret = waitpid (sitter->sitter_pid, &status, WNOHANG);
304 
305  /* If we couldn't reap the child then kill it, and
306  * try again
307  */
308  if (ret == 0)
309  kill (sitter->sitter_pid, SIGKILL);
310 
311  again:
312  if (ret == 0)
313  ret = waitpid (sitter->sitter_pid, &status, 0);
314 
315  if (ret < 0)
316  {
317  if (errno == EINTR)
318  goto again;
319  else if (errno == ECHILD)
320  _dbus_warn ("Babysitter process not available to be reaped; should not happen\n");
321  else
322  _dbus_warn ("Unexpected error %d in waitpid() for babysitter: %s\n",
323  errno, _dbus_strerror (errno));
324  }
325  else
326  {
327  _dbus_verbose ("Reaped %ld, waiting for babysitter %ld\n",
328  (long) ret, (long) sitter->sitter_pid);
329 
330  if (WIFEXITED (sitter->status))
331  _dbus_verbose ("Babysitter exited with status %d\n",
332  WEXITSTATUS (sitter->status));
333  else if (WIFSIGNALED (sitter->status))
334  _dbus_verbose ("Babysitter received signal %d\n",
335  WTERMSIG (sitter->status));
336  else
337  _dbus_verbose ("Babysitter exited abnormally\n");
338  }
339 
340  sitter->sitter_pid = -1;
341  }
342 
343  if (sitter->watches)
344  _dbus_watch_list_free (sitter->watches);
345 
346  dbus_free (sitter->executable);
347 
348  dbus_free (sitter);
349  }
350 }
351 
352 static ReadStatus
353 read_data (DBusBabysitter *sitter,
354  int fd)
355 {
356  int what;
357  int got;
358  DBusError error = DBUS_ERROR_INIT;
359  ReadStatus r;
360 
361  r = read_ints (fd, &what, 1, &got, &error);
362 
363  switch (r)
364  {
365  case READ_STATUS_ERROR:
366  _dbus_warn ("Failed to read data from fd %d: %s\n", fd, error.message);
367  dbus_error_free (&error);
368  return r;
369 
370  case READ_STATUS_EOF:
371  return r;
372 
373  case READ_STATUS_OK:
374  break;
375  }
376 
377  if (got == 1)
378  {
379  switch (what)
380  {
381  case CHILD_EXITED:
382  case CHILD_FORK_FAILED:
383  case CHILD_EXEC_FAILED:
384  {
385  int arg;
386 
387  r = read_ints (fd, &arg, 1, &got, &error);
388 
389  switch (r)
390  {
391  case READ_STATUS_ERROR:
392  _dbus_warn ("Failed to read arg from fd %d: %s\n", fd, error.message);
393  dbus_error_free (&error);
394  return r;
395  case READ_STATUS_EOF:
396  return r;
397  case READ_STATUS_OK:
398  break;
399  }
400 
401  if (got == 1)
402  {
403  if (what == CHILD_EXITED)
404  {
405  sitter->have_child_status = TRUE;
406  sitter->status = arg;
407  sitter->errnum = 0;
408  _dbus_verbose ("recorded child status exited = %d signaled = %d exitstatus = %d termsig = %d\n",
409  WIFEXITED (sitter->status), WIFSIGNALED (sitter->status),
410  WEXITSTATUS (sitter->status), WTERMSIG (sitter->status));
411  }
412  else if (what == CHILD_FORK_FAILED)
413  {
414  sitter->have_fork_errnum = TRUE;
415  sitter->errnum = arg;
416  _dbus_verbose ("recorded fork errnum %d\n", sitter->errnum);
417  }
418  else if (what == CHILD_EXEC_FAILED)
419  {
420  sitter->have_exec_errnum = TRUE;
421  sitter->errnum = arg;
422  _dbus_verbose ("recorded exec errnum %d\n", sitter->errnum);
423  }
424  }
425  }
426  break;
427  case CHILD_PID:
428  {
429  pid_t pid = -1;
430 
431  r = read_pid (fd, &pid, &error);
432 
433  switch (r)
434  {
435  case READ_STATUS_ERROR:
436  _dbus_warn ("Failed to read PID from fd %d: %s\n", fd, error.message);
437  dbus_error_free (&error);
438  return r;
439  case READ_STATUS_EOF:
440  return r;
441  case READ_STATUS_OK:
442  break;
443  }
444 
445  sitter->grandchild_pid = pid;
446 
447  _dbus_verbose ("recorded grandchild pid %d\n", sitter->grandchild_pid);
448  }
449  break;
450  default:
451  _dbus_warn ("Unknown message received from babysitter process\n");
452  break;
453  }
454  }
455 
456  return r;
457 }
458 
459 static void
460 close_socket_to_babysitter (DBusBabysitter *sitter)
461 {
462  _dbus_verbose ("Closing babysitter\n");
463 
464  if (sitter->sitter_watch != NULL)
465  {
466  _dbus_assert (sitter->watches != NULL);
470  sitter->sitter_watch = NULL;
471  }
472 
473  if (sitter->socket_to_babysitter >= 0)
474  {
476  sitter->socket_to_babysitter = -1;
477  }
478 }
479 
480 static void
481 close_error_pipe_from_child (DBusBabysitter *sitter)
482 {
483  _dbus_verbose ("Closing child error\n");
484 
485  if (sitter->error_watch != NULL)
486  {
487  _dbus_assert (sitter->watches != NULL);
490  _dbus_watch_unref (sitter->error_watch);
491  sitter->error_watch = NULL;
492  }
493 
494  if (sitter->error_pipe_from_child >= 0)
495  {
497  sitter->error_pipe_from_child = -1;
498  }
499 }
500 
501 static void
502 handle_babysitter_socket (DBusBabysitter *sitter,
503  int revents)
504 {
505  /* Even if we have POLLHUP, we want to keep reading
506  * data until POLLIN goes away; so this function only
507  * looks at HUP/ERR if no IN is set.
508  */
509  if (revents & _DBUS_POLLIN)
510  {
511  _dbus_verbose ("Reading data from babysitter\n");
512  if (read_data (sitter, sitter->socket_to_babysitter) != READ_STATUS_OK)
513  close_socket_to_babysitter (sitter);
514  }
515  else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
516  {
517  close_socket_to_babysitter (sitter);
518  }
519 }
520 
521 static void
522 handle_error_pipe (DBusBabysitter *sitter,
523  int revents)
524 {
525  if (revents & _DBUS_POLLIN)
526  {
527  _dbus_verbose ("Reading data from child error\n");
528  if (read_data (sitter, sitter->error_pipe_from_child) != READ_STATUS_OK)
529  close_error_pipe_from_child (sitter);
530  }
531  else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
532  {
533  close_error_pipe_from_child (sitter);
534  }
535 }
536 
537 /* returns whether there were any poll events handled */
538 static dbus_bool_t
539 babysitter_iteration (DBusBabysitter *sitter,
540  dbus_bool_t block)
541 {
542  DBusPollFD fds[2];
543  int i;
544  dbus_bool_t descriptors_ready;
545 
546  descriptors_ready = FALSE;
547 
548  i = 0;
549 
550  if (sitter->error_pipe_from_child >= 0)
551  {
552  fds[i].fd = sitter->error_pipe_from_child;
553  fds[i].events = _DBUS_POLLIN;
554  fds[i].revents = 0;
555  ++i;
556  }
557 
558  if (sitter->socket_to_babysitter >= 0)
559  {
560  fds[i].fd = sitter->socket_to_babysitter;
561  fds[i].events = _DBUS_POLLIN;
562  fds[i].revents = 0;
563  ++i;
564  }
565 
566  if (i > 0)
567  {
568  int ret;
569 
570  do
571  {
572  ret = _dbus_poll (fds, i, 0);
573  }
574  while (ret < 0 && errno == EINTR);
575 
576  if (ret == 0 && block)
577  {
578  do
579  {
580  ret = _dbus_poll (fds, i, -1);
581  }
582  while (ret < 0 && errno == EINTR);
583  }
584 
585  if (ret > 0)
586  {
587  descriptors_ready = TRUE;
588 
589  while (i > 0)
590  {
591  --i;
592  if (fds[i].fd == sitter->error_pipe_from_child)
593  handle_error_pipe (sitter, fds[i].revents);
594  else if (fds[i].fd == sitter->socket_to_babysitter)
595  handle_babysitter_socket (sitter, fds[i].revents);
596  }
597  }
598  }
599 
600  return descriptors_ready;
601 }
602 
607 #define LIVE_CHILDREN(sitter) ((sitter)->socket_to_babysitter >= 0 || (sitter)->error_pipe_from_child >= 0)
608 
615 void
617 {
618  /* be sure we have the PID of the child */
619  while (LIVE_CHILDREN (sitter) &&
620  sitter->grandchild_pid == -1)
621  babysitter_iteration (sitter, TRUE);
622 
623  _dbus_verbose ("Got child PID %ld for killing\n",
624  (long) sitter->grandchild_pid);
625 
626  if (sitter->grandchild_pid == -1)
627  return; /* child is already dead, or we're so hosed we'll never recover */
628 
629  kill (sitter->grandchild_pid, SIGKILL);
630 }
631 
639 {
640 
641  /* Be sure we're up-to-date */
642  while (LIVE_CHILDREN (sitter) &&
643  babysitter_iteration (sitter, FALSE))
644  ;
645 
646  /* We will have exited the babysitter when the child has exited */
647  return sitter->socket_to_babysitter < 0;
648 }
649 
664  int *status)
665 {
666  if (!_dbus_babysitter_get_child_exited (sitter))
667  _dbus_assert_not_reached ("Child has not exited");
668 
669  if (!sitter->have_child_status ||
670  !(WIFEXITED (sitter->status)))
671  return FALSE;
672 
673  *status = WEXITSTATUS (sitter->status);
674  return TRUE;
675 }
676 
686 void
688  DBusError *error)
689 {
690  if (!_dbus_babysitter_get_child_exited (sitter))
691  return;
692 
693  /* Note that if exec fails, we will also get a child status
694  * from the babysitter saying the child exited,
695  * so we need to give priority to the exec error
696  */
697  if (sitter->have_exec_errnum)
698  {
700  "Failed to execute program %s: %s",
701  sitter->executable, _dbus_strerror (sitter->errnum));
702  }
703  else if (sitter->have_fork_errnum)
704  {
706  "Failed to fork a new process %s: %s",
707  sitter->executable, _dbus_strerror (sitter->errnum));
708  }
709  else if (sitter->have_child_status)
710  {
711  if (WIFEXITED (sitter->status))
713  "Process %s exited with status %d",
714  sitter->executable, WEXITSTATUS (sitter->status));
715  else if (WIFSIGNALED (sitter->status))
717  "Process %s received signal %d",
718  sitter->executable, WTERMSIG (sitter->status));
719  else
721  "Process %s exited abnormally",
722  sitter->executable);
723  }
724  else
725  {
727  "Process %s exited, reason unknown",
728  sitter->executable);
729  }
730 }
731 
746  DBusAddWatchFunction add_function,
747  DBusRemoveWatchFunction remove_function,
748  DBusWatchToggledFunction toggled_function,
749  void *data,
750  DBusFreeFunction free_data_function)
751 {
752  return _dbus_watch_list_set_functions (sitter->watches,
753  add_function,
754  remove_function,
755  toggled_function,
756  data,
757  free_data_function);
758 }
759 
760 static dbus_bool_t
761 handle_watch (DBusWatch *watch,
762  unsigned int condition,
763  void *data)
764 {
765  DBusBabysitter *sitter = _dbus_babysitter_ref (data);
766  int revents;
767  int fd;
768 
769  revents = 0;
770  if (condition & DBUS_WATCH_READABLE)
771  revents |= _DBUS_POLLIN;
772  if (condition & DBUS_WATCH_ERROR)
773  revents |= _DBUS_POLLERR;
774  if (condition & DBUS_WATCH_HANGUP)
775  revents |= _DBUS_POLLHUP;
776 
777  fd = dbus_watch_get_socket (watch);
778 
779  if (fd == sitter->error_pipe_from_child)
780  handle_error_pipe (sitter, revents);
781  else if (fd == sitter->socket_to_babysitter)
782  handle_babysitter_socket (sitter, revents);
783 
784  while (LIVE_CHILDREN (sitter) &&
785  babysitter_iteration (sitter, FALSE))
786  ;
787 
788  /* fd.o #32992: if the handle_* methods closed their sockets, they previously
789  * didn't always remove the watches. Check that we don't regress. */
790  _dbus_assert (sitter->socket_to_babysitter != -1 || sitter->sitter_watch == NULL);
791  _dbus_assert (sitter->error_pipe_from_child != -1 || sitter->error_watch == NULL);
792 
793  if (_dbus_babysitter_get_child_exited (sitter) &&
794  sitter->finished_cb != NULL)
795  {
796  sitter->finished_cb (sitter, sitter->finished_data);
797  sitter->finished_cb = NULL;
798  }
799 
800  _dbus_babysitter_unref (sitter);
801  return TRUE;
802 }
803 
805 #define READ_END 0
806 
807 #define WRITE_END 1
808 
809 
810 /* Avoids a danger in threaded situations (calling close()
811  * on a file descriptor twice, and another thread has
812  * re-opened it since the first close)
813  */
814 static int
815 close_and_invalidate (int *fd)
816 {
817  int ret;
818 
819  if (*fd < 0)
820  return -1;
821  else
822  {
823  ret = _dbus_close_socket (*fd, NULL);
824  *fd = -1;
825  }
826 
827  return ret;
828 }
829 
830 static dbus_bool_t
831 make_pipe (int p[2],
832  DBusError *error)
833 {
834  int retval;
835 
836 #ifdef HAVE_PIPE2
837  dbus_bool_t cloexec_done;
838 
839  retval = pipe2 (p, O_CLOEXEC);
840  cloexec_done = retval >= 0;
841 
842  /* Check if kernel seems to be too old to know pipe2(). We assume
843  that if pipe2 is available, O_CLOEXEC is too. */
844  if (retval < 0 && errno == ENOSYS)
845 #endif
846  {
847  retval = pipe(p);
848  }
849 
850  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
851 
852  if (retval < 0)
853  {
854  dbus_set_error (error,
856  "Failed to create pipe for communicating with child process (%s)",
857  _dbus_strerror (errno));
858  return FALSE;
859  }
860 
861 #ifdef HAVE_PIPE2
862  if (!cloexec_done)
863 #endif
864  {
867  }
868 
869  return TRUE;
870 }
871 
872 static void
873 do_write (int fd, const void *buf, size_t count)
874 {
875  size_t bytes_written;
876  int ret;
877 
878  bytes_written = 0;
879 
880  again:
881 
882  ret = write (fd, ((const char*)buf) + bytes_written, count - bytes_written);
883 
884  if (ret < 0)
885  {
886  if (errno == EINTR)
887  goto again;
888  else
889  {
890  _dbus_warn ("Failed to write data to pipe!\n");
891  exit (1); /* give up, we suck */
892  }
893  }
894  else
895  bytes_written += ret;
896 
897  if (bytes_written < count)
898  goto again;
899 }
900 
901 static void
902 write_err_and_exit (int fd, int msg)
903 {
904  int en = errno;
905 
906  do_write (fd, &msg, sizeof (msg));
907  do_write (fd, &en, sizeof (en));
908 
909  exit (1);
910 }
911 
912 static void
913 write_pid (int fd, pid_t pid)
914 {
915  int msg = CHILD_PID;
916 
917  do_write (fd, &msg, sizeof (msg));
918  do_write (fd, &pid, sizeof (pid));
919 }
920 
921 static void
922 write_status_and_exit (int fd, int status)
923 {
924  int msg = CHILD_EXITED;
925 
926  do_write (fd, &msg, sizeof (msg));
927  do_write (fd, &status, sizeof (status));
928 
929  exit (0);
930 }
931 
932 static void
933 do_exec (int child_err_report_fd,
934  char **argv,
935  char **envp,
936  DBusSpawnChildSetupFunc child_setup,
937  void *user_data)
938 {
939 #ifdef DBUS_BUILD_TESTS
940  int i, max_open;
941 #endif
942 
943  _dbus_verbose_reset ();
944  _dbus_verbose ("Child process has PID " DBUS_PID_FORMAT "\n",
945  _dbus_getpid ());
946 
947  if (child_setup)
948  (* child_setup) (user_data);
949 
950 #ifdef DBUS_BUILD_TESTS
951  max_open = sysconf (_SC_OPEN_MAX);
952 
953  for (i = 3; i < max_open; i++)
954  {
955  int retval;
956 
957  if (i == child_err_report_fd)
958  continue;
959 
960  retval = fcntl (i, F_GETFD);
961 
962  if (retval != -1 && !(retval & FD_CLOEXEC))
963  _dbus_warn ("Fd %d did not have the close-on-exec flag set!\n", i);
964  }
965 #endif
966 
967  if (envp == NULL)
968  {
969  _dbus_assert (environ != NULL);
970 
971  envp = environ;
972  }
973 
974  execve (argv[0], argv, envp);
975 
976  /* Exec failed */
977  write_err_and_exit (child_err_report_fd,
978  CHILD_EXEC_FAILED);
979 }
980 
981 static void
982 check_babysit_events (pid_t grandchild_pid,
983  int parent_pipe,
984  int revents)
985 {
986  pid_t ret;
987  int status;
988 
989  do
990  {
991  ret = waitpid (grandchild_pid, &status, WNOHANG);
992  /* The man page says EINTR can't happen with WNOHANG,
993  * but there are reports of it (maybe only with valgrind?)
994  */
995  }
996  while (ret < 0 && errno == EINTR);
997 
998  if (ret == 0)
999  {
1000  _dbus_verbose ("no child exited\n");
1001 
1002  ; /* no child exited */
1003  }
1004  else if (ret < 0)
1005  {
1006  /* This isn't supposed to happen. */
1007  _dbus_warn ("unexpected waitpid() failure in check_babysit_events(): %s\n",
1008  _dbus_strerror (errno));
1009  exit (1);
1010  }
1011  else if (ret == grandchild_pid)
1012  {
1013  /* Child exited */
1014  _dbus_verbose ("reaped child pid %ld\n", (long) ret);
1015 
1016  write_status_and_exit (parent_pipe, status);
1017  }
1018  else
1019  {
1020  _dbus_warn ("waitpid() reaped pid %d that we've never heard of\n",
1021  (int) ret);
1022  exit (1);
1023  }
1024 
1025  if (revents & _DBUS_POLLIN)
1026  {
1027  _dbus_verbose ("babysitter got POLLIN from parent pipe\n");
1028  }
1029 
1030  if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))
1031  {
1032  /* Parent is gone, so we just exit */
1033  _dbus_verbose ("babysitter got POLLERR or POLLHUP from parent\n");
1034  exit (0);
1035  }
1036 }
1037 
1038 static int babysit_sigchld_pipe = -1;
1039 
1040 static void
1041 babysit_signal_handler (int signo)
1042 {
1043  char b = '\0';
1044  again:
1045  if (write (babysit_sigchld_pipe, &b, 1) <= 0)
1046  if (errno == EINTR)
1047  goto again;
1048 }
1049 
1050 static void
1051 babysit (pid_t grandchild_pid,
1052  int parent_pipe)
1053 {
1054  int sigchld_pipe[2];
1055 
1056  /* We don't exec, so we keep parent state, such as the pid that
1057  * _dbus_verbose() uses. Reset the pid here.
1058  */
1059  _dbus_verbose_reset ();
1060 
1061  /* I thought SIGCHLD would just wake up the poll, but
1062  * that didn't seem to work, so added this pipe.
1063  * Probably the pipe is more likely to work on busted
1064  * operating systems anyhow.
1065  */
1066  if (pipe (sigchld_pipe) < 0)
1067  {
1068  _dbus_warn ("Not enough file descriptors to create pipe in babysitter process\n");
1069  exit (1);
1070  }
1071 
1072  babysit_sigchld_pipe = sigchld_pipe[WRITE_END];
1073 
1074  _dbus_set_signal_handler (SIGCHLD, babysit_signal_handler);
1075 
1076  write_pid (parent_pipe, grandchild_pid);
1077 
1078  check_babysit_events (grandchild_pid, parent_pipe, 0);
1079 
1080  while (TRUE)
1081  {
1082  DBusPollFD pfds[2];
1083 
1084  pfds[0].fd = parent_pipe;
1085  pfds[0].events = _DBUS_POLLIN;
1086  pfds[0].revents = 0;
1087 
1088  pfds[1].fd = sigchld_pipe[READ_END];
1089  pfds[1].events = _DBUS_POLLIN;
1090  pfds[1].revents = 0;
1091 
1092  if (_dbus_poll (pfds, _DBUS_N_ELEMENTS (pfds), -1) < 0 && errno != EINTR)
1093  {
1094  _dbus_warn ("_dbus_poll() error: %s\n", strerror (errno));
1095  exit (1);
1096  }
1097 
1098  if (pfds[0].revents != 0)
1099  {
1100  check_babysit_events (grandchild_pid, parent_pipe, pfds[0].revents);
1101  }
1102  else if (pfds[1].revents & _DBUS_POLLIN)
1103  {
1104  char b;
1105  if (read (sigchld_pipe[READ_END], &b, 1) == -1)
1106  {
1107  /* ignore */
1108  }
1109  /* do waitpid check */
1110  check_babysit_events (grandchild_pid, parent_pipe, 0);
1111  }
1112  }
1113 
1114  exit (1);
1115 }
1116 
1138  char **argv,
1139  char **env,
1140  DBusSpawnChildSetupFunc child_setup,
1141  void *user_data,
1142  DBusError *error)
1143 {
1144  DBusBabysitter *sitter;
1145  int child_err_report_pipe[2] = { -1, -1 };
1146  int babysitter_pipe[2] = { -1, -1 };
1147  pid_t pid;
1148 
1149  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1150 
1151  if (sitter_p != NULL)
1152  *sitter_p = NULL;
1153 
1154  sitter = NULL;
1155 
1156  sitter = _dbus_babysitter_new ();
1157  if (sitter == NULL)
1158  {
1160  return FALSE;
1161  }
1162 
1163  sitter->executable = _dbus_strdup (argv[0]);
1164  if (sitter->executable == NULL)
1165  {
1167  goto cleanup_and_fail;
1168  }
1169 
1170  if (!make_pipe (child_err_report_pipe, error))
1171  goto cleanup_and_fail;
1172 
1173  if (!_dbus_full_duplex_pipe (&babysitter_pipe[0], &babysitter_pipe[1], TRUE, error))
1174  goto cleanup_and_fail;
1175 
1176  /* Setting up the babysitter is only useful in the parent,
1177  * but we don't want to run out of memory and fail
1178  * after we've already forked, since then we'd leak
1179  * child processes everywhere.
1180  */
1181  sitter->error_watch = _dbus_watch_new (child_err_report_pipe[READ_END],
1182  DBUS_WATCH_READABLE,
1183  TRUE, handle_watch, sitter, NULL);
1184  if (sitter->error_watch == NULL)
1185  {
1187  goto cleanup_and_fail;
1188  }
1189 
1190  if (!_dbus_watch_list_add_watch (sitter->watches, sitter->error_watch))
1191  {
1192  /* we need to free it early so the destructor won't try to remove it
1193  * without it having been added, which DBusLoop doesn't allow */
1195  _dbus_watch_unref (sitter->error_watch);
1196  sitter->error_watch = NULL;
1197 
1199  goto cleanup_and_fail;
1200  }
1201 
1202  sitter->sitter_watch = _dbus_watch_new (babysitter_pipe[0],
1203  DBUS_WATCH_READABLE,
1204  TRUE, handle_watch, sitter, NULL);
1205  if (sitter->sitter_watch == NULL)
1206  {
1208  goto cleanup_and_fail;
1209  }
1210 
1211  if (!_dbus_watch_list_add_watch (sitter->watches, sitter->sitter_watch))
1212  {
1213  /* we need to free it early so the destructor won't try to remove it
1214  * without it having been added, which DBusLoop doesn't allow */
1216  _dbus_watch_unref (sitter->sitter_watch);
1217  sitter->sitter_watch = NULL;
1218 
1220  goto cleanup_and_fail;
1221  }
1222 
1223  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1224 
1225  pid = fork ();
1226 
1227  if (pid < 0)
1228  {
1229  dbus_set_error (error,
1231  "Failed to fork (%s)",
1232  _dbus_strerror (errno));
1233  goto cleanup_and_fail;
1234  }
1235  else if (pid == 0)
1236  {
1237  /* Immediate child, this is the babysitter process. */
1238  int grandchild_pid;
1239 
1240  /* Be sure we crash if the parent exits
1241  * and we write to the err_report_pipe
1242  */
1243  signal (SIGPIPE, SIG_DFL);
1244 
1245  /* Close the parent's end of the pipes. */
1246  close_and_invalidate (&child_err_report_pipe[READ_END]);
1247  close_and_invalidate (&babysitter_pipe[0]);
1248 
1249  /* Create the child that will exec () */
1250  grandchild_pid = fork ();
1251 
1252  if (grandchild_pid < 0)
1253  {
1254  write_err_and_exit (babysitter_pipe[1],
1255  CHILD_FORK_FAILED);
1256  _dbus_assert_not_reached ("Got to code after write_err_and_exit()");
1257  }
1258  else if (grandchild_pid == 0)
1259  {
1260  /* Go back to ignoring SIGPIPE, since it's evil
1261  */
1262  signal (SIGPIPE, SIG_IGN);
1263 
1264  do_exec (child_err_report_pipe[WRITE_END],
1265  argv,
1266  env,
1267  child_setup, user_data);
1268  _dbus_assert_not_reached ("Got to code after exec() - should have exited on error");
1269  }
1270  else
1271  {
1272  babysit (grandchild_pid, babysitter_pipe[1]);
1273  _dbus_assert_not_reached ("Got to code after babysit()");
1274  }
1275  }
1276  else
1277  {
1278  /* Close the uncared-about ends of the pipes */
1279  close_and_invalidate (&child_err_report_pipe[WRITE_END]);
1280  close_and_invalidate (&babysitter_pipe[1]);
1281 
1282  sitter->socket_to_babysitter = babysitter_pipe[0];
1283  babysitter_pipe[0] = -1;
1284 
1285  sitter->error_pipe_from_child = child_err_report_pipe[READ_END];
1286  child_err_report_pipe[READ_END] = -1;
1287 
1288  sitter->sitter_pid = pid;
1289 
1290  if (sitter_p != NULL)
1291  *sitter_p = sitter;
1292  else
1293  _dbus_babysitter_unref (sitter);
1294 
1295  dbus_free_string_array (env);
1296 
1297  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1298 
1299  return TRUE;
1300  }
1301 
1302  cleanup_and_fail:
1303 
1304  _DBUS_ASSERT_ERROR_IS_SET (error);
1305 
1306  close_and_invalidate (&child_err_report_pipe[READ_END]);
1307  close_and_invalidate (&child_err_report_pipe[WRITE_END]);
1308  close_and_invalidate (&babysitter_pipe[0]);
1309  close_and_invalidate (&babysitter_pipe[1]);
1310 
1311  if (sitter != NULL)
1312  _dbus_babysitter_unref (sitter);
1313 
1314  return FALSE;
1315 }
1316 
1317 void
1318 _dbus_babysitter_set_result_function (DBusBabysitter *sitter,
1319  DBusBabysitterFinishedFunc finished,
1320  void *user_data)
1321 {
1322  sitter->finished_cb = finished;
1323  sitter->finished_data = user_data;
1324 }
1325 
1328 #ifdef DBUS_BUILD_TESTS
1329 
1330 static char *
1331 get_test_exec (const char *exe,
1332  DBusString *scratch_space)
1333 {
1334  const char *dbus_test_exec;
1335 
1336  dbus_test_exec = _dbus_getenv ("DBUS_TEST_EXEC");
1337 
1338  if (dbus_test_exec == NULL)
1339  dbus_test_exec = DBUS_TEST_EXEC;
1340 
1341  if (!_dbus_string_init (scratch_space))
1342  return NULL;
1343 
1344  if (!_dbus_string_append_printf (scratch_space, "%s/%s%s",
1345  dbus_test_exec, exe, DBUS_EXEEXT))
1346  {
1347  _dbus_string_free (scratch_space);
1348  return NULL;
1349  }
1350 
1351  return _dbus_string_get_data (scratch_space);
1352 }
1353 
1354 static void
1355 _dbus_babysitter_block_for_child_exit (DBusBabysitter *sitter)
1356 {
1357  while (LIVE_CHILDREN (sitter))
1358  babysitter_iteration (sitter, TRUE);
1359 }
1360 
1361 static dbus_bool_t
1362 check_spawn_nonexistent (void *data)
1363 {
1364  char *argv[4] = { NULL, NULL, NULL, NULL };
1365  DBusBabysitter *sitter = NULL;
1366  DBusError error = DBUS_ERROR_INIT;
1367 
1368  /*** Test launching nonexistent binary */
1369 
1370  argv[0] = "/this/does/not/exist/32542sdgafgafdg";
1371  if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1372  NULL, NULL, NULL,
1373  &error))
1374  {
1375  _dbus_babysitter_block_for_child_exit (sitter);
1376  _dbus_babysitter_set_child_exit_error (sitter, &error);
1377  }
1378 
1379  if (sitter)
1380  _dbus_babysitter_unref (sitter);
1381 
1382  if (!dbus_error_is_set (&error))
1383  {
1384  _dbus_warn ("Did not get an error launching nonexistent executable\n");
1385  return FALSE;
1386  }
1387 
1388  if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1390  {
1391  _dbus_warn ("Not expecting error when launching nonexistent executable: %s: %s\n",
1392  error.name, error.message);
1393  dbus_error_free (&error);
1394  return FALSE;
1395  }
1396 
1397  dbus_error_free (&error);
1398 
1399  return TRUE;
1400 }
1401 
1402 static dbus_bool_t
1403 check_spawn_segfault (void *data)
1404 {
1405  char *argv[4] = { NULL, NULL, NULL, NULL };
1406  DBusBabysitter *sitter = NULL;
1407  DBusError error = DBUS_ERROR_INIT;
1408  DBusString argv0;
1409 
1410  /*** Test launching segfault binary */
1411 
1412  argv[0] = get_test_exec ("test-segfault", &argv0);
1413 
1414  if (argv[0] == NULL)
1415  {
1416  /* OOM was simulated, never mind */
1417  return TRUE;
1418  }
1419 
1420  if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1421  NULL, NULL, NULL,
1422  &error))
1423  {
1424  _dbus_babysitter_block_for_child_exit (sitter);
1425  _dbus_babysitter_set_child_exit_error (sitter, &error);
1426  }
1427 
1428  _dbus_string_free (&argv0);
1429 
1430  if (sitter)
1431  _dbus_babysitter_unref (sitter);
1432 
1433  if (!dbus_error_is_set (&error))
1434  {
1435  _dbus_warn ("Did not get an error launching segfaulting binary\n");
1436  return FALSE;
1437  }
1438 
1439  if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1441  {
1442  _dbus_warn ("Not expecting error when launching segfaulting executable: %s: %s\n",
1443  error.name, error.message);
1444  dbus_error_free (&error);
1445  return FALSE;
1446  }
1447 
1448  dbus_error_free (&error);
1449 
1450  return TRUE;
1451 }
1452 
1453 static dbus_bool_t
1454 check_spawn_exit (void *data)
1455 {
1456  char *argv[4] = { NULL, NULL, NULL, NULL };
1457  DBusBabysitter *sitter = NULL;
1458  DBusError error = DBUS_ERROR_INIT;
1459  DBusString argv0;
1460 
1461  /*** Test launching exit failure binary */
1462 
1463  argv[0] = get_test_exec ("test-exit", &argv0);
1464 
1465  if (argv[0] == NULL)
1466  {
1467  /* OOM was simulated, never mind */
1468  return TRUE;
1469  }
1470 
1471  if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1472  NULL, NULL, NULL,
1473  &error))
1474  {
1475  _dbus_babysitter_block_for_child_exit (sitter);
1476  _dbus_babysitter_set_child_exit_error (sitter, &error);
1477  }
1478 
1479  _dbus_string_free (&argv0);
1480 
1481  if (sitter)
1482  _dbus_babysitter_unref (sitter);
1483 
1484  if (!dbus_error_is_set (&error))
1485  {
1486  _dbus_warn ("Did not get an error launching binary that exited with failure code\n");
1487  return FALSE;
1488  }
1489 
1490  if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1492  {
1493  _dbus_warn ("Not expecting error when launching exiting executable: %s: %s\n",
1494  error.name, error.message);
1495  dbus_error_free (&error);
1496  return FALSE;
1497  }
1498 
1499  dbus_error_free (&error);
1500 
1501  return TRUE;
1502 }
1503 
1504 static dbus_bool_t
1505 check_spawn_and_kill (void *data)
1506 {
1507  char *argv[4] = { NULL, NULL, NULL, NULL };
1508  DBusBabysitter *sitter = NULL;
1509  DBusError error = DBUS_ERROR_INIT;
1510  DBusString argv0;
1511 
1512  /*** Test launching sleeping binary then killing it */
1513 
1514  argv[0] = get_test_exec ("test-sleep-forever", &argv0);
1515 
1516  if (argv[0] == NULL)
1517  {
1518  /* OOM was simulated, never mind */
1519  return TRUE;
1520  }
1521 
1522  if (_dbus_spawn_async_with_babysitter (&sitter, argv,
1523  NULL, NULL, NULL,
1524  &error))
1525  {
1526  _dbus_babysitter_kill_child (sitter);
1527 
1528  _dbus_babysitter_block_for_child_exit (sitter);
1529 
1530  _dbus_babysitter_set_child_exit_error (sitter, &error);
1531  }
1532 
1533  _dbus_string_free (&argv0);
1534 
1535  if (sitter)
1536  _dbus_babysitter_unref (sitter);
1537 
1538  if (!dbus_error_is_set (&error))
1539  {
1540  _dbus_warn ("Did not get an error after killing spawned binary\n");
1541  return FALSE;
1542  }
1543 
1544  if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
1546  {
1547  _dbus_warn ("Not expecting error when killing executable: %s: %s\n",
1548  error.name, error.message);
1549  dbus_error_free (&error);
1550  return FALSE;
1551  }
1552 
1553  dbus_error_free (&error);
1554 
1555  return TRUE;
1556 }
1557 
1559 _dbus_spawn_test (const char *test_data_dir)
1560 {
1561  if (!_dbus_test_oom_handling ("spawn_nonexistent",
1562  check_spawn_nonexistent,
1563  NULL))
1564  return FALSE;
1565 
1566  if (!_dbus_test_oom_handling ("spawn_segfault",
1567  check_spawn_segfault,
1568  NULL))
1569  return FALSE;
1570 
1571  if (!_dbus_test_oom_handling ("spawn_exit",
1572  check_spawn_exit,
1573  NULL))
1574  return FALSE;
1575 
1576  if (!_dbus_test_oom_handling ("spawn_and_kill",
1577  check_spawn_and_kill,
1578  NULL))
1579  return FALSE;
1580 
1581  return TRUE;
1582 }
1583 #endif