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 (at) 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 goto oom; 705 706 args[0] = xstrdup (runprog); 707 if (!args[0]) 708 goto oom; 709 for (i = 1; i <= (argc-remaining_args); i++) 710 { 711 size_t len = strlen (argv[remaining_args+i-1])+1; 712 args[i] = malloc (len); 713 if (!args[i]) 714 goto oom; 715 strncpy (args[i], argv[remaining_args+i-1], len); 716 } 717 args[i] = NULL; 718 719 strcpy (envvar, "DBUS_SESSION_BUS_ADDRESS="); 720 strcat (envvar, bus_address); 721 putenv (envvar); 722 723 execvp (runprog, args); 724 fprintf (stderr, "Couldn't exec %s: %s\n", runprog, strerror (errno)); 725 exit (1); 726 } 727 else 728 { 729 print_variables (bus_address, bus_pid, bus_wid, c_shell_syntax, 730 bourne_shell_syntax, binary_syntax); 731 } 732 verbose ("dbus-launch exiting\n"); 733 734 fflush (stdout); 735 fflush (stderr); 736 close (1); 737 close (2); 738 exit (0); 739 oom: 740 fprintf (stderr, "Out of memory!"); 741 exit (1); 742 } 743 744 #define READ_END 0 745 #define WRITE_END 1 746 747 int 748 main (int argc, char **argv) 749 { 750 const char *prev_arg; 751 const char *shname; 752 const char *runprog = NULL; 753 int remaining_args = 0; 754 int exit_with_session; 755 int binary_syntax = FALSE; 756 int c_shell_syntax = FALSE; 757 int bourne_shell_syntax = FALSE; 758 int auto_shell_syntax = FALSE; 759 int autolaunch = FALSE; 760 int requires_arg = FALSE; 761 int close_stderr = FALSE; 762 int i; 763 int ret; 764 int bus_pid_to_launcher_pipe[2]; 765 int bus_pid_to_babysitter_pipe[2]; 766 int bus_address_to_launcher_pipe[2]; 767 char *config_file; 768 769 exit_with_session = FALSE; 770 config_file = NULL; 771 772 prev_arg = NULL; 773 i = 1; 774 while (i < argc) 775 { 776 const char *arg = argv[i]; 777 778 if (strcmp (arg, "--help") == 0 || 779 strcmp (arg, "-h") == 0 || 780 strcmp (arg, "-?") == 0) 781 usage (0); 782 else if (strcmp (arg, "--auto-syntax") == 0) 783 auto_shell_syntax = TRUE; 784 else if (strcmp (arg, "-c") == 0 || 785 strcmp (arg, "--csh-syntax") == 0) 786 c_shell_syntax = TRUE; 787 else if (strcmp (arg, "-s") == 0 || 788 strcmp (arg, "--sh-syntax") == 0) 789 bourne_shell_syntax = TRUE; 790 else if (strcmp (arg, "--binary-syntax") == 0) 791 binary_syntax = TRUE; 792 else if (strcmp (arg, "--version") == 0) 793 version (); 794 else if (strcmp (arg, "--exit-with-session") == 0) 795 exit_with_session = TRUE; 796 else if (strcmp (arg, "--close-stderr") == 0) 797 close_stderr = TRUE; 798 else if (strstr (arg, "--autolaunch=") == arg) 799 { 800 const char *s; 801 802 if (autolaunch) 803 { 804 fprintf (stderr, "--autolaunch given twice\n"); 805 exit (1); 806 } 807 808 autolaunch = TRUE; 809 810 s = strchr (arg, '='); 811 ++s; 812 813 save_machine_uuid (s); 814 } 815 else if (prev_arg && 816 strcmp (prev_arg, "--autolaunch") == 0) 817 { 818 if (autolaunch) 819 { 820 fprintf (stderr, "--autolaunch given twice\n"); 821 exit (1); 822 } 823 824 autolaunch = TRUE; 825 826 save_machine_uuid (arg); 827 requires_arg = FALSE; 828 } 829 else if (strcmp (arg, "--autolaunch") == 0) 830 requires_arg = TRUE; 831 else if (strstr (arg, "--config-file=") == arg) 832 { 833 const char *file; 834 835 if (config_file != NULL) 836 { 837 fprintf (stderr, "--config-file given twice\n"); 838 exit (1); 839 } 840 841 file = strchr (arg, '='); 842 ++file; 843 844 config_file = xstrdup (file); 845 } 846 else if (prev_arg && 847 strcmp (prev_arg, "--config-file") == 0) 848 { 849 if (config_file != NULL) 850 { 851 fprintf (stderr, "--config-file given twice\n"); 852 exit (1); 853 } 854 855 config_file = xstrdup (arg); 856 requires_arg = FALSE; 857 } 858 else if (strcmp (arg, "--config-file") == 0) 859 requires_arg = TRUE; 860 else if (arg[0] == '-') 861 { 862 if (strcmp (arg, "--") != 0) 863 { 864 fprintf (stderr, "Option `%s' is unknown.\n", arg); 865 exit (1); 866 } 867 else 868 { 869 runprog = argv[i+1]; 870 remaining_args = i+2; 871 break; 872 } 873 } 874 else 875 { 876 runprog = arg; 877 remaining_args = i+1; 878 break; 879 } 880 881 prev_arg = arg; 882 883 ++i; 884 } 885 if (requires_arg) 886 { 887 fprintf (stderr, "Option `%s' requires an argument.\n", prev_arg); 888 exit (1); 889 } 890 891 if (auto_shell_syntax) 892 { 893 if ((shname = getenv ("SHELL")) != NULL) 894 { 895 if (!strncmp (shname + strlen (shname) - 3, "csh", 3)) 896 c_shell_syntax = TRUE; 897 else 898 bourne_shell_syntax = TRUE; 899 } 900 else 901 bourne_shell_syntax = TRUE; 902 } 903 904 if (exit_with_session) 905 verbose ("--exit-with-session enabled\n"); 906 907 if (autolaunch) 908 { 909 #ifndef DBUS_BUILD_X11 910 fprintf (stderr, "Autolaunch requested, but X11 support not compiled in.\n" 911 "Cannot continue.\n"); 912 exit (1); 913 #else 914 char *address; 915 pid_t pid; 916 long wid; 917 918 if (get_machine_uuid () == NULL) 919 { 920 fprintf (stderr, "Machine UUID not provided as arg to --autolaunch\n"); 921 exit (1); 922 } 923 924 verbose ("Autolaunch enabled (using X11).\n"); 925 if (!exit_with_session) 926 { 927 verbose ("--exit-with-session automatically enabled\n"); 928 exit_with_session = TRUE; 929 } 930 931 if (!x11_init ()) 932 { 933 fprintf (stderr, "Autolaunch error: X11 initialization failed.\n"); 934 exit (1); 935 } 936 937 if (!x11_get_address (&address, &pid, &wid)) 938 { 939 fprintf (stderr, "Autolaunch error: X11 communication error.\n"); 940 exit (1); 941 } 942 943 if (address != NULL) 944 { 945 verbose ("dbus-daemon is already running. Returning existing parameters.\n"); 946 pass_info (runprog, address, pid, wid, c_shell_syntax, 947 bourne_shell_syntax, binary_syntax, argc, argv, remaining_args); 948 exit (0); 949 } 950 } 951 else if (read_machine_uuid_if_needed()) 952 { 953 x11_init(); 954 #endif 955 } 956 957 958 if (pipe (bus_pid_to_launcher_pipe) < 0 || 959 pipe (bus_address_to_launcher_pipe) < 0 || 960 pipe (bus_pid_to_babysitter_pipe) < 0) 961 { 962 fprintf (stderr, 963 "Failed to create pipe: %s\n", 964 strerror (errno)); 965 exit (1); 966 } 967 968 ret = fork (); 969 if (ret < 0) 970 { 971 fprintf (stderr, "Failed to fork: %s\n", 972 strerror (errno)); 973 exit (1); 974 } 975 976 if (ret == 0) 977 { 978 /* Child */ 979 #define MAX_FD_LEN 64 980 char write_pid_fd_as_string[MAX_FD_LEN]; 981 char write_address_fd_as_string[MAX_FD_LEN]; 982 983 #ifdef DBUS_BUILD_X11 984 xdisplay = NULL; 985 #endif 986 987 if (close_stderr) 988 do_close_stderr (); 989 990 verbose ("=== Babysitter's intermediate parent created\n"); 991 992 /* Fork once more to create babysitter */ 993 994 ret = fork (); 995 if (ret < 0) 996 { 997 fprintf (stderr, "Failed to fork: %s\n", 998 strerror (errno)); 999 exit (1); 1000 } 1001 1002 if (ret > 0) 1003 { 1004 /* In babysitter */ 1005 verbose ("=== Babysitter's intermediate parent continues\n"); 1006 1007 close (bus_pid_to_launcher_pipe[READ_END]); 1008 close (bus_pid_to_launcher_pipe[WRITE_END]); 1009 close (bus_address_to_launcher_pipe[READ_END]); 1010 close (bus_address_to_launcher_pipe[WRITE_END]); 1011 close (bus_pid_to_babysitter_pipe[WRITE_END]); 1012 1013 /* babysit() will fork *again* 1014 * and will also reap the pre-forked bus 1015 * daemon 1016 */ 1017 babysit (exit_with_session, ret, 1018 bus_pid_to_babysitter_pipe[READ_END]); 1019 exit (0); 1020 } 1021 1022 verbose ("=== Bus exec process created\n"); 1023 1024 /* Now we are the bus process (well, almost; 1025 * dbus-daemon itself forks again) 1026 */ 1027 close (bus_pid_to_launcher_pipe[READ_END]); 1028 close (bus_address_to_launcher_pipe[READ_END]); 1029 close (bus_pid_to_babysitter_pipe[READ_END]); 1030 close (bus_pid_to_babysitter_pipe[WRITE_END]); 1031 1032 sprintf (write_pid_fd_as_string, 1033 "%d", bus_pid_to_launcher_pipe[WRITE_END]); 1034 1035 sprintf (write_address_fd_as_string, 1036 "%d", bus_address_to_launcher_pipe[WRITE_END]); 1037 1038 verbose ("Calling exec()\n"); 1039 1040 #ifdef DBUS_BUILD_TESTS 1041 /* exec from testdir */ 1042 if (getenv("DBUS_USE_TEST_BINARY") != NULL) 1043 { 1044 execl (TEST_BUS_BINARY, 1045 TEST_BUS_BINARY, 1046 "--fork", 1047 "--print-pid", write_pid_fd_as_string, 1048 "--print-address", write_address_fd_as_string, 1049 config_file ? "--config-file" : "--session", 1050 config_file, /* has to be last in this varargs list */ 1051 NULL); 1052 1053 fprintf (stderr, 1054 "Failed to execute test message bus daemon %s: %s. Will try again with the system path.\n", 1055 TEST_BUS_BINARY, strerror (errno)); 1056 } 1057 #endif /* DBUS_BUILD_TESTS */ 1058 1059 execl (DBUS_DAEMONDIR"/dbus-daemon", 1060 DBUS_DAEMONDIR"/dbus-daemon", 1061 "--fork", 1062 "--print-pid", write_pid_fd_as_string, 1063 "--print-address", write_address_fd_as_string, 1064 config_file ? "--config-file" : "--session", 1065 config_file, /* has to be last in this varargs list */ 1066 NULL); 1067 1068 fprintf (stderr, 1069 "Failed to execute message bus daemon %s: %s. Will try again without full path.\n", 1070 DBUS_DAEMONDIR"/dbus-daemon", strerror (errno)); 1071 1072 /* 1073 * If it failed, try running without full PATH. Note this is needed 1074 * because the build process builds the run-with-tmp-session-bus.conf 1075 * file and the dbus-daemon will not be in the install location during 1076 * build time. 1077 */ 1078 execlp ("dbus-daemon", 1079 "dbus-daemon", 1080 "--fork", 1081 "--print-pid", write_pid_fd_as_string, 1082 "--print-address", write_address_fd_as_string, 1083 config_file ? "--config-file" : "--session", 1084 config_file, /* has to be last in this varargs list */ 1085 NULL); 1086 1087 fprintf (stderr, 1088 "Failed to execute message bus daemon: %s\n", 1089 strerror (errno)); 1090 exit (1); 1091 } 1092 else 1093 { 1094 /* Parent */ 1095 #define MAX_PID_LEN 64 1096 pid_t bus_pid; 1097 char bus_address[MAX_ADDR_LEN]; 1098 char buf[MAX_PID_LEN]; 1099 char *end; 1100 long wid = 0; 1101 long val; 1102 int ret2; 1103 1104 verbose ("=== Parent dbus-launch continues\n"); 1105 1106 close (bus_pid_to_launcher_pipe[WRITE_END]); 1107 close (bus_address_to_launcher_pipe[WRITE_END]); 1108 close (bus_pid_to_babysitter_pipe[READ_END]); 1109 1110 verbose ("Waiting for babysitter's intermediate parent\n"); 1111 1112 /* Immediately reap parent of babysitter 1113 * (which was created just for us to reap) 1114 */ 1115 if (do_waitpid (ret) < 0) 1116 { 1117 fprintf (stderr, "Failed to waitpid() for babysitter intermediate process: %s\n", 1118 strerror (errno)); 1119 exit (1); 1120 } 1121 1122 verbose ("Reading address from bus\n"); 1123 1124 /* Read the pipe data, print, and exit */ 1125 switch (read_line (bus_address_to_launcher_pipe[READ_END], 1126 bus_address, MAX_ADDR_LEN)) 1127 { 1128 case READ_STATUS_OK: 1129 break; 1130 case READ_STATUS_EOF: 1131 fprintf (stderr, "EOF in dbus-launch reading address from bus daemon\n"); 1132 exit (1); 1133 break; 1134 case READ_STATUS_ERROR: 1135 fprintf (stderr, "Error in dbus-launch reading address from bus daemon: %s\n", 1136 strerror (errno)); 1137 exit (1); 1138 break; 1139 } 1140 1141 close (bus_address_to_launcher_pipe[READ_END]); 1142 1143 verbose ("Reading PID from daemon\n"); 1144 /* Now read data */ 1145 switch (read_line (bus_pid_to_launcher_pipe[READ_END], buf, MAX_PID_LEN)) 1146 { 1147 case READ_STATUS_OK: 1148 break; 1149 case READ_STATUS_EOF: 1150 fprintf (stderr, "EOF reading PID from bus daemon\n"); 1151 exit (1); 1152 break; 1153 case READ_STATUS_ERROR: 1154 fprintf (stderr, "Error reading PID from bus daemon: %s\n", 1155 strerror (errno)); 1156 exit (1); 1157 break; 1158 } 1159 1160 end = NULL; 1161 val = strtol (buf, &end, 0); 1162 if (buf == end || end == NULL) 1163 { 1164 fprintf (stderr, "Failed to parse bus PID \"%s\": %s\n", 1165 buf, strerror (errno)); 1166 exit (1); 1167 } 1168 1169 bus_pid = val; 1170 1171 close (bus_pid_to_launcher_pipe[READ_END]); 1172 1173 #ifdef DBUS_BUILD_X11 1174 if (xdisplay != NULL) 1175 { 1176 verbose("Saving x11 address\n"); 1177 ret2 = x11_save_address (bus_address, bus_pid, &wid); 1178 /* Only get an existing dbus session when autolaunching */ 1179 if (autolaunch) 1180 { 1181 if (ret2 == 0) 1182 { 1183 char *address = NULL; 1184 /* another window got added. Return its address */ 1185 bus_pid_to_kill = bus_pid; 1186 if (x11_get_address (&address, &bus_pid, &wid) 1187 && address != NULL) 1188 { 1189 verbose ("dbus-daemon is already running. Returning existing parameters.\n"); 1190 /* Kill the old bus */ 1191 kill_bus(); 1192 pass_info (runprog, address, bus_pid, wid, 1193 c_shell_syntax, bourne_shell_syntax, binary_syntax, 1194 argc, argv, remaining_args); 1195 } 1196 } 1197 if (ret2 < 0) 1198 { 1199 fprintf (stderr, "Error saving bus information.\n"); 1200 bus_pid_to_kill = bus_pid; 1201 kill_bus_and_exit (1); 1202 } 1203 } 1204 } 1205 #endif 1206 1207 /* Forward the pid to the babysitter */ 1208 write_pid (bus_pid_to_babysitter_pipe[WRITE_END], bus_pid); 1209 close (bus_pid_to_babysitter_pipe[WRITE_END]); 1210 1211 pass_info (runprog, bus_address, bus_pid, wid, c_shell_syntax, 1212 bourne_shell_syntax, binary_syntax, argc, argv, remaining_args); 1213 } 1214 1215 return 0; 1216 } 1217
