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