tools/dbus-launch.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-launch.c  dbus-launch utility
   3  *
   4  * Copyright (C) 2003 Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23 #include <config.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <signal.h>
  28 #include <sys/wait.h>
  29 #include <errno.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <stdarg.h>
  34 #include <sys/select.h>
  35 #ifdef DBUS_BUILD_X11
  36 #include <X11/Xlib.h>
  37 #endif
  38
  39 #ifndef TRUE
  40 #define TRUE (1)
  41 #endif
  42
  43 #ifndef FALSE
  44 #define FALSE (0)
  45 #endif
  46
  47 #undef  MAX
  48 #define MAX(a, b)  (((a) > (b)) ? (a) : (b))
  49
  50 static void
  51 verbose (const char *format,
  52          ...)
  53 {
  54   va_list args;
  55   static int verbose = TRUE;
  56   static int verbose_initted = FALSE;
  57
  58   /* things are written a bit oddly here so that
  59    * in the non-verbose case we just have the one
  60    * conditional and return immediately.
  61    */
  62   if (!verbose)
  63     return;
  64
  65   if (!verbose_initted)
  66     {
  67       verbose = getenv ("DBUS_VERBOSE") != NULL;
  68       verbose_initted = TRUE;
  69       if (!verbose)
  70         return;
  71     }
  72
  73   fprintf (stderr, "%lu: ", (unsigned long) getpid ());
  74
  75   va_start (args, format);
  76   vfprintf (stderr, format, args);
  77   va_end (args);
  78 }
  79
  80 static void
  81 usage (int ecode)
  82 {
  83   fprintf (stderr, "dbus-launch [--version] [--help] [--sh-syntax] [--csh-syntax] [--auto-syntax] [--exit-with-session]\n");
  84   exit (ecode);
  85 }
  86
  87 static void
  88 version (void)
  89 {
  90   printf ("D-Bus Message Bus Launcher %s\n"
  91           "Copyright (C) 2003 Red Hat, Inc.\n"
  92           "This is free software; see the source for copying conditions.\n"
  93           "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
  94           VERSION);
  95   exit (0);
  96 }
  97
  98 static char *
  99 xstrdup (const char *str)
 100 {
 101   int len;
 102   char *copy;
 103
 104   if (str == NULL)
 105     return NULL;
 106
 107   len = strlen (str);
 108
 109   copy = malloc (len + 1);
 110   if (copy == NULL)
 111     return NULL;
 112
 113   memcpy (copy, str, len + 1);
 114
 115   return copy;
 116 }
 117
 118 typedef enum
 119 {
 120   READ_STATUS_OK,    /**< Read succeeded */
 121   READ_STATUS_ERROR, /**< Some kind of error */
 122   READ_STATUS_EOF    /**< EOF returned */
 123 } ReadStatus;
 124
 125 static ReadStatus
 126 read_line (int        fd,
 127            char      *buf,
 128            size_t     maxlen)
 129 {
 130   size_t bytes = 0;
 131   ReadStatus retval;
 132
 133   memset (buf, '\0', maxlen);
 134   maxlen -= 1; /* ensure nul term */
 135
 136   retval = READ_STATUS_OK;
 137
 138   while (TRUE)
 139     {
 140       ssize_t chunk;
 141       size_t to_read;
 142
 143     again:
 144       to_read = maxlen - bytes;
 145
 146       if (to_read == 0)
 147         break;
 148
 149       chunk = read (fd,
 150                     buf + bytes,
 151                     to_read);
 152       if (chunk < 0 && errno == EINTR)
 153         goto again;
 154
 155       if (chunk < 0)
 156         {
 157           retval = READ_STATUS_ERROR;
 158           break;
 159         }
 160       else if (chunk == 0)
 161         {
 162           retval = READ_STATUS_EOF;
 163           break; /* EOF */
 164         }
 165       else /* chunk > 0 */
 166         bytes += chunk;
 167     }
 168
 169   if (retval == READ_STATUS_EOF &&
 170       bytes > 0)
 171     retval = READ_STATUS_OK;
 172
 173   /* whack newline */
 174   if (retval != READ_STATUS_ERROR &&
 175       bytes > 0 &&
 176       buf[bytes-1] == '\n')
 177     buf[bytes-1] = '\0';
 178
 179   return retval;
 180 }
 181
 182 static ReadStatus
 183 read_pid (int        fd,
 184           pid_t     *buf)
 185 {
 186   size_t bytes = 0;
 187   ReadStatus retval;
 188
 189   retval = READ_STATUS_OK;
 190
 191   while (TRUE)
 192     {
 193       ssize_t chunk;
 194       size_t to_read;
 195
 196     again:
 197       to_read = sizeof (pid_t) - bytes;
 198
 199       if (to_read == 0)
 200         break;
 201
 202       chunk = read (fd,
 203                     ((char*)buf) + bytes,
 204                     to_read);
 205       if (chunk < 0 && errno == EINTR)
 206         goto again;
 207
 208       if (chunk < 0)
 209         {
 210           retval = READ_STATUS_ERROR;
 211           break;
 212         }
 213       else if (chunk == 0)
 214         {
 215           retval = READ_STATUS_EOF;
 216           break; /* EOF */
 217         }
 218       else /* chunk > 0 */
 219         bytes += chunk;
 220     }
 221
 222   return retval;
 223 }
 224
 225 static void
 226 do_write (int fd, const void *buf, size_t count)
 227 {
 228   size_t bytes_written;
 229   int ret;
 230
 231   bytes_written = 0;
 232
 233  again:
 234
 235   ret = write (fd, ((const char*)buf) + bytes_written, count - bytes_written);
 236
 237   if (ret < 0)
 238     {
 239       if (errno == EINTR)
 240         goto again;
 241       else
 242         {
 243           fprintf (stderr, "Failed to write data to pipe! %s\n",
 244                    strerror (errno));
 245           exit (1); /* give up, we suck */
 246         }
 247     }
 248   else
 249     bytes_written += ret;
 250
 251   if (bytes_written < count)
 252     goto again;
 253 }
 254
 255 static void
 256 write_pid (int   fd,
 257            pid_t pid)
 258 {
 259   do_write (fd, &pid, sizeof (pid));
 260 }
 261
 262 static int
 263 do_waitpid (pid_t pid)
 264 {
 265   int ret;
 266
 267  again:
 268   ret = waitpid (pid, NULL, 0);
 269
 270   if (ret < 0 &&
 271       errno == EINTR)
 272     goto again;
 273
 274   return ret;
 275 }
 276
 277 static pid_t bus_pid_to_kill = -1;
 278
 279 static void
 280 kill_bus_and_exit (void)
 281 {
 282   verbose ("Killing message bus and exiting babysitter\n");
 283
 284   /* in case these point to any NFS mounts, get rid of them immediately */
 285   close (0);
 286   close (1);
 287   close (2);
 288
 289   kill (bus_pid_to_kill, SIGTERM);
 290   sleep (3);
 291   kill (bus_pid_to_kill, SIGKILL);
 292
 293   exit (0);
 294 }
 295
 296 #ifdef DBUS_BUILD_X11
 297 static int
 298 x_io_error_handler (Display *xdisplay)
 299 {
 300   verbose ("X IO error\n");
 301   kill_bus_and_exit ();
 302   return 0;
 303 }
 304 #endif
 305
 306 static int got_sighup = FALSE;
 307
 308 static void
 309 signal_handler (int sig)
 310 {
 311   switch (sig)
 312     {
 313     case SIGHUP:
 314     case SIGTERM:
 315       got_sighup = TRUE;
 316       break;
 317     }
 318 }
 319
 320 static void
 321 kill_bus_when_session_ends (void)
 322 {
 323   int tty_fd;
 324   int x_fd;
 325   fd_set read_set;
 326   fd_set err_set;
 327   struct sigaction act;
 328   sigset_t empty_mask;
 329 #ifdef DBUS_BUILD_X11
 330   Display *xdisplay;
 331 #endif
 332
 333   /* install SIGHUP handler */
 334   got_sighup = FALSE;
 335   sigemptyset (&empty_mask);
 336   act.sa_handler = signal_handler;
 337   act.sa_mask    = empty_mask;
 338   act.sa_flags   = 0;
 339   sigaction (SIGHUP,  &act, NULL);
 340   sigaction (SIGTERM,  &act, NULL);
 341
 342 #ifdef DBUS_BUILD_X11
 343   xdisplay = XOpenDisplay (NULL);
 344   if (xdisplay != NULL)
 345     {
 346       verbose ("Successfully opened X display\n");
 347       x_fd = ConnectionNumber (xdisplay);
 348       XSetIOErrorHandler (x_io_error_handler);
 349     }
 350   else
 351     x_fd = -1;
 352 #else
 353   verbose ("Compiled without X11 support\n");
 354   x_fd = -1;
 355 #endif
 356
 357   if (isatty (0))
 358     tty_fd = 0;
 359   else
 360     tty_fd = -1;
 361
 362   if (tty_fd >= 0)
 363     verbose ("stdin isatty(), monitoring it\n");
 364   else
 365     verbose ("stdin was not a TTY, not monitoring it\n");
 366
 367   if (tty_fd < 0 && x_fd < 0)
 368     {
 369       fprintf (stderr, "No terminal on standard input and no X display; cannot attach message bus to session lifetime\n");
 370       exit (1);
 371     }
 372
 373   while (TRUE)
 374     {
 375       FD_ZERO (&read_set);
 376       FD_ZERO (&err_set);
 377
 378       if (tty_fd >= 0)
 379         {
 380           FD_SET (tty_fd, &read_set);
 381           FD_SET (tty_fd, &err_set);
 382         }
 383
 384       if (x_fd >= 0)
 385         {
 386           FD_SET (x_fd, &read_set);
 387           FD_SET (x_fd, &err_set);
 388         }
 389
 390       select (MAX (tty_fd, x_fd) + 1,
 391               &read_set, NULL, &err_set, NULL);
 392
 393       if (got_sighup)
 394         {
 395           verbose ("Got SIGHUP, exiting\n");
 396           kill_bus_and_exit ();
 397         }
 398
 399 #ifdef DBUS_BUILD_X11
 400       /* Dump events on the floor, and let
 401        * IO error handler run if we lose
 402        * the X connection
 403        */
 404       if (x_fd >= 0)
 405         verbose ("X fd condition reading = %d error = %d\n",
 406                  FD_ISSET (x_fd, &read_set),
 407                  FD_ISSET (x_fd, &err_set));
 408
 409       if (xdisplay != NULL)
 410         {
 411           while (XPending (xdisplay))
 412             {
 413               XEvent ignored;
 414               XNextEvent (xdisplay, &ignored);
 415             }
 416         }
 417 #endif
 418
 419       if (tty_fd >= 0)
 420         {
 421           if (FD_ISSET (tty_fd, &read_set))
 422             {
 423               int bytes_read;
 424               char discard[512];
 425
 426               verbose ("TTY ready for reading\n");
 427
 428               bytes_read = read (tty_fd, discard, sizeof (discard));
 429
 430               verbose ("Read %d bytes from TTY errno = %d\n",
 431                        bytes_read, errno);
 432
 433               if (bytes_read == 0)
 434                 kill_bus_and_exit (); /* EOF */
 435               else if (bytes_read < 0 && errno != EINTR)
 436                 {
 437                   /* This shouldn't happen I don't think; to avoid
 438                    * spinning on the fd forever we exit.
 439                    */
 440                   fprintf (stderr, "dbus-launch: error reading from stdin: %s\n",
 441                            strerror (errno));
 442                   kill_bus_and_exit ();
 443                 }
 444             }
 445           else if (FD_ISSET (tty_fd, &err_set))
 446             {
 447               verbose ("TTY has error condition\n");
 448
 449               kill_bus_and_exit ();
 450             }
 451         }
 452     }
 453 }
 454
 455 static void
 456 babysit (int   exit_with_session,
 457          pid_t child_pid,
 458          int   read_bus_pid_fd,  /* read pid from here */
 459          int   write_bus_pid_fd) /* forward pid to here */
 460 {
 461   int ret;
 462 #define MAX_PID_LEN 64
 463   char buf[MAX_PID_LEN];
 464   long val;
 465   char *end;
 466   int dev_null_fd;
 467   const char *s;
 468
 469   verbose ("babysitting, exit_with_session = %d, child_pid = %ld, read_bus_pid_fd = %d, write_bus_pid_fd = %d\n",
 470            exit_with_session, (long) child_pid, read_bus_pid_fd, write_bus_pid_fd);
 471
 472   /* We chdir ("/") since we are persistent and daemon-like, and fork
 473    * again so dbus-launch can reap the parent.  However, we don't
 474    * setsid() or close fd 0 because the idea is to remain attached
 475    * to the tty and the X server in order to kill the message bus
 476    * when the session ends.
 477    */
 478
 479   if (chdir ("/") < 0)
 480     {
 481       fprintf (stderr, "Could not change to root directory: %s\n",
 482                strerror (errno));
 483       exit (1);
 484     }
 485
 486   /* Close stdout/stderr so we don't block an "eval" or otherwise
 487    * lock up. stdout is still chaining through to dbus-launch
 488    * and in turn to the parent shell.
 489    */
 490   dev_null_fd = open ("/dev/null", O_RDWR);
 491   if (dev_null_fd >= 0)
 492     {
 493       if (!exit_with_session)
 494         dup2 (dev_null_fd, 0);
 495       dup2 (dev_null_fd, 1);
 496       s = getenv ("DBUS_DEBUG_OUTPUT");
 497       if (s == NULL || *s == '\0')
 498         dup2 (dev_null_fd, 2);
 499     }
 500   else
 501     {
 502       fprintf (stderr, "Failed to open /dev/null: %s\n",
 503                strerror (errno));
 504       /* continue, why not */
 505     }
 506
 507   ret = fork ();
 508
 509   if (ret < 0)
 510     {
 511       fprintf (stderr, "fork() failed in babysitter: %s\n",
 512                strerror (errno));
 513       exit (1);
 514     }
 515
 516   if (ret > 0)
 517     {
 518       /* Parent reaps pre-fork part of bus daemon, then exits and is
 519        * reaped so the babysitter isn't a zombie
 520        */
 521
 522       verbose ("=== Babysitter's intermediate parent continues again\n");
 523
 524       if (do_waitpid (child_pid) < 0)
 525         {
 526           /* shouldn't happen */
 527           fprintf (stderr, "Failed waitpid() waiting for bus daemon's parent\n");
 528           exit (1);
 529         }
 530
 531       verbose ("Babysitter's intermediate parent exiting\n");
 532
 533       exit (0);
 534     }
 535
 536   /* Child continues */
 537   verbose ("=== Babysitter process created\n");
 538
 539   verbose ("Reading PID from daemon\n");
 540   /* Now read data */
 541   switch (read_line (read_bus_pid_fd, buf, MAX_PID_LEN))
 542     {
 543     case READ_STATUS_OK:
 544       break;
 545     case READ_STATUS_EOF:
 546       fprintf (stderr, "EOF reading PID from bus daemon\n");
 547       exit (1);
 548       break;
 549     case READ_STATUS_ERROR:
 550       fprintf (stderr, "Error reading PID from bus daemon: %s\n",
 551                strerror (errno));
 552       exit (1);
 553       break;
 554     }
 555
 556   end = NULL;
 557   val = strtol (buf, &end, 0);
 558   if (buf == end || end == NULL)
 559     {
 560       fprintf (stderr, "Failed to parse bus PID \"%s\": %s\n",
 561                buf, strerror (errno));
 562       exit (1);
 563     }
 564
 565   bus_pid_to_kill = val;
 566
 567   verbose ("Got PID %ld from daemon\n",
 568            (long) bus_pid_to_kill);
 569
 570   /* Write data to launcher */
 571   write_pid (write_bus_pid_fd, bus_pid_to_kill);
 572   close (write_bus_pid_fd);
 573
 574   if (exit_with_session)
 575     {
 576       /* Bus is now started and launcher has needed info;
 577        * we connect to X display and tty and wait to
 578        * kill bus if requested.
 579        */
 580
 581       kill_bus_when_session_ends ();
 582     }
 583
 584   verbose ("Babysitter exiting\n");
 585
 586   exit (0);
 587 }
 588
 589 #define READ_END  0
 590 #define WRITE_END 1
 591
 592 int
 593 main (int argc, char **argv)
 594 {
 595   const char *prev_arg;
 596   const char *shname;
 597   const char *runprog = NULL;
 598   int remaining_args = 0;
 599   int exit_with_session;
 600   int c_shell_syntax = FALSE;
 601   int bourne_shell_syntax = FALSE;
 602   int auto_shell_syntax = FALSE;
 603   int i;
 604   int ret;
 605   int bus_pid_to_launcher_pipe[2];
 606   int bus_pid_to_babysitter_pipe[2];
 607   int bus_address_to_launcher_pipe[2];
 608   char *config_file;
 609
 610   exit_with_session = FALSE;
 611   config_file = NULL;
 612
 613   prev_arg = NULL;
 614   i = 1;
 615   while (i < argc)
 616     {
 617       const char *arg = argv[i];
 618
 619       if (strcmp (arg, "--help") == 0 ||
 620           strcmp (arg, "-h") == 0 ||
 621           strcmp (arg, "-?") == 0)
 622         usage (0);
 623       else if (strcmp (arg, "--auto-syntax") == 0)
 624         auto_shell_syntax = TRUE;
 625       else if (strcmp (arg, "-c") == 0 ||
 626                strcmp (arg, "--csh-syntax") == 0)
 627         c_shell_syntax = TRUE;
 628       else if (strcmp (arg, "-s") == 0 ||
 629                strcmp (arg, "--sh-syntax") == 0)
 630         bourne_shell_syntax = TRUE;
 631       else if (strcmp (arg, "--version") == 0)
 632         version ();
 633       else if (strcmp (arg, "--exit-with-session") == 0)
 634         exit_with_session = TRUE;
 635       else if (strstr (arg, "--config-file=") == arg)
 636         {
 637           const char *file;
 638
 639           if (config_file != NULL)
 640             {
 641               fprintf (stderr, "--config-file given twice\n");
 642               exit (1);
 643             }
 644
 645           file = strchr (arg, '=');
 646           ++file;
 647
 648           config_file = xstrdup (file);
 649         }
 650       else if (prev_arg &&
 651                strcmp (prev_arg, "--config-file") == 0)
 652         {
 653           if (config_file != NULL)
 654             {
 655               fprintf (stderr, "--config-file given twice\n");
 656               exit (1);
 657             }
 658
 659           config_file = xstrdup (arg);
 660         }
 661       else if (strcmp (arg, "--config-file") == 0)
 662         ; /* wait for next arg */
 663       else
 664         {
 665           runprog = arg;
 666           remaining_args = i+1;
 667           break;
 668         }
 669
 670       prev_arg = arg;
 671
 672       ++i;
 673     }
 674
 675   if (exit_with_session)
 676     verbose ("--exit-with-session enabled\n");
 677
 678   if (auto_shell_syntax)
 679     {
 680       if ((shname = getenv ("SHELL")) != NULL)
 681        {
 682          if (!strncmp (shname + strlen (shname) - 3, "csh", 3))
 683            c_shell_syntax = TRUE;
 684          else
 685            bourne_shell_syntax = TRUE;
 686        }
 687       else
 688        bourne_shell_syntax = TRUE;
 689     }
 690
 691   if (pipe (bus_pid_to_launcher_pipe) < 0 ||
 692       pipe (bus_address_to_launcher_pipe) < 0)
 693     {
 694       fprintf (stderr,
 695                "Failed to create pipe: %s\n",
 696                strerror (errno));
 697       exit (1);
 698     }
 699
 700   bus_pid_to_babysitter_pipe[READ_END] = -1;
 701   bus_pid_to_babysitter_pipe[WRITE_END] = -1;
 702
 703   ret = fork ();
 704   if (ret < 0)
 705     {
 706       fprintf (stderr, "Failed to fork: %s\n",
 707                strerror (errno));
 708       exit (1);
 709     }
 710
 711   if (ret == 0)
 712     {
 713       /* Child */
 714 #define MAX_FD_LEN 64
 715       char write_pid_fd_as_string[MAX_FD_LEN];
 716       char write_address_fd_as_string[MAX_FD_LEN];
 717
 718       verbose ("=== Babysitter's intermediate parent created\n");
 719
 720       /* Fork once more to create babysitter */
 721
 722       if (pipe (bus_pid_to_babysitter_pipe) < 0)
 723         {
 724           fprintf (stderr,
 725                    "Failed to create pipe: %s\n",
 726                    strerror (errno));
 727           exit (1);
 728         }
 729
 730       ret = fork ();
 731       if (ret < 0)
 732         {
 733           fprintf (stderr, "Failed to fork: %s\n",
 734                    strerror (errno));
 735           exit (1);
 736         }
 737
 738       if (ret > 0)
 739         {
 740           /* In babysitter */
 741           verbose ("=== Babysitter's intermediate parent continues\n");
 742
 743           close (bus_pid_to_launcher_pipe[READ_END]);
 744           close (bus_address_to_launcher_pipe[READ_END]);
 745           close (bus_address_to_launcher_pipe[WRITE_END]);
 746           close (bus_pid_to_babysitter_pipe[WRITE_END]);
 747
 748           /* babysit() will fork *again*
 749            * and will also reap the pre-forked bus
 750            * daemon
 751            */
 752           babysit (exit_with_session, ret,
 753                    bus_pid_to_babysitter_pipe[READ_END],
 754                    bus_pid_to_launcher_pipe[WRITE_END]);
 755           exit (0);
 756         }
 757
 758       verbose ("=== Bus exec process created\n");
 759
 760       /* Now we are the bus process (well, almost;
 761        * dbus-daemon itself forks again)
 762        */
 763       close (bus_pid_to_launcher_pipe[READ_END]);
 764       close (bus_address_to_launcher_pipe[READ_END]);
 765       close (bus_pid_to_babysitter_pipe[READ_END]);
 766       close (bus_pid_to_launcher_pipe[WRITE_END]);
 767
 768       sprintf (write_pid_fd_as_string,
 769                "%d", bus_pid_to_babysitter_pipe[WRITE_END]);
 770
 771       sprintf (write_address_fd_as_string,
 772                "%d", bus_address_to_launcher_pipe[WRITE_END]);
 773
 774       verbose ("Calling exec()\n");
 775
 776       execl (DBUS_DAEMONDIR"/dbus-daemon",
 777              DBUS_DAEMONDIR"/dbus-daemon",
 778              "--fork",
 779              "--print-pid", write_pid_fd_as_string,
 780              "--print-address", write_address_fd_as_string,
 781              config_file ? "--config-file" : "--session",
 782              config_file, /* has to be last in this varargs list */
 783              NULL);
 784
 785       fprintf (stderr,
 786                "Failed to execute message bus daemon %s: %s.  Will try again without full path.\n",
 787                DBUS_DAEMONDIR"/dbus-daemon", strerror (errno));
 788
 789       /*
 790        * If it failed, try running without full PATH.  Note this is needed
 791        * because the build process builds the run-with-tmp-session-bus.conf
 792        * file and the dbus-daemon will not be in the install location during
 793        * build time.
 794        */
 795       execlp ("dbus-daemon",
 796               "dbus-daemon",
 797               "--fork",
 798               "--print-pid", write_pid_fd_as_string,
 799               "--print-address", write_address_fd_as_string,
 800               config_file ? "--config-file" : "--session",
 801               config_file, /* has to be last in this varargs list */
 802               NULL);
 803
 804       fprintf (stderr,
 805                "Failed to execute message bus daemon: %s\n",
 806                strerror (errno));
 807       exit (1);
 808     }
 809   else
 810     {
 811       /* Parent */
 812 #define MAX_ADDR_LEN 512
 813       pid_t bus_pid;
 814       char bus_address[MAX_ADDR_LEN];
 815
 816       verbose ("=== Parent dbus-launch continues\n");
 817
 818       close (bus_pid_to_launcher_pipe[WRITE_END]);
 819       close (bus_address_to_launcher_pipe[WRITE_END]);
 820
 821       verbose ("Waiting for babysitter's intermediate parent\n");
 822
 823       /* Immediately reap parent of babysitter
 824        * (which was created just for us to reap)
 825        */
 826       if (do_waitpid (ret) < 0)
 827         {
 828           fprintf (stderr, "Failed to waitpid() for babysitter intermediate process: %s\n",
 829                    strerror (errno));
 830           exit (1);
 831         }
 832
 833       verbose ("Reading address from bus\n");
 834
 835       /* Read the pipe data, print, and exit */
 836       switch (read_line (bus_address_to_launcher_pipe[READ_END],
 837                          bus_address, MAX_ADDR_LEN))
 838         {
 839         case READ_STATUS_OK:
 840           break;
 841         case READ_STATUS_EOF:
 842           fprintf (stderr, "EOF in dbus-launch reading address from bus daemon\n");
 843           exit (1);
 844           break;
 845         case READ_STATUS_ERROR:
 846           fprintf (stderr, "Error in dbus-launch reading address from bus daemon: %s\n",
 847                    strerror (errno));
 848           exit (1);
 849           break;
 850         }
 851
 852       close (bus_address_to_launcher_pipe[READ_END]);
 853
 854       verbose ("Reading PID from babysitter\n");
 855
 856       switch (read_pid (bus_pid_to_launcher_pipe[READ_END], &bus_pid))
 857         {
 858         case READ_STATUS_OK:
 859           break;
 860         case READ_STATUS_EOF:
 861           fprintf (stderr, "EOF in dbus-launch reading address from bus daemon\n");
 862           exit (1);
 863           break;
 864         case READ_STATUS_ERROR:
 865           fprintf (stderr, "Error in dbus-launch reading address from bus daemon: %s\n",
 866                    strerror (errno));
 867           exit (1);
 868           break;
 869         }
 870
 871       close (bus_pid_to_launcher_pipe[READ_END]);
 872
 873       if (runprog)
 874         {
 875           char *envvar;
 876           char **args;
 877
 878           envvar = malloc (strlen ("DBUS_SESSION_BUS_ADDRESS=") + strlen (bus_address) + 1);
 879           args = malloc (sizeof (char *) * ((argc-remaining_args)+2));
 880
 881           if (envvar == NULL || args == NULL)
 882             goto oom;
 883
 884           args[0] = xstrdup (runprog);
 885           if (!args[0])
 886             goto oom;
 887           for (i = 1; i <= (argc-remaining_args); i++)
 888             {
 889               size_t len = strlen (argv[remaining_args+i-1])+1;
 890               args[i] = malloc (len);
 891               if (!args[i])
 892                 goto oom;
 893               strncpy (args[i], argv[remaining_args+i-1], len);
 894             }
 895           args[i] = NULL;
 896
 897           strcpy (envvar, "DBUS_SESSION_BUS_ADDRESS=");
 898           strcat (envvar, bus_address);
 899           putenv (envvar);
 900
 901           execvp (runprog, args);
 902           fprintf (stderr, "Couldn't exec %s: %s\n", runprog, strerror (errno));
 903           exit (1);
 904         }
 905       else
 906         {
 907           if (c_shell_syntax)
 908             printf ("setenv DBUS_SESSION_BUS_ADDRESS '%s';\n", bus_address);
 909           else
 910             {
 911               printf ("DBUS_SESSION_BUS_ADDRESS='%s';\n", bus_address);
 912               if (bourne_shell_syntax)
 913                 printf ("export DBUS_SESSION_BUS_ADDRESS;\n");
 914             }
 915           if (c_shell_syntax)
 916             printf ("set DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
 917           else
 918             printf ("DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
 919         }
 920
 921       verbose ("dbus-launch exiting\n");
 922
 923       fflush (stdout);
 924       fflush (stderr);
 925       close (1);
 926       close (2);
 927
 928       exit (0);
 929     }
 930
 931   return 0;
 932  oom:
 933   fprintf (stderr, "Out of memory!");
 934   exit (1);
 935 }