tools/dbus-launch.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-launch.c  dbus-launch utility
   3  *
   4  * Copyright (C) 2003, 2006 Red Hat, Inc.
   5  * Copyright (C) 2006 Thiago Macieira <thiago@kde.org>
   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 #include "dbus-launch.h"
  27 #include <stdlib.h>
  28 #include <ctype.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <signal.h>
  32 #include <sys/wait.h>
  33 #include <errno.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <signal.h>
  37 #include <stdarg.h>
  38 #include <sys/select.h>
  39 #include <time.h>
  40
  41 #ifdef DBUS_BUILD_X11
  42 #include <X11/Xlib.h>
  43 extern Display *xdisplay;
  44 #endif
  45
  46 static char* machine_uuid = NULL;
  47
  48 const char*
  49 get_machine_uuid (void)
  50 {
  51   return machine_uuid;
  52 }
  53
  54 static void
  55 save_machine_uuid (const char *uuid_arg)
  56 {
  57   if (strlen (uuid_arg) != 32)
  58     {
  59       fprintf (stderr, "machine ID '%s' looks like it's the wrong length, should be 32 hex digits",
  60                uuid_arg);
  61       exit (1);
  62     }
  63
  64   machine_uuid = xstrdup (uuid_arg);
  65 }
  66
  67 #define UUID_MAXLEN 40
  68 /* Read the machine uuid from file if needed. Returns TRUE if machine_uuid is
  69  * set after this function */
  70 static int
  71 read_machine_uuid_if_needed (void)
  72 {
  73   FILE *f;
  74   char uuid[UUID_MAXLEN];
  75   size_t len;
  76   int ret = FALSE;
  77
  78   if (machine_uuid != NULL)
  79     return TRUE;
  80
  81   f = fopen (DBUS_MACHINE_UUID_FILE, "r");
  82   if (f == NULL)
  83     return FALSE;
  84
  85   if (fgets (uuid, UUID_MAXLEN, f) == NULL)
  86     goto out;
  87
  88   len = strlen (uuid);
  89   if (len < 32)
  90     goto out;
  91
  92   /* rstrip the read uuid */
  93   while (len > 31 && isspace(uuid[len - 1]))
  94     len--;
  95
  96   if (len != 32)
  97     goto out;
  98
  99   uuid[len] = '\0';
 100   machine_uuid = xstrdup (uuid);
 101   verbose ("UID: %s\n", machine_uuid);
 102   ret = TRUE;
 103
 104 out:
 105   fclose(f);
 106   return ret;
 107 }
 108
 109
 110 void
 111 verbose (const char *format,
 112          ...)
 113 {
 114   va_list args;
 115   static int verbose = TRUE;
 116   static int verbose_initted = FALSE;
 117
 118   /* things are written a bit oddly here so that
 119    * in the non-verbose case we just have the one
 120    * conditional and return immediately.
 121    */
 122   if (!verbose)
 123     return;
 124
 125   if (!verbose_initted)
 126     {
 127       verbose = getenv ("DBUS_VERBOSE") != NULL;
 128       verbose_initted = TRUE;
 129       if (!verbose)
 130         return;
 131     }
 132
 133   fprintf (stderr, "%lu: ", (unsigned long) getpid ());
 134
 135   va_start (args, format);
 136   vfprintf (stderr, format, args);
 137   va_end (args);
 138 }
 139
 140 static void
 141 usage (int ecode)
 142 {
 143   fprintf (stderr, "dbus-launch [--version] [--help] [--sh-syntax] [--csh-syntax] [--auto-syntax] [--exit-with-session]\n");
 144   exit (ecode);
 145 }
 146
 147 static void
 148 version (void)
 149 {
 150   printf ("D-Bus Message Bus Launcher %s\n"
 151           "Copyright (C) 2003 Red Hat, Inc.\n"
 152           "This is free software; see the source for copying conditions.\n"
 153           "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
 154           VERSION);
 155   exit (0);
 156 }
 157
 158 char *
 159 xstrdup (const char *str)
 160 {
 161   int len;
 162   char *copy;
 163
 164   if (str == NULL)
 165     return NULL;
 166
 167   len = strlen (str);
 168
 169   copy = malloc (len + 1);
 170   if (copy == NULL)
 171     return NULL;
 172
 173   memcpy (copy, str, len + 1);
 174
 175   return copy;
 176 }
 177
 178 typedef enum
 179 {
 180   READ_STATUS_OK,    /**< Read succeeded */
 181   READ_STATUS_ERROR, /**< Some kind of error */
 182   READ_STATUS_EOF    /**< EOF returned */
 183 } ReadStatus;
 184
 185 static ReadStatus
 186 read_line (int        fd,
 187            char      *buf,
 188            size_t     maxlen)
 189 {
 190   size_t bytes = 0;
 191   ReadStatus retval;
 192
 193   memset (buf, '\0', maxlen);
 194   maxlen -= 1; /* ensure nul term */
 195
 196   retval = READ_STATUS_OK;
 197
 198   while (TRUE)
 199     {
 200       ssize_t chunk;
 201       size_t to_read;
 202
 203     again:
 204       to_read = maxlen - bytes;
 205
 206       if (to_read == 0)
 207         break;
 208
 209       chunk = read (fd,
 210                     buf + bytes,
 211                     to_read);
 212       if (chunk < 0 && errno == EINTR)
 213         goto again;
 214
 215       if (chunk < 0)
 216         {
 217           retval = READ_STATUS_ERROR;
 218           break;
 219         }
 220       else if (chunk == 0)
 221         {
 222           retval = READ_STATUS_EOF;
 223           break; /* EOF */
 224         }
 225       else /* chunk > 0 */
 226         bytes += chunk;
 227     }
 228
 229   if (retval == READ_STATUS_EOF &&
 230       bytes > 0)
 231     retval = READ_STATUS_OK;
 232
 233   /* whack newline */
 234   if (retval != READ_STATUS_ERROR &&
 235       bytes > 0 &&
 236       buf[bytes-1] == '\n')
 237     buf[bytes-1] = '\0';
 238
 239   return retval;
 240 }
 241
 242 static ReadStatus
 243 read_pid (int        fd,
 244           pid_t     *buf)
 245 {
 246   size_t bytes = 0;
 247   ReadStatus retval;
 248
 249   retval = READ_STATUS_OK;
 250
 251   while (TRUE)
 252     {
 253       ssize_t chunk;
 254       size_t to_read;
 255
 256     again:
 257       to_read = sizeof (pid_t) - bytes;
 258
 259       if (to_read == 0)
 260         break;
 261
 262       chunk = read (fd,
 263                     ((char*)buf) + bytes,
 264                     to_read);
 265       if (chunk < 0 && errno == EINTR)
 266         goto again;
 267
 268       if (chunk < 0)
 269         {
 270           retval = READ_STATUS_ERROR;
 271           break;
 272         }
 273       else if (chunk == 0)
 274         {
 275           retval = READ_STATUS_EOF;
 276           break; /* EOF */
 277         }
 278       else /* chunk > 0 */
 279         bytes += chunk;
 280     }
 281
 282   return retval;
 283 }
 284
 285 static void
 286 do_write (int fd, const void *buf, size_t count)
 287 {
 288   size_t bytes_written;
 289   int ret;
 290
 291   bytes_written = 0;
 292
 293  again:
 294
 295   ret = write (fd, ((const char*)buf) + bytes_written, count - bytes_written);
 296
 297   if (ret < 0)
 298     {
 299       if (errno == EINTR)
 300         goto again;
 301       else
 302         {
 303           fprintf (stderr, "Failed to write data to pipe! %s\n",
 304                    strerror (errno));
 305           exit (1); /* give up, we suck */
 306         }
 307     }
 308   else
 309     bytes_written += ret;
 310
 311   if (bytes_written < count)
 312     goto again;
 313 }
 314
 315 static void
 316 write_pid (int   fd,
 317            pid_t pid)
 318 {
 319   do_write (fd, &pid, sizeof (pid));
 320 }
 321
 322 static int
 323 do_waitpid (pid_t pid)
 324 {
 325   int ret;
 326
 327  again:
 328   ret = waitpid (pid, NULL, 0);
 329
 330   if (ret < 0 &&
 331       errno == EINTR)
 332     goto again;
 333
 334   return ret;
 335 }
 336
 337 static pid_t bus_pid_to_kill = -1;
 338
 339 static void
 340 kill_bus(void)
 341 {
 342   verbose ("Killing message bus and exiting babysitter\n");
 343   kill (bus_pid_to_kill, SIGTERM);
 344   sleep (3);
 345   kill (bus_pid_to_kill, SIGKILL);
 346 }
 347
 348 void
 349 kill_bus_and_exit (int exitcode)
 350 {
 351   /* in case these point to any NFS mounts, get rid of them immediately */
 352   close (0);
 353   close (1);
 354   close (2);
 355
 356   kill_bus();
 357
 358   exit (exitcode);
 359 }
 360
 361 static void
 362 print_variables (const char *bus_address, pid_t bus_pid, long bus_wid,
 363                  int c_shell_syntax, int bourne_shell_syntax,
 364                  int binary_syntax)
 365 {
 366   if (binary_syntax)
 367     {
 368       do_write (1, bus_address, strlen (bus_address) + 1);
 369       do_write (1, &bus_pid, sizeof bus_pid);
 370       do_write (1, &bus_wid, sizeof bus_wid);
 371       return;
 372     }
 373   else if (c_shell_syntax)
 374     {
 375       printf ("setenv DBUS_SESSION_BUS_ADDRESS '%s';\n", bus_address);
 376       printf ("set DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
 377       if (bus_wid)
 378         printf ("set DBUS_SESSION_BUS_WINDOWID=%ld;\n", (long) bus_wid);
 379       fflush (stdout);
 380     }
 381   else if (bourne_shell_syntax)
 382     {
 383       printf ("DBUS_SESSION_BUS_ADDRESS='%s';\n", bus_address);
 384       printf ("export DBUS_SESSION_BUS_ADDRESS;\n");
 385       printf ("DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
 386       if (bus_wid)
 387         printf ("DBUS_SESSION_BUS_WINDOWID=%ld;\n", (long) bus_wid);
 388       fflush (stdout);
 389     }
 390   else
 391     {
 392       printf ("DBUS_SESSION_BUS_ADDRESS=%s\n", bus_address);
 393       printf ("DBUS_SESSION_BUS_PID=%ld\n", (long) bus_pid);
 394       if (bus_wid)
 395         printf ("DBUS_SESSION_BUS_WINDOWID=%ld\n", (long) bus_wid);
 396       fflush (stdout);
 397     }
 398 }
 399
 400 static int got_sighup = FALSE;
 401
 402 static void
 403 signal_handler (int sig)
 404 {
 405   switch (sig)
 406     {
 407 #ifdef SIGHUP
 408     case SIGHUP:
 409 #endif
 410     case SIGINT:
 411     case SIGTERM:
 412       got_sighup = TRUE;
 413       break;
 414     }
 415 }
 416
 417 static void
 418 kill_bus_when_session_ends (void)
 419 {
 420   int tty_fd;
 421   int x_fd;
 422   fd_set read_set;
 423   fd_set err_set;
 424   struct sigaction act;
 425   sigset_t empty_mask;
 426
 427   /* install SIGHUP handler */
 428   got_sighup = FALSE;
 429   sigemptyset (&empty_mask);
 430   act.sa_handler = signal_handler;
 431   act.sa_mask    = empty_mask;
 432   act.sa_flags   = 0;
 433   sigaction (SIGHUP,  &act, NULL);
 434   sigaction (SIGTERM,  &act, NULL);
 435   sigaction (SIGINT,  &act, NULL);
 436
 437 #ifdef DBUS_BUILD_X11
 438   x11_init();
 439   if (xdisplay != NULL)
 440     {
 441       x_fd = ConnectionNumber (xdisplay);
 442     }
 443   else
 444     x_fd = -1;
 445 #else
 446   x_fd = -1;
 447 #endif
 448
 449   if (isatty (0))
 450     tty_fd = 0;
 451   else
 452     tty_fd = -1;
 453
 454   if (tty_fd >= 0)
 455     verbose ("stdin isatty(), monitoring it\n");
 456   else
 457     verbose ("stdin was not a TTY, not monitoring it\n");
 458
 459   if (tty_fd < 0 && x_fd < 0)
 460     {
 461       fprintf (stderr, "No terminal on standard input and no X display; cannot attach message bus to session lifetime\n");
 462       exit (1);
 463     }
 464
 465   while (TRUE)
 466     {
 467 #ifdef DBUS_BUILD_X11
 468       /* Dump events on the floor, and let
 469        * IO error handler run if we lose
 470        * the X connection. It's important to
 471        * run this before going into select() since
 472        * we might have queued outgoing messages or
 473        * events.
 474        */
 475       x11_handle_event ();
 476 #endif
 477
 478       FD_ZERO (&read_set);
 479       FD_ZERO (&err_set);
 480
 481       if (tty_fd >= 0)
 482         {
 483           FD_SET (tty_fd, &read_set);
 484           FD_SET (tty_fd, &err_set);
 485         }
 486
 487       if (x_fd >= 0)
 488         {
 489           FD_SET (x_fd, &read_set);
 490           FD_SET (x_fd, &err_set);
 491         }
 492
 493       select (MAX (tty_fd, x_fd) + 1,
 494               &read_set, NULL, &err_set, NULL);
 495
 496       if (got_sighup)
 497         {
 498           verbose ("Got SIGHUP, exiting\n");
 499           kill_bus_and_exit (0);
 500         }
 501
 502 #ifdef DBUS_BUILD_X11
 503       /* Events will be processed before we select again
 504        */
 505       if (x_fd >= 0)
 506         verbose ("X fd condition reading = %d error = %d\n",
 507                  FD_ISSET (x_fd, &read_set),
 508                  FD_ISSET (x_fd, &err_set));
 509 #endif
 510
 511       if (tty_fd >= 0)
 512         {
 513           if (FD_ISSET (tty_fd, &read_set))
 514             {
 515               int bytes_read;
 516               char discard[512];
 517
 518               verbose ("TTY ready for reading\n");
 519
 520               bytes_read = read (tty_fd, discard, sizeof (discard));
 521
 522               verbose ("Read %d bytes from TTY errno = %d\n",
 523                        bytes_read, errno);
 524
 525               if (bytes_read == 0)
 526                 kill_bus_and_exit (0); /* EOF */
 527               else if (bytes_read < 0 && errno != EINTR)
 528                 {
 529                   /* This shouldn't happen I don't think; to avoid
 530                    * spinning on the fd forever we exit.
 531                    */
 532                   fprintf (stderr, "dbus-launch: error reading from stdin: %s\n",
 533                            strerror (errno));
 534                   kill_bus_and_exit (0);
 535                 }
 536             }
 537           else if (FD_ISSET (tty_fd, &err_set))
 538             {
 539               verbose ("TTY has error condition\n");
 540
 541               kill_bus_and_exit (0);
 542             }
 543         }
 544     }
 545 }
 546
 547 static void
 548 babysit (int   exit_with_session,
 549          pid_t child_pid,
 550          int   read_bus_pid_fd)  /* read pid from here */
 551 {
 552   int ret;
 553   int dev_null_fd;
 554   const char *s;
 555
 556   verbose ("babysitting, exit_with_session = %d, child_pid = %ld, read_bus_pid_fd = %d\n",
 557            exit_with_session, (long) child_pid, read_bus_pid_fd);
 558
 559   /* We chdir ("/") since we are persistent and daemon-like, and fork
 560    * again so dbus-launch can reap the parent.  However, we don't
 561    * setsid() or close fd 0 because the idea is to remain attached
 562    * to the tty and the X server in order to kill the message bus
 563    * when the session ends.
 564    */
 565
 566   if (chdir ("/") < 0)
 567     {
 568       fprintf (stderr, "Could not change to root directory: %s\n",
 569                strerror (errno));
 570       exit (1);
 571     }
 572
 573   /* Close stdout/stderr so we don't block an "eval" or otherwise
 574    * lock up. stdout is still chaining through to dbus-launch
 575    * and in turn to the parent shell.
 576    */
 577   dev_null_fd = open ("/dev/null", O_RDWR);
 578   if (dev_null_fd >= 0)
 579     {
 580       if (!exit_with_session)
 581         dup2 (dev_null_fd, 0);
 582       dup2 (dev_null_fd, 1);
 583       s = getenv ("DBUS_DEBUG_OUTPUT");
 584       if (s == NULL || *s == '\0')
 585         dup2 (dev_null_fd, 2);
 586     }
 587   else
 588     {
 589       fprintf (stderr, "Failed to open /dev/null: %s\n",
 590                strerror (errno));
 591       /* continue, why not */
 592     }
 593
 594   ret = fork ();
 595
 596   if (ret < 0)
 597     {
 598       fprintf (stderr, "fork() failed in babysitter: %s\n",
 599                strerror (errno));
 600       exit (1);
 601     }
 602
 603   if (ret > 0)
 604     {
 605       /* Parent reaps pre-fork part of bus daemon, then exits and is
 606        * reaped so the babysitter isn't a zombie
 607        */
 608
 609       verbose ("=== Babysitter's intermediate parent continues again\n");
 610
 611       if (do_waitpid (child_pid) < 0)
 612         {
 613           /* shouldn't happen */
 614           fprintf (stderr, "Failed waitpid() waiting for bus daemon's parent\n");
 615           exit (1);
 616         }
 617
 618       verbose ("Babysitter's intermediate parent exiting\n");
 619
 620       exit (0);
 621     }
 622
 623   /* Child continues */
 624   verbose ("=== Babysitter process created\n");
 625
 626   verbose ("Reading PID from bus\n");
 627
 628   switch (read_pid (read_bus_pid_fd, &bus_pid_to_kill))
 629     {
 630     case READ_STATUS_OK:
 631       break;
 632     case READ_STATUS_EOF:
 633       fprintf (stderr, "EOF in dbus-launch reading PID from bus daemon\n");
 634       exit (1);
 635       break;
 636     case READ_STATUS_ERROR:
 637       fprintf (stderr, "Error in dbus-launch reading PID from bus daemon: %s\n",
 638                strerror (errno));
 639       exit (1);
 640       break;
 641     }
 642
 643   verbose ("Got PID %ld from daemon\n",
 644            (long) bus_pid_to_kill);
 645
 646   if (exit_with_session)
 647     {
 648       /* Bus is now started and launcher has needed info;
 649        * we connect to X display and tty and wait to
 650        * kill bus if requested.
 651        */
 652
 653       kill_bus_when_session_ends ();
 654     }
 655
 656   verbose ("Babysitter exiting\n");
 657
 658   exit (0);
 659 }
 660
 661 static void
 662 do_close_stderr (void)
 663 {
 664   int fd;
 665
 666   fflush (stderr);
 667
 668   /* dbus-launch is a Unix-only program, so we can rely on /dev/null being there.
 669    * We're including unistd.h and we're dealing with sh/csh launch sequences...
 670    */
 671   fd = open ("/dev/null", O_RDWR);
 672   if (fd == -1)
 673     {
 674       fprintf (stderr, "Internal error: cannot open /dev/null: %s", strerror (errno));
 675       exit (1);
 676     }
 677
 678   close (2);
 679   if (dup2 (fd, 2) == -1)
 680     {
 681       /* error; we can't report an error anymore... */
 682       exit (1);
 683     }
 684   close (fd);
 685 }
 686
 687 static void
 688 pass_info (const char *runprog, const char *bus_address, pid_t bus_pid,
 689            long bus_wid, int c_shell_syntax, int bourne_shell_syntax,
 690            int binary_syntax,
 691            int argc, char **argv, int remaining_args)
 692 {
 693   if (runprog)
 694     {
 695       char *envvar;
 696       char **args;
 697       int i;
 698
 699       envvar = malloc (strlen ("DBUS_SESSION_BUS_ADDRESS=") +
 700           strlen (bus_address) + 1);
 701       args = malloc (sizeof (char *) * ((argc-remaining_args)+2));
 702
 703       if (envvar == NULL || args == NULL)
 704         {
 705           free (envvar);
 706           free (args);
 707           goto oom;
 708         }
 709
 710      args[0] = xstrdup (runprog);
 711       if (!args[0])
 712         goto oom;
 713      for (i = 1; i <= (argc-remaining_args); i++)
 714       {
 715         size_t len = strlen (argv[remaining_args+i-1])+1;
 716         args[i] = malloc (len);
 717         if (!args[i])
 718           goto oom;
 719         strncpy (args[i], argv[remaining_args+i-1], len);
 720        }
 721      args[i] = NULL;
 722
 723      strcpy (envvar, "DBUS_SESSION_BUS_ADDRESS=");
 724      strcat (envvar, bus_address);
 725      putenv (envvar);
 726
 727      execvp (runprog, args);
 728      fprintf (stderr, "Couldn't exec %s: %s\n", runprog, strerror (errno));
 729      exit (1);
 730     }
 731    else
 732     {
 733       print_variables (bus_address, bus_pid, bus_wid, c_shell_syntax,
 734          bourne_shell_syntax, binary_syntax);
 735     }
 736   verbose ("dbus-launch exiting\n");
 737
 738   fflush (stdout);
 739   fflush (stderr);
 740   close (1);
 741   close (2);
 742   exit (0);
 743 oom:
 744   fprintf (stderr, "Out of memory!");
 745   exit (1);
 746 }
 747
 748 #define READ_END  0
 749 #define WRITE_END 1
 750
 751 int
 752 main (int argc, char **argv)
 753 {
 754   const char *prev_arg;
 755   const char *shname;
 756   const char *runprog = NULL;
 757   int remaining_args = 0;
 758   int exit_with_session;
 759   int binary_syntax = FALSE;
 760   int c_shell_syntax = FALSE;
 761   int bourne_shell_syntax = FALSE;
 762   int auto_shell_syntax = FALSE;
 763   int autolaunch = FALSE;
 764   int requires_arg = FALSE;
 765   int close_stderr = FALSE;
 766   int i;
 767   int ret;
 768   int bus_pid_to_launcher_pipe[2];
 769   int bus_pid_to_babysitter_pipe[2];
 770   int bus_address_to_launcher_pipe[2];
 771   char *config_file;
 772
 773   exit_with_session = FALSE;
 774   config_file = NULL;
 775
 776   prev_arg = NULL;
 777   i = 1;
 778   while (i < argc)
 779     {
 780       const char *arg = argv[i];
 781
 782       if (strcmp (arg, "--help") == 0 ||
 783           strcmp (arg, "-h") == 0 ||
 784           strcmp (arg, "-?") == 0)
 785         usage (0);
 786       else if (strcmp (arg, "--auto-syntax") == 0)
 787         auto_shell_syntax = TRUE;
 788       else if (strcmp (arg, "-c") == 0 ||
 789                strcmp (arg, "--csh-syntax") == 0)
 790         c_shell_syntax = TRUE;
 791       else if (strcmp (arg, "-s") == 0 ||
 792                strcmp (arg, "--sh-syntax") == 0)
 793         bourne_shell_syntax = TRUE;
 794       else if (strcmp (arg, "--binary-syntax") == 0)
 795         binary_syntax = TRUE;
 796       else if (strcmp (arg, "--version") == 0)
 797         version ();
 798       else if (strcmp (arg, "--exit-with-session") == 0)
 799         exit_with_session = TRUE;
 800       else if (strcmp (arg, "--close-stderr") == 0)
 801         close_stderr = TRUE;
 802       else if (strstr (arg, "--autolaunch=") == arg)
 803         {
 804           const char *s;
 805
 806           if (autolaunch)
 807             {
 808               fprintf (stderr, "--autolaunch given twice\n");
 809               exit (1);
 810             }
 811
 812           autolaunch = TRUE;
 813
 814           s = strchr (arg, '=');
 815           ++s;
 816
 817           save_machine_uuid (s);
 818         }
 819       else if (prev_arg &&
 820                strcmp (prev_arg, "--autolaunch") == 0)
 821         {
 822           if (autolaunch)
 823             {
 824               fprintf (stderr, "--autolaunch given twice\n");
 825               exit (1);
 826             }
 827
 828           autolaunch = TRUE;
 829
 830           save_machine_uuid (arg);
 831           requires_arg = FALSE;
 832         }
 833       else if (strcmp (arg, "--autolaunch") == 0)
 834         requires_arg = TRUE;
 835       else if (strstr (arg, "--config-file=") == arg)
 836         {
 837           const char *file;
 838
 839           if (config_file != NULL)
 840             {
 841               fprintf (stderr, "--config-file given twice\n");
 842               exit (1);
 843             }
 844
 845           file = strchr (arg, '=');
 846           ++file;
 847
 848           config_file = xstrdup (file);
 849         }
 850       else if (prev_arg &&
 851                strcmp (prev_arg, "--config-file") == 0)
 852         {
 853           if (config_file != NULL)
 854             {
 855               fprintf (stderr, "--config-file given twice\n");
 856               exit (1);
 857             }
 858
 859           config_file = xstrdup (arg);
 860           requires_arg = FALSE;
 861         }
 862       else if (strcmp (arg, "--config-file") == 0)
 863         requires_arg = TRUE;
 864       else if (arg[0] == '-')
 865         {
 866           if (strcmp (arg, "--") != 0)
 867             {
 868               fprintf (stderr, "Option `%s' is unknown.\n", arg);
 869               exit (1);
 870             }
 871           else
 872             {
 873               runprog = argv[i+1];
 874               remaining_args = i+2;
 875               break;
 876             }
 877         }
 878       else
 879         {
 880           runprog = arg;
 881           remaining_args = i+1;
 882           break;
 883         }
 884
 885       prev_arg = arg;
 886
 887       ++i;
 888     }
 889   if (requires_arg)
 890     {
 891       fprintf (stderr, "Option `%s' requires an argument.\n", prev_arg);
 892       exit (1);
 893     }
 894
 895   if (auto_shell_syntax)
 896     {
 897       if ((shname = getenv ("SHELL")) != NULL)
 898        {
 899          if (!strncmp (shname + strlen (shname) - 3, "csh", 3))
 900            c_shell_syntax = TRUE;
 901          else
 902            bourne_shell_syntax = TRUE;
 903        }
 904       else
 905        bourne_shell_syntax = TRUE;
 906     }
 907
 908   if (exit_with_session)
 909     verbose ("--exit-with-session enabled\n");
 910
 911   if (autolaunch)
 912     {
 913 #ifndef DBUS_BUILD_X11
 914       fprintf (stderr, "Autolaunch requested, but X11 support not compiled in.\n"
 915                "Cannot continue.\n");
 916       exit (1);
 917 #else
 918       char *address;
 919       pid_t pid;
 920       long wid;
 921
 922       if (get_machine_uuid () == NULL)
 923         {
 924           fprintf (stderr, "Machine UUID not provided as arg to --autolaunch\n");
 925           exit (1);
 926         }
 927
 928       verbose ("Autolaunch enabled (using X11).\n");
 929       if (!exit_with_session)
 930         {
 931           verbose ("--exit-with-session automatically enabled\n");
 932           exit_with_session = TRUE;
 933         }
 934
 935       if (!x11_init ())
 936         {
 937           fprintf (stderr, "Autolaunch error: X11 initialization failed.\n");
 938           exit (1);
 939         }
 940
 941       if (!x11_get_address (&address, &pid, &wid))
 942         {
 943           fprintf (stderr, "Autolaunch error: X11 communication error.\n");
 944           exit (1);
 945         }
 946
 947       if (address != NULL)
 948         {
 949           verbose ("dbus-daemon is already running. Returning existing parameters.\n");
 950           pass_info (runprog, address, pid, wid, c_shell_syntax,
 951                            bourne_shell_syntax, binary_syntax, argc, argv, remaining_args);
 952           exit (0);
 953         }
 954     }
 955    else if (read_machine_uuid_if_needed())
 956     {
 957       x11_init();
 958 #endif
 959     }
 960
 961
 962   if (pipe (bus_pid_to_launcher_pipe) < 0 ||
 963       pipe (bus_address_to_launcher_pipe) < 0 ||
 964       pipe (bus_pid_to_babysitter_pipe) < 0)
 965     {
 966       fprintf (stderr,
 967                "Failed to create pipe: %s\n",
 968                strerror (errno));
 969       exit (1);
 970     }
 971
 972   ret = fork ();
 973   if (ret < 0)
 974     {
 975       fprintf (stderr, "Failed to fork: %s\n",
 976                strerror (errno));
 977       exit (1);
 978     }
 979
 980   if (ret == 0)
 981     {
 982       /* Child */
 983 #define MAX_FD_LEN 64
 984       char write_pid_fd_as_string[MAX_FD_LEN];
 985       char write_address_fd_as_string[MAX_FD_LEN];
 986
 987 #ifdef DBUS_BUILD_X11
 988       xdisplay = NULL;
 989 #endif
 990
 991       if (close_stderr)
 992         do_close_stderr ();
 993
 994       verbose ("=== Babysitter's intermediate parent created\n");
 995
 996       /* Fork once more to create babysitter */
 997
 998       ret = fork ();
 999       if (ret < 0)
1000         {
1001           fprintf (stderr, "Failed to fork: %s\n",
1002                    strerror (errno));
1003           exit (1);
1004         }
1005
1006       if (ret > 0)
1007         {
1008           /* In babysitter */
1009           verbose ("=== Babysitter's intermediate parent continues\n");
1010
1011           close (bus_pid_to_launcher_pipe[READ_END]);
1012           close (bus_pid_to_launcher_pipe[WRITE_END]);
1013           close (bus_address_to_launcher_pipe[READ_END]);
1014           close (bus_address_to_launcher_pipe[WRITE_END]);
1015           close (bus_pid_to_babysitter_pipe[WRITE_END]);
1016
1017           /* babysit() will fork *again*
1018            * and will also reap the pre-forked bus
1019            * daemon
1020            */
1021           babysit (exit_with_session, ret,
1022                    bus_pid_to_babysitter_pipe[READ_END]);
1023           exit (0);
1024         }
1025
1026       verbose ("=== Bus exec process created\n");
1027
1028       /* Now we are the bus process (well, almost;
1029        * dbus-daemon itself forks again)
1030        */
1031       close (bus_pid_to_launcher_pipe[READ_END]);
1032       close (bus_address_to_launcher_pipe[READ_END]);
1033       close (bus_pid_to_babysitter_pipe[READ_END]);
1034       close (bus_pid_to_babysitter_pipe[WRITE_END]);
1035
1036       sprintf (write_pid_fd_as_string,
1037                "%d", bus_pid_to_launcher_pipe[WRITE_END]);
1038
1039       sprintf (write_address_fd_as_string,
1040                "%d", bus_address_to_launcher_pipe[WRITE_END]);
1041
1042       verbose ("Calling exec()\n");
1043
1044 #ifdef DBUS_BUILD_TESTS
1045       /* exec from testdir */
1046       if (getenv("DBUS_USE_TEST_BINARY") != NULL)
1047         {
1048           execl (TEST_BUS_BINARY,
1049                  TEST_BUS_BINARY,
1050                  "--fork",
1051                  "--print-pid", write_pid_fd_as_string,
1052                  "--print-address", write_address_fd_as_string,
1053                  config_file ? "--config-file" : "--session",
1054                  config_file, /* has to be last in this varargs list */
1055                  NULL);
1056
1057           fprintf (stderr,
1058                    "Failed to execute test message bus daemon %s: %s. Will try again with the system path.\n",
1059                    TEST_BUS_BINARY, strerror (errno));
1060         }
1061  #endif /* DBUS_BUILD_TESTS */
1062
1063       execl (DBUS_DAEMONDIR"/dbus-daemon",
1064              DBUS_DAEMONDIR"/dbus-daemon",
1065              "--fork",
1066              "--print-pid", write_pid_fd_as_string,
1067              "--print-address", write_address_fd_as_string,
1068              config_file ? "--config-file" : "--session",
1069              config_file, /* has to be last in this varargs list */
1070              NULL);
1071
1072       fprintf (stderr,
1073                "Failed to execute message bus daemon %s: %s.  Will try again without full path.\n",
1074                DBUS_DAEMONDIR"/dbus-daemon", strerror (errno));
1075
1076       /*
1077        * If it failed, try running without full PATH.  Note this is needed
1078        * because the build process builds the run-with-tmp-session-bus.conf
1079        * file and the dbus-daemon will not be in the install location during
1080        * build time.
1081        */
1082       execlp ("dbus-daemon",
1083               "dbus-daemon",
1084               "--fork",
1085               "--print-pid", write_pid_fd_as_string,
1086               "--print-address", write_address_fd_as_string,
1087               config_file ? "--config-file" : "--session",
1088               config_file, /* has to be last in this varargs list */
1089               NULL);
1090
1091       fprintf (stderr,
1092                "Failed to execute message bus daemon: %s\n",
1093                strerror (errno));
1094       exit (1);
1095     }
1096   else
1097     {
1098       /* Parent */
1099 #define MAX_PID_LEN 64
1100       pid_t bus_pid;
1101       char bus_address[MAX_ADDR_LEN];
1102       char buf[MAX_PID_LEN];
1103       char *end;
1104       long wid = 0;
1105       long val;
1106       int ret2;
1107
1108       verbose ("=== Parent dbus-launch continues\n");
1109
1110       close (bus_pid_to_launcher_pipe[WRITE_END]);
1111       close (bus_address_to_launcher_pipe[WRITE_END]);
1112       close (bus_pid_to_babysitter_pipe[READ_END]);
1113
1114       verbose ("Waiting for babysitter's intermediate parent\n");
1115
1116       /* Immediately reap parent of babysitter
1117        * (which was created just for us to reap)
1118        */
1119       if (do_waitpid (ret) < 0)
1120         {
1121           fprintf (stderr, "Failed to waitpid() for babysitter intermediate process: %s\n",
1122                    strerror (errno));
1123           exit (1);
1124         }
1125
1126       verbose ("Reading address from bus\n");
1127
1128       /* Read the pipe data, print, and exit */
1129       switch (read_line (bus_address_to_launcher_pipe[READ_END],
1130                          bus_address, MAX_ADDR_LEN))
1131         {
1132         case READ_STATUS_OK:
1133           break;
1134         case READ_STATUS_EOF:
1135           fprintf (stderr, "EOF in dbus-launch reading address from bus daemon\n");
1136           exit (1);
1137           break;
1138         case READ_STATUS_ERROR:
1139           fprintf (stderr, "Error in dbus-launch reading address from bus daemon: %s\n",
1140                    strerror (errno));
1141           exit (1);
1142           break;
1143         }
1144
1145       close (bus_address_to_launcher_pipe[READ_END]);
1146
1147       verbose ("Reading PID from daemon\n");
1148       /* Now read data */
1149       switch (read_line (bus_pid_to_launcher_pipe[READ_END], buf, MAX_PID_LEN))
1150         {
1151         case READ_STATUS_OK:
1152           break;
1153         case READ_STATUS_EOF:
1154           fprintf (stderr, "EOF reading PID from bus daemon\n");
1155           exit (1);
1156           break;
1157         case READ_STATUS_ERROR:
1158           fprintf (stderr, "Error reading PID from bus daemon: %s\n",
1159                    strerror (errno));
1160           exit (1);
1161           break;
1162         }
1163
1164       end = NULL;
1165       val = strtol (buf, &end, 0);
1166       if (buf == end || end == NULL)
1167         {
1168           fprintf (stderr, "Failed to parse bus PID \"%s\": %s\n",
1169                    buf, strerror (errno));
1170           exit (1);
1171         }
1172
1173       bus_pid = val;
1174
1175       close (bus_pid_to_launcher_pipe[READ_END]);
1176
1177 #ifdef DBUS_BUILD_X11
1178       if (xdisplay != NULL)
1179         {
1180           verbose("Saving x11 address\n");
1181           ret2 = x11_save_address (bus_address, bus_pid, &wid);
1182           /* Only get an existing dbus session when autolaunching */
1183           if (autolaunch)
1184             {
1185               if (ret2 == 0)
1186                 {
1187                   char *address = NULL;
1188                   /* another window got added. Return its address */
1189                   bus_pid_to_kill = bus_pid;
1190                   if (x11_get_address (&address, &bus_pid, &wid)
1191                        && address != NULL)
1192                     {
1193                       verbose ("dbus-daemon is already running. Returning existing parameters.\n");
1194                       /* Kill the old bus */
1195                       kill_bus();
1196                       pass_info (runprog, address, bus_pid, wid,
1197                          c_shell_syntax, bourne_shell_syntax, binary_syntax,
1198                          argc, argv, remaining_args);
1199                     }
1200                   }
1201               if (ret2 < 0)
1202                 {
1203                   fprintf (stderr, "Error saving bus information.\n");
1204                   bus_pid_to_kill = bus_pid;
1205                   kill_bus_and_exit (1);
1206                 }
1207             }
1208         }
1209 #endif
1210
1211       /* Forward the pid to the babysitter */
1212       write_pid (bus_pid_to_babysitter_pipe[WRITE_END], bus_pid);
1213       close (bus_pid_to_babysitter_pipe[WRITE_END]);
1214
1215        pass_info (runprog, bus_address, bus_pid, wid, c_shell_syntax,
1216               bourne_shell_syntax, binary_syntax, argc, argv, remaining_args);
1217     }
1218
1219   return 0;
1220 }