dbus-launch.c 32.9 KB
Newer Older
1
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 3
/* dbus-launch.c  dbus-launch utility
 *
4 5
 * Copyright (C) 2003, 2006 Red Hat, Inc.
 * Copyright (C) 2006 Thiago Macieira <thiago@kde.org>
6
 *
7
 * Licensed under the Academic Free License version 2.1
8 9 10 11 12 13 14 15 16 17 18 19 20
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * 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 30 31 32 33 34 35
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
36 37
#include <signal.h>
#include <stdarg.h>
38
#include <sys/select.h>
39 40
#include <time.h>

41 42
#ifdef DBUS_BUILD_X11
#include <X11/Xlib.h>
43
extern Display *xdisplay;
44 45
#endif

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
/* PROCESSES
 *
 * If you are in a shell and run "dbus-launch myapp", here is what happens:
 *
 * shell [*]
 *   \- main()               --exec--> myapp[*]
 *      \- "intermediate parent"
 *         \- bus-runner     --exec--> dbus-daemon --fork
 *         \- babysitter[*]            \- final dbus-daemon[*]
 *
 * Processes marked [*] survive the initial flurry of activity.
 *
 * If you run "dbus-launch --sh-syntax" then the diagram is the same, except
 * that main() prints variables and exits 0 instead of exec'ing myapp.
 *
 * PIPES
 *
 * dbus-daemon --print-pid     -> bus_pid_to_launcher_pipe     -> main
 * dbus-daemon --print-address -> bus_address_to_launcher_pipe -> main
 * main                        -> bus_pid_to_babysitter_pipe   -> babysitter
 *
 * The intermediate parent looks pretty useless at first glance. Its purpose
 * is to avoid the bus-runner becoming a zombie: when the intermediate parent
 * terminates, the bus-runner and babysitter are reparented to init, which
 * reaps them if they have finished. We can't rely on main() to reap arbitrary
 * children because it might exec myapp, after which it can't be relied on to
 * reap its children. We *can* rely on main() to reap the intermediate parent,
 * because that happens before it execs myapp.
 *
 * It's unclear why dbus-daemon needs to fork, but we explicitly tell it to
 * for some reason, then wait for it. If we left it undefined, a forking
 * dbus-daemon would get the parent process reparented to init and reaped
 * when the intermediate parent terminated, and a non-forking dbus-daemon
 * would get reparented to init and carry on there.
 *
 * myapp is exec'd by the process that initially ran main() so that it's
 * the shell's child, so the shell knows how to do job control and stuff.
 * This is desirable for the "dbus-launch an application" use-case, less so
 * for the "dbus-launch a test suite in an isolated session" use-case.
 */

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
static char* machine_uuid = NULL;

const char*
get_machine_uuid (void)
{
  return machine_uuid;
}

static void
save_machine_uuid (const char *uuid_arg)
{
  if (strlen (uuid_arg) != 32)
    {
      fprintf (stderr, "machine ID '%s' looks like it's the wrong length, should be 32 hex digits",
               uuid_arg);
      exit (1);
    }

  machine_uuid = xstrdup (uuid_arg);
}

108
#ifdef DBUS_BUILD_X11
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
#define UUID_MAXLEN 40
/* Read the machine uuid from file if needed. Returns TRUE if machine_uuid is
 * set after this function */
static int
read_machine_uuid_if_needed (void)
{
  FILE *f;
  char uuid[UUID_MAXLEN];
  size_t len;
  int ret = FALSE;

  if (machine_uuid != NULL)
    return TRUE;

  f = fopen (DBUS_MACHINE_UUID_FILE, "r");
  if (f == NULL)
    return FALSE;

  if (fgets (uuid, UUID_MAXLEN, f) == NULL)
    goto out;

  len = strlen (uuid);
  if (len < 32)
    goto out;

  /* rstrip the read uuid */
135
  while (len > 31 && isspace((int) uuid[len - 1]))
136 137 138 139 140 141 142 143 144 145 146 147 148 149
    len--;

  if (len != 32)
    goto out;

  uuid[len] = '\0';
  machine_uuid = xstrdup (uuid);
  verbose ("UID: %s\n", machine_uuid);
  ret = TRUE;

out:
  fclose(f);
  return ret;
}
150
#endif /* DBUS_BUILD_X11 */
151

152
void
153 154 155
verbose (const char *format,
         ...)
{
156
#ifdef DBUS_ENABLE_VERBOSE_MODE
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
  va_list args;
  static int verbose = TRUE;
  static int verbose_initted = FALSE;
  
  /* things are written a bit oddly here so that
   * in the non-verbose case we just have the one
   * conditional and return immediately.
   */
  if (!verbose)
    return;
  
  if (!verbose_initted)
    {
      verbose = getenv ("DBUS_VERBOSE") != NULL;
      verbose_initted = TRUE;
      if (!verbose)
        return;
    }

  fprintf (stderr, "%lu: ", (unsigned long) getpid ());
  
  va_start (args, format);
  vfprintf (stderr, format, args);
  va_end (args);
181
#endif /* DBUS_ENABLE_VERBOSE_MODE */
182 183
}

184
static void
185
usage (int ecode)
186
{
187 188 189 190
  fprintf (stderr, "dbus-launch [--version] [--help] [--sh-syntax]"
           " [--csh-syntax] [--auto-syntax] [--binary-syntax] [--close-stderr]"
           " [--exit-with-session] [--autolaunch=MACHINEID]"
           " [--config-file=FILENAME] [PROGRAM] [ARGS...]\n");
191
  exit (ecode);
192 193 194 195 196
}

static void
version (void)
{
John (J5) Palmieri's avatar
John (J5) Palmieri committed
197
  printf ("D-Bus Message Bus Launcher %s\n"
198 199 200 201 202 203 204
          "Copyright (C) 2003 Red Hat, Inc.\n"
          "This is free software; see the source for copying conditions.\n"
          "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
          VERSION);
  exit (0);
}

205
char *
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
xstrdup (const char *str)
{
  int len;
  char *copy;
  
  if (str == NULL)
    return NULL;
  
  len = strlen (str);

  copy = malloc (len + 1);
  if (copy == NULL)
    return NULL;

  memcpy (copy, str, len + 1);
  
  return copy;
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
static char *
concat2 (const char *a,
    const char *b)
{
  size_t la, lb;
  char *ret;

  la = strlen (a);
  lb = strlen (b);

  ret = malloc (la + lb + 1);

  if (ret == NULL)
    return NULL;

  memcpy (ret, a, la);
  memcpy (ret + la, b, lb + 1);
  return ret;
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
typedef enum
{
  READ_STATUS_OK,    /**< Read succeeded */
  READ_STATUS_ERROR, /**< Some kind of error */
  READ_STATUS_EOF    /**< EOF returned */
} ReadStatus;

static ReadStatus
read_line (int        fd,
           char      *buf,
           size_t     maxlen)
{
  size_t bytes = 0;
  ReadStatus retval;

  memset (buf, '\0', maxlen);
  maxlen -= 1; /* ensure nul term */
  
  retval = READ_STATUS_OK;
  
  while (TRUE)
    {
267
      ssize_t chunk;    
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
      size_t to_read;
      
    again:
      to_read = maxlen - bytes;

      if (to_read == 0)
        break;
      
      chunk = read (fd,
                    buf + bytes,
                    to_read);
      if (chunk < 0 && errno == EINTR)
        goto again;
          
      if (chunk < 0)
        {
          retval = READ_STATUS_ERROR;
          break;
        }
      else if (chunk == 0)
        {
          retval = READ_STATUS_EOF;
          break; /* EOF */
        }
      else /* chunk > 0 */
	bytes += chunk;
    }

  if (retval == READ_STATUS_EOF &&
      bytes > 0)
    retval = READ_STATUS_OK;
  
  /* whack newline */
  if (retval != READ_STATUS_ERROR &&
      bytes > 0 &&
      buf[bytes-1] == '\n')
    buf[bytes-1] = '\0';
  
  return retval;
}

static ReadStatus
read_pid (int        fd,
          pid_t     *buf)
{
  size_t bytes = 0;
  ReadStatus retval;

  retval = READ_STATUS_OK;
  
  while (TRUE)
    {
320
      ssize_t chunk;    
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
      size_t to_read;
      
    again:
      to_read = sizeof (pid_t) - bytes;

      if (to_read == 0)
        break;
      
      chunk = read (fd,
                    ((char*)buf) + bytes,
                    to_read);
      if (chunk < 0 && errno == EINTR)
        goto again;
          
      if (chunk < 0)
        {
          retval = READ_STATUS_ERROR;
          break;
        }
      else if (chunk == 0)
        {
          retval = READ_STATUS_EOF;
          break; /* EOF */
        }
      else /* chunk > 0 */
	bytes += chunk;
    }

  return retval;
}

static void
do_write (int fd, const void *buf, size_t count)
{
  size_t bytes_written;
  int ret;
  
  bytes_written = 0;
  
 again:
  
  ret = write (fd, ((const char*)buf) + bytes_written, count - bytes_written);

  if (ret < 0)
    {
      if (errno == EINTR)
        goto again;
      else
        {
370 371
          fprintf (stderr, "Failed to write data to pipe! %s\n",
                   strerror (errno));
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
          exit (1); /* give up, we suck */
        }
    }
  else
    bytes_written += ret;
  
  if (bytes_written < count)
    goto again;
}

static void
write_pid (int   fd,
           pid_t pid)
{
  do_write (fd, &pid, sizeof (pid));
}

static int
do_waitpid (pid_t pid)
{
  int ret;
  
 again:
  ret = waitpid (pid, NULL, 0);

  if (ret < 0 &&
      errno == EINTR)
    goto again;

  return ret;
}

static pid_t bus_pid_to_kill = -1;

406
static void
407
kill_bus(void)
408
{
409 410 411
  if (bus_pid_to_kill <= 0)
    return;

412 413 414 415 416 417
  verbose ("Killing message bus and exiting babysitter\n");
  kill (bus_pid_to_kill, SIGTERM);
  sleep (3);
  kill (bus_pid_to_kill, SIGKILL);
}

418 419
void
kill_bus_and_exit (int exitcode)
420 421 422 423 424 425
{
  /* in case these point to any NFS mounts, get rid of them immediately */
  close (0);
  close (1);
  close (2);

426
  kill_bus();
427

428
  exit (exitcode);
429 430
}

431 432 433 434
static void
print_variables (const char *bus_address, pid_t bus_pid, long bus_wid,
		 int c_shell_syntax, int bourne_shell_syntax,
		 int binary_syntax)
435
{
436 437
  if (binary_syntax)
    {
438 439 440
      do_write (1, bus_address, strlen (bus_address) + 1);
      do_write (1, &bus_pid, sizeof bus_pid);
      do_write (1, &bus_wid, sizeof bus_wid);
441 442 443 444 445 446 447
      return;
    }
  else if (c_shell_syntax)
    {
      printf ("setenv DBUS_SESSION_BUS_ADDRESS '%s';\n", bus_address);	
      printf ("set DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
      if (bus_wid)
448
        printf ("set DBUS_SESSION_BUS_WINDOWID=%ld;\n", (long) bus_wid);
449
      fflush (stdout);
450
    }
451
  else if (bourne_shell_syntax)
452 453
    {
      printf ("DBUS_SESSION_BUS_ADDRESS='%s';\n", bus_address);
454
      printf ("export DBUS_SESSION_BUS_ADDRESS;\n");
455 456
      printf ("DBUS_SESSION_BUS_PID=%ld;\n", (long) bus_pid);
      if (bus_wid)
457
        printf ("DBUS_SESSION_BUS_WINDOWID=%ld;\n", (long) bus_wid);
458 459 460 461 462 463 464 465 466
      fflush (stdout);
    }
  else
    {
      printf ("DBUS_SESSION_BUS_ADDRESS=%s\n", bus_address);
      printf ("DBUS_SESSION_BUS_PID=%ld\n", (long) bus_pid);
      if (bus_wid)
	printf ("DBUS_SESSION_BUS_WINDOWID=%ld\n", (long) bus_wid);
      fflush (stdout);
467
    }
468 469 470 471 472 473 474 475 476 477
}

static int got_sighup = FALSE;

static void
signal_handler (int sig)
{
  switch (sig)
    {
    case SIGHUP:
478
    case SIGINT:
479
    case SIGTERM:
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
      got_sighup = TRUE;
      break;
    }
}

static void
kill_bus_when_session_ends (void)
{
  int tty_fd;
  int x_fd;
  fd_set read_set;
  fd_set err_set;
  struct sigaction act;
  sigset_t empty_mask;
  
  /* install SIGHUP handler */
  got_sighup = FALSE;
  sigemptyset (&empty_mask);
  act.sa_handler = signal_handler;
  act.sa_mask    = empty_mask;
  act.sa_flags   = 0;
501
  sigaction (SIGHUP,  &act, NULL);
502
  sigaction (SIGTERM,  &act, NULL);
503
  sigaction (SIGINT,  &act, NULL);
504 505
  
#ifdef DBUS_BUILD_X11
506
  x11_init();
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
  if (xdisplay != NULL)
    {
      x_fd = ConnectionNumber (xdisplay);
    }
  else
    x_fd = -1;
#else
  x_fd = -1;
#endif

  if (isatty (0))
    tty_fd = 0;
  else
    tty_fd = -1;

522 523 524 525 526 527 528 529 530
  if (x_fd >= 0)
    {
      verbose ("session lifetime is defined by X, not monitoring stdin\n");
      tty_fd = -1;
    }
  else if (tty_fd >= 0)
    {
      verbose ("stdin isatty(), monitoring it\n");
    }
531
  else
532 533 534 535
    {
      verbose ("stdin was not a TTY, not monitoring it\n");
    }

536 537 538
  if (tty_fd < 0 && x_fd < 0)
    {
      fprintf (stderr, "No terminal on standard input and no X display; cannot attach message bus to session lifetime\n");
539
      kill_bus_and_exit (1);
540 541 542 543
    }
  
  while (TRUE)
    {
544 545 546 547 548 549 550 551 552 553 554
#ifdef DBUS_BUILD_X11
      /* Dump events on the floor, and let
       * IO error handler run if we lose
       * the X connection. It's important to
       * run this before going into select() since
       * we might have queued outgoing messages or
       * events.
       */
      x11_handle_event ();
#endif
      
555 556 557 558 559 560 561 562 563 564 565 566 567 568
      FD_ZERO (&read_set);
      FD_ZERO (&err_set);

      if (tty_fd >= 0)
        {
          FD_SET (tty_fd, &read_set);
          FD_SET (tty_fd, &err_set);
        }

      if (x_fd >= 0)
        {
          FD_SET (x_fd, &read_set);
          FD_SET (x_fd, &err_set);
        }
569

570 571
      select (MAX (tty_fd, x_fd) + 1,
              &read_set, NULL, &err_set, NULL);
572 573 574 575

      if (got_sighup)
        {
          verbose ("Got SIGHUP, exiting\n");
576
          kill_bus_and_exit (0);
577 578 579
        }
      
#ifdef DBUS_BUILD_X11
580
      /* Events will be processed before we select again
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
       */
      if (x_fd >= 0)
        verbose ("X fd condition reading = %d error = %d\n",
                 FD_ISSET (x_fd, &read_set),
                 FD_ISSET (x_fd, &err_set));
#endif

      if (tty_fd >= 0)
        {
          if (FD_ISSET (tty_fd, &read_set))
            {
              int bytes_read;
              char discard[512];

              verbose ("TTY ready for reading\n");
              
              bytes_read = read (tty_fd, discard, sizeof (discard));

              verbose ("Read %d bytes from TTY errno = %d\n",
                       bytes_read, errno);
              
              if (bytes_read == 0)
603
                kill_bus_and_exit (0); /* EOF */
604 605 606 607 608 609 610
              else if (bytes_read < 0 && errno != EINTR)
                {
                  /* This shouldn't happen I don't think; to avoid
                   * spinning on the fd forever we exit.
                   */
                  fprintf (stderr, "dbus-launch: error reading from stdin: %s\n",
                           strerror (errno));
611
                  kill_bus_and_exit (0);
612 613 614 615 616 617
                }
            }
          else if (FD_ISSET (tty_fd, &err_set))
            {
              verbose ("TTY has error condition\n");
              
618
              kill_bus_and_exit (0);
619 620 621 622 623 624 625 626
            }
        }
    }
}

static void
babysit (int   exit_with_session,
         pid_t child_pid,
627
         int   read_bus_pid_fd)  /* read pid from here */
628 629
{
  int ret;
630
  int dev_null_fd;
631 632
  const char *s;

633 634
  verbose ("babysitting, exit_with_session = %d, child_pid = %ld, read_bus_pid_fd = %d\n",
           exit_with_session, (long) child_pid, read_bus_pid_fd);
635 636 637
  
  /* We chdir ("/") since we are persistent and daemon-like, and fork
   * again so dbus-launch can reap the parent.  However, we don't
638
   * setsid() or close fd 0 because the idea is to remain attached
639 640 641 642 643 644 645 646 647
   * to the tty and the X server in order to kill the message bus
   * when the session ends.
   */

  if (chdir ("/") < 0)
    {
      fprintf (stderr, "Could not change to root directory: %s\n",
               strerror (errno));
      exit (1);
648
    }
649

650 651 652
  /* Close stdout/stderr so we don't block an "eval" or otherwise
   * lock up. stdout is still chaining through to dbus-launch
   * and in turn to the parent shell.
653 654 655 656
   */
  dev_null_fd = open ("/dev/null", O_RDWR);
  if (dev_null_fd >= 0)
    {
657 658
      if (!exit_with_session)
        dup2 (dev_null_fd, 0);
659
      dup2 (dev_null_fd, 1);
660 661 662
      s = getenv ("DBUS_DEBUG_OUTPUT");
      if (s == NULL || *s == '\0')
        dup2 (dev_null_fd, 2);
663
      close (dev_null_fd);
664 665 666 667 668 669 670 671
    }
  else
    {
      fprintf (stderr, "Failed to open /dev/null: %s\n",
               strerror (errno));
      /* continue, why not */
    }
  
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
  ret = fork ();

  if (ret < 0)
    {
      fprintf (stderr, "fork() failed in babysitter: %s\n",
               strerror (errno));
      exit (1);
    }

  if (ret > 0)
    {
      /* Parent reaps pre-fork part of bus daemon, then exits and is
       * reaped so the babysitter isn't a zombie
       */

      verbose ("=== Babysitter's intermediate parent continues again\n");
      
      if (do_waitpid (child_pid) < 0)
        {
          /* shouldn't happen */
          fprintf (stderr, "Failed waitpid() waiting for bus daemon's parent\n");
          exit (1);
        }

      verbose ("Babysitter's intermediate parent exiting\n");
      
      exit (0);
    }

  /* Child continues */
  verbose ("=== Babysitter process created\n");

704 705 706
  verbose ("Reading PID from bus\n");
      
  switch (read_pid (read_bus_pid_fd, &bus_pid_to_kill))
707 708 709 710
    {
    case READ_STATUS_OK:
      break;
    case READ_STATUS_EOF:
711
      fprintf (stderr, "EOF in dbus-launch reading PID from bus daemon\n");
712 713 714
      exit (1);
      break;
    case READ_STATUS_ERROR:
715 716
      fprintf (stderr, "Error in dbus-launch reading PID from bus daemon: %s\n",
	       strerror (errno));
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
      exit (1);
      break;
    }

  verbose ("Got PID %ld from daemon\n",
           (long) bus_pid_to_kill);
  
  if (exit_with_session)
    {
      /* Bus is now started and launcher has needed info;
       * we connect to X display and tty and wait to
       * kill bus if requested.
       */
      
      kill_bus_when_session_ends ();
    }

  verbose ("Babysitter exiting\n");
  
  exit (0);
}

739 740
static void
do_close_stderr (void)
741
{
742 743
  int fd;

744 745 746 747 748
  fflush (stderr);

  /* dbus-launch is a Unix-only program, so we can rely on /dev/null being there.
   * We're including unistd.h and we're dealing with sh/csh launch sequences...
   */
749
  fd = open ("/dev/null", O_RDWR);
750 751 752 753 754 755 756 757
  if (fd == -1)
    {
      fprintf (stderr, "Internal error: cannot open /dev/null: %s", strerror (errno));
      exit (1);
    }

  close (2);
  if (dup2 (fd, 2) == -1)
758 759 760 761
    {
      /* error; we can't report an error anymore... */
      exit (1);
    }
762 763 764
  close (fd);
}

765 766 767 768 769 770
static void
pass_info (const char *runprog, const char *bus_address, pid_t bus_pid,
           long bus_wid, int c_shell_syntax, int bourne_shell_syntax,
           int binary_syntax,
           int argc, char **argv, int remaining_args)
{
771 772 773
  char *envvar = NULL;
  char **args = NULL;

774 775 776 777 778 779 780 781 782
  if (runprog)
    {
      int i;

      envvar = malloc (strlen ("DBUS_SESSION_BUS_ADDRESS=") +
          strlen (bus_address) + 1);
      args = malloc (sizeof (char *) * ((argc-remaining_args)+2));

      if (envvar == NULL || args == NULL)
783
        goto oom;
784

785
      args[0] = xstrdup (runprog);
786 787
      if (!args[0])
        goto oom;
788 789 790 791 792
      for (i = 1; i <= (argc-remaining_args); i++)
        {
          size_t len = strlen (argv[remaining_args+i-1])+1;
          args[i] = malloc (len);
          if (!args[i])
793 794 795 796 797
	    {
              while (i > 1)
                free (args[--i]);
              goto oom;
	    }
798 799 800 801 802 803 804 805 806 807 808
          strncpy (args[i], argv[remaining_args+i-1], len);
        }
      args[i] = NULL;

      strcpy (envvar, "DBUS_SESSION_BUS_ADDRESS=");
      strcat (envvar, bus_address);
      putenv (envvar);

      execvp (runprog, args);
      fprintf (stderr, "Couldn't exec %s: %s\n", runprog, strerror (errno));
      exit (1);
809 810 811 812
    }
   else
    {
      print_variables (bus_address, bus_pid, bus_wid, c_shell_syntax,
813
          bourne_shell_syntax, binary_syntax);
814 815 816 817 818 819 820 821 822
    }
  verbose ("dbus-launch exiting\n");

  fflush (stdout);
  fflush (stderr);
  close (1);
  close (2);
  exit (0);
oom:
823 824 825 826 827 828
  if (envvar)
    free (envvar);

  if (args)
    free (args);

829 830 831 832
  fprintf (stderr, "Out of memory!");
  exit (1);
}

833 834 835
#define READ_END  0
#define WRITE_END 1

836 837 838 839
int
main (int argc, char **argv)
{
  const char *prev_arg;
840 841 842
  const char *shname;
  const char *runprog = NULL;
  int remaining_args = 0;
843
  int exit_with_session;
844
  int binary_syntax = FALSE;
845 846 847
  int c_shell_syntax = FALSE;
  int bourne_shell_syntax = FALSE;
  int auto_shell_syntax = FALSE;
848
  int autolaunch = FALSE;
849
  int requires_arg = FALSE;
850 851
  int close_stderr = FALSE;
  int i;
852 853 854 855
  int ret;
  int bus_pid_to_launcher_pipe[2];
  int bus_pid_to_babysitter_pipe[2];
  int bus_address_to_launcher_pipe[2];
856
  char *config_file;
857
  
858
  exit_with_session = FALSE;
859
  config_file = NULL;
860 861 862 863 864 865
  
  prev_arg = NULL;
  i = 1;
  while (i < argc)
    {
      const char *arg = argv[i];
866
 
867 868 869
      if (strcmp (arg, "--help") == 0 ||
          strcmp (arg, "-h") == 0 ||
          strcmp (arg, "-?") == 0)
870 871 872 873
        usage (0);
      else if (strcmp (arg, "--auto-syntax") == 0)
        auto_shell_syntax = TRUE;
      else if (strcmp (arg, "-c") == 0 ||
874
               strcmp (arg, "--csh-syntax") == 0)
875 876
        c_shell_syntax = TRUE;
      else if (strcmp (arg, "-s") == 0 ||
877
               strcmp (arg, "--sh-syntax") == 0)
878
        bourne_shell_syntax = TRUE;
879
      else if (strcmp (arg, "--binary-syntax") == 0)
880
        binary_syntax = TRUE;
881 882 883 884
      else if (strcmp (arg, "--version") == 0)
        version ();
      else if (strcmp (arg, "--exit-with-session") == 0)
        exit_with_session = TRUE;
885 886
      else if (strcmp (arg, "--close-stderr") == 0)
        close_stderr = TRUE;
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
      else if (strstr (arg, "--autolaunch=") == arg)
        {
          const char *s;

          if (autolaunch)
            {
              fprintf (stderr, "--autolaunch given twice\n");
              exit (1);
            }
          
          autolaunch = TRUE;

          s = strchr (arg, '=');
          ++s;

          save_machine_uuid (s);
        }
      else if (prev_arg &&
               strcmp (prev_arg, "--autolaunch") == 0)
        {
          if (autolaunch)
            {
              fprintf (stderr, "--autolaunch given twice\n");
              exit (1);
            }
          
          autolaunch = TRUE;

          save_machine_uuid (arg);
916
	  requires_arg = FALSE;
917
        }
918
      else if (strcmp (arg, "--autolaunch") == 0)
919
	requires_arg = TRUE;
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
      else if (strstr (arg, "--config-file=") == arg)
        {
          const char *file;

          if (config_file != NULL)
            {
              fprintf (stderr, "--config-file given twice\n");
              exit (1);
            }
          
          file = strchr (arg, '=');
          ++file;

          config_file = xstrdup (file);
        }
      else if (prev_arg &&
               strcmp (prev_arg, "--config-file") == 0)
        {
          if (config_file != NULL)
            {
              fprintf (stderr, "--config-file given twice\n");
              exit (1);
            }

          config_file = xstrdup (arg);
945
	  requires_arg = FALSE;
946 947
        }
      else if (strcmp (arg, "--config-file") == 0)
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
	requires_arg = TRUE;
      else if (arg[0] == '-')
        {
          if (strcmp (arg, "--") != 0)
            {
              fprintf (stderr, "Option `%s' is unknown.\n", arg);
              exit (1);
            }
          else
            {
              runprog = argv[i+1];
              remaining_args = i+2;
              break;
            }
        }
963
      else
964 965 966 967 968
	{
	  runprog = arg;
	  remaining_args = i+1;
	  break;
	}
969 970 971 972 973
      
      prev_arg = arg;
      
      ++i;
    }
974 975 976 977 978
  if (requires_arg)
    {
      fprintf (stderr, "Option `%s' requires an argument.\n", prev_arg);
      exit (1);
    }
979

980 981 982 983 984 985 986 987 988 989 990 991
  if (auto_shell_syntax)
    {
      if ((shname = getenv ("SHELL")) != NULL)
       {
         if (!strncmp (shname + strlen (shname) - 3, "csh", 3))
           c_shell_syntax = TRUE;
         else
           bourne_shell_syntax = TRUE;
       }
      else
       bourne_shell_syntax = TRUE;
    }  
992

993 994 995 996
  if (exit_with_session)
    verbose ("--exit-with-session enabled\n");

  if (autolaunch)
997
    {      
998 999 1000 1001
#ifndef DBUS_BUILD_X11
      fprintf (stderr, "Autolaunch requested, but X11 support not compiled in.\n"
	       "Cannot continue.\n");
      exit (1);
1002 1003 1004 1005 1006
#else /* DBUS_BUILD_X11 */
#ifndef DBUS_ENABLE_X11_AUTOLAUNCH
      fprintf (stderr, "X11 autolaunch support disabled at compile time.\n");
      exit (1);
#else /* DBUS_ENABLE_X11_AUTOLAUNCH */
1007 1008 1009
      char *address;
      pid_t pid;
      long wid;
1010 1011 1012 1013 1014 1015
      
      if (get_machine_uuid () == NULL)
        {
          fprintf (stderr, "Machine UUID not provided as arg to --autolaunch\n");
          exit (1);
        }
1016 1017

      verbose ("Autolaunch enabled (using X11).\n");
1018
      if (!exit_with_session)
1019
	{
1020 1021
	  verbose ("--exit-with-session automatically enabled\n");
	  exit_with_session = TRUE;
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	}

      if (!x11_init ())
	{
	  fprintf (stderr, "Autolaunch error: X11 initialization failed.\n");
	  exit (1);
	}

      if (!x11_get_address (&address, &pid, &wid))
	{
	  fprintf (stderr, "Autolaunch error: X11 communication error.\n");
	  exit (1);
	}

      if (address != NULL)
1037
	{
1038
	  verbose ("dbus-daemon is already running. Returning existing parameters.\n");
1039 1040
	  pass_info (runprog, address, pid, wid, c_shell_syntax,
			   bourne_shell_syntax, binary_syntax, argc, argv, remaining_args);
1041 1042
	  exit (0);
	}
1043
#endif /* DBUS_ENABLE_X11_AUTOLAUNCH */
1044
    }
1045
  else if (read_machine_uuid_if_needed())
1046 1047
    {
      x11_init();
1048
#endif /* DBUS_BUILD_X11 */
1049
    }
1050

1051

1052
  if (pipe (bus_pid_to_launcher_pipe) < 0 ||
1053 1054
      pipe (bus_address_to_launcher_pipe) < 0 ||
      pipe (bus_pid_to_babysitter_pipe) < 0)
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
    {
      fprintf (stderr,
               "Failed to create pipe: %s\n",
               strerror (errno));
      exit (1);
    }

  ret = fork ();
  if (ret < 0)
    {
      fprintf (stderr, "Failed to fork: %s\n",
               strerror (errno));
      exit (1);
    }

  if (ret == 0)
    {
      /* Child */
#define MAX_FD_LEN 64
      char write_pid_fd_as_string[MAX_FD_LEN];
      char write_address_fd_as_string[MAX_FD_LEN];

1077
#ifdef DBUS_BUILD_X11
1078
      xdisplay = NULL;
1079
#endif
1080

1081 1082 1083
      if (close_stderr)
	do_close_stderr ();

1084
      verbose ("=== Babysitter's intermediate parent created\n");
1085

1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
      /* Fork once more to create babysitter */
      
      ret = fork ();
      if (ret < 0)
        {
          fprintf (stderr, "Failed to fork: %s\n",
                   strerror (errno));
          exit (1);
        }
      
      if (ret > 0)
        {
          /* In babysitter */
          verbose ("=== Babysitter's intermediate parent continues\n");
          
          close (bus_pid_to_launcher_pipe[READ_END]);
1102
	  close (bus_pid_to_launcher_pipe[WRITE_END]);
1103 1104 1105
          close (bus_address_to_launcher_pipe[READ_END]);
          close (bus_address_to_launcher_pipe[WRITE_END]);
          close (bus_pid_to_babysitter_pipe[WRITE_END]);
1106

1107 1108 1109 1110
          /* babysit() will fork *again*
           * and will also reap the pre-forked bus
           * daemon
           */
1111
          babysit (exit_with_session, ret,
1112
                   bus_pid_to_babysitter_pipe[READ_END]);
1113 1114 1115 1116 1117 1118
          exit (0);
        }

      verbose ("=== Bus exec process created\n");
      
      /* Now we are the bus process (well, almost;
Havoc Pennington's avatar
Havoc Pennington committed
1119
       * dbus-daemon itself forks again)
1120 1121 1122 1123
       */
      close (bus_pid_to_launcher_pipe[READ_END]);
      close (bus_address_to_launcher_pipe[READ_END]);
      close (bus_pid_to_babysitter_pipe[READ_END]);
1124
      close (bus_pid_to_babysitter_pipe[WRITE_END]);
1125 1126

      sprintf (write_pid_fd_as_string,
1127
               "%d", bus_pid_to_launcher_pipe[WRITE_END]);
1128 1129 1130 1131 1132

      sprintf (write_address_fd_as_string,
               "%d", bus_address_to_launcher_pipe[WRITE_END]);

      verbose ("Calling exec()\n");
1133
 
1134
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
      {
        const char *test_daemon;
        /* exec from testdir */
        if (getenv ("DBUS_USE_TEST_BINARY") != NULL &&
            (test_daemon = getenv ("DBUS_TEST_DAEMON")) != NULL)
          {
            if (config_file == NULL && getenv ("DBUS_TEST_DATA") != NULL)
              {
                config_file = concat2 (getenv ("DBUS_TEST_DATA"),
                    "/valid-config-files/session.conf");

                if (config_file == NULL)
                  {
                    fprintf (stderr, "Out of memory\n");
                    exit (1);
                  }
              }

            execl (test_daemon,
                   test_daemon,
                   "--fork",
                   "--print-pid", write_pid_fd_as_string,
                   "--print-address", write_address_fd_as_string,
                   config_file ? "--config-file" : "--session",
                   config_file, /* has to be last in this varargs list */
                   NULL);

            fprintf (stderr,
                     "Failed to execute test message bus daemon %s: %s.\n",
                     test_daemon, strerror (errno));
            exit (1);
          }
      }
1168
 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
1169

John (J5) Palmieri's avatar
John (J5) Palmieri committed
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
      execl (DBUS_DAEMONDIR"/dbus-daemon",
             DBUS_DAEMONDIR"/dbus-daemon",
             "--fork",
             "--print-pid", write_pid_fd_as_string,
             "--print-address", write_address_fd_as_string,
             config_file ? "--config-file" : "--session",
             config_file, /* has to be last in this varargs list */
             NULL);

      fprintf (stderr,
               "Failed to execute message bus daemon %s: %s.  Will try again without full path.\n",
               DBUS_DAEMONDIR"/dbus-daemon", strerror (errno));
1182
      
John (J5) Palmieri's avatar
John (J5) Palmieri committed
1183 1184 1185 1186 1187 1188
      /*
       * If it failed, try running without full PATH.  Note this is needed
       * because the build process builds the run-with-tmp-session-bus.conf
       * file and the dbus-daemon will not be in the install location during
       * build time.
       */
Havoc Pennington's avatar
Havoc Pennington committed
1189 1190
      execlp ("dbus-daemon",
              "dbus-daemon",
1191 1192 1193
              "--fork",
              "--print-pid", write_pid_fd_as_string,
              "--print-address", write_address_fd_as_string,
1194 1195
              config_file ? "--config-file" : "--session",
              config_file, /* has to be last in this varargs list */
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
              NULL);

      fprintf (stderr,
               "Failed to execute message bus daemon: %s\n",
               strerror (errno));
      exit (1);
    }
  else
    {
      /* Parent */
1206
#define MAX_PID_LEN 64
1207 1208
      pid_t bus_pid;  
      char bus_address[MAX_ADDR_LEN];
1209 1210 1211 1212
      char buf[MAX_PID_LEN];
      char *end;
      long wid = 0;
      long val;
1213 1214 1215 1216 1217

      verbose ("=== Parent dbus-launch continues\n");
      
      close (bus_pid_to_launcher_pipe[WRITE_END]);
      close (bus_address_to_launcher_pipe[WRITE_END]);
1218
      close (bus_pid_to_babysitter_pipe[READ_END]);
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252

      verbose ("Waiting for babysitter's intermediate parent\n");
      
      /* Immediately reap parent of babysitter
       * (which was created just for us to reap)
       */
      if (do_waitpid (ret) < 0)
        {
          fprintf (stderr, "Failed to waitpid() for babysitter intermediate process: %s\n",
                   strerror (errno));
          exit (1);
        }

      verbose ("Reading address from bus\n");
      
      /* Read the pipe data, print, and exit */
      switch (read_line (bus_address_to_launcher_pipe[READ_END],
                         bus_address, MAX_ADDR_LEN))
        {
        case READ_STATUS_OK:
          break;
        case READ_STATUS_EOF:
          fprintf (stderr, "EOF in dbus-launch reading address from bus daemon\n");
          exit (1);
          break;
        case READ_STATUS_ERROR:
          fprintf (stderr, "Error in dbus-launch reading address from bus daemon: %s\n",
                   strerror (errno));
          exit (1);
          break;
        }
        
      close (bus_address_to_launcher_pipe[READ_END]);

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
      verbose ("Reading PID from daemon\n");
      /* Now read data */
      switch (read_line (bus_pid_to_launcher_pipe[READ_END], buf, MAX_PID_LEN))
	{
	case READ_STATUS_OK:
	  break;
	case READ_STATUS_EOF:
	  fprintf (stderr, "EOF reading PID from bus daemon\n");
	  exit (1);
	  break;
	case READ_STATUS_ERROR:
	  fprintf (stderr, "Error reading PID from bus daemon: %s\n",
		   strerror (errno));
	  exit (1);
	  break;
	}

      end = NULL;
      val = strtol (buf, &end, 0);
      if (buf == end || end == NULL)
	{
	  fprintf (stderr, "Failed to parse bus PID \"%s\": %s\n",
		   buf, strerror (errno));
	  exit (1);
	}

      bus_pid = val;
1280

1281 1282 1283 1284
      /* Have to initialize bus_pid_to_kill ASAP, so that the
         X error callback can kill it if an error happens. */
      bus_pid_to_kill = bus_pid;

1285
      close (bus_pid_to_launcher_pipe[READ_END]);
1286

1287
#ifdef DBUS_ENABLE_X11_AUTOLAUNCH
1288
      if (xdisplay != NULL)
1289
        {
1290 1291
          int ret2;

1292
          verbose("Saving x11 address\n");
1293
          ret2 = x11_save_address (bus_address, bus_pid, &wid);
1294 1295
          /* Only get an existing dbus session when autolaunching */
          if (autolaunch)
1296
            {
1297
              if (ret2 == 0)
1298
                {
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
                  char *address = NULL;
                  /* another window got added. Return its address */
                  if (x11_get_address (&address, &bus_pid, &wid)
                       && address != NULL)
                    {
                      verbose ("dbus-daemon is already running. Returning existing parameters.\n");
                      /* Kill the old bus */
                      kill_bus();
                      pass_info (runprog, address, bus_pid, wid,
                         c_shell_syntax, bourne_shell_syntax, binary_syntax,
                         argc, argv, remaining_args);
                    }
                  }
              if (ret2 < 0)
                {
                  fprintf (stderr, "Error saving bus information.\n");
                  bus_pid_to_kill = bus_pid;
                  kill_bus_and_exit (1);
1317 1318 1319
                }
            }
        }
1320 1321 1322 1323 1324 1325
#endif

      /* Forward the pid to the babysitter */
      write_pid (bus_pid_to_babysitter_pipe[WRITE_END], bus_pid);
      close (bus_pid_to_babysitter_pipe[WRITE_END]);

1326 1327 1328
       pass_info (runprog, bus_address, bus_pid, wid, c_shell_syntax,
              bourne_shell_syntax, binary_syntax, argc, argv, remaining_args);
    }
1329

1330 1331
  return 0;
}