1 /***************************************************************************
   2  * CVSID: $Id$
   3  *
   4  * hald.c : main startup for HAL daemon
   5  *
   6  * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
   7  * Copyright (C) 2005 Danny Kukawka, <danny.kukawka@web.de>
   8  *
   9  * Licensed under the Academic Free License version 2.1
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  *
  25  **************************************************************************/
  26 
  27 #ifdef HAVE_CONFIG_H
  28 #  include <config.h>
  29 #endif
  30 
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <getopt.h>
  36 #include <pwd.h>
  37 #include <stdint.h>
  38 #include <sys/stat.h>
  39 #include <fcntl.h>
  40 #include <errno.h>
  41 #include <signal.h>
  42 #include <grp.h>
  43 #include <syslog.h>
  44 
  45 #include <dbus/dbus.h>
  46 #include <dbus/dbus-glib.h>
  47 #include <dbus/dbus-glib-lowlevel.h>
  48 
  49 /*#include "master_slave.h"*/
  50 
  51 #include "logger.h"
  52 #include "hald.h"
  53 #include "device_store.h"
  54 #include "device_info.h"
  55 #include "osspec.h"
  56 #include "hald_dbus.h"
  57 #include "util.h"
  58 #include "hald_runner.h"
  59 #include "util_helper.h"
  60 
  61 static void delete_pid(void)
  62 {
  63         unlink(HALD_PID_FILE);
  64 }
  65 
  66 /**
  67  * @defgroup HalDaemon HAL daemon
  68  * @brief The HAL daemon manages persistent device objects available through
  69  *        a D-BUS network API
  70  */
  71 
  72 static HalDeviceStore *global_device_list = NULL;
  73 
  74 static HalDeviceStore *temporary_device_list = NULL;
  75 
  76 
  77 static void
  78 addon_terminated (HalDevice *device, guint32 exit_type, 
  79                   gint return_code, gchar **error,
  80                   gpointer data1, gpointer data2)
  81 {
  82         HAL_INFO (("in addon_terminated for udi=%s", device->udi));
  83 
  84         /* TODO: log to syslog - addons shouldn't just terminate, this is a bug with the addon */
  85 
  86         /* however, the world can stop, mark this addon as ready 
  87          * (TODO: potential bug if the addon crashed after calling libhal_device_addon_is_ready())
  88          */
  89         if (hal_device_inc_num_ready_addons (device)) {
  90                 if (hal_device_are_all_addons_ready (device)) {
  91                         manager_send_signal_device_added (device);
  92                 }
  93         }
  94 }
  95 
  96 
  97 
  98 
  99 static void
 100 gdl_store_changed (HalDeviceStore *store, HalDevice *device,
 101                    gboolean is_added, gpointer user_data)
 102 {
 103         if (is_added) {
 104                 GSList *addons;
 105 
 106                 HAL_INFO (("Added device to GDL; udi=%s", hal_device_get_udi(device)));
 107 
 108                 if ((addons = hal_device_property_get_strlist (device, "info.addons")) != NULL) {
 109                         GSList *i;
 110 
 111                         for (i = addons; i != NULL; i = g_slist_next (i)) {
 112                                 const gchar *command_line;
 113                                 gchar *extra_env[2] = {"HALD_ACTION=addon", NULL};
 114 
 115                                 command_line = (const gchar *) i->data;
 116                                 if (hald_runner_start(device, command_line, extra_env, addon_terminated, NULL, NULL)) {
 117                                         HAL_INFO (("Started addon %s for udi %s", 
 118                                                    command_line, hal_device_get_udi(device)));
 119                                         hal_device_inc_num_addons (device);
 120                                 } else {
 121                                         HAL_ERROR (("Cannot start addon %s for udi %s", 
 122                                                     command_line, hal_device_get_udi(device)));
 123                                 }
 124                         }
 125                 }
 126         } else {
 127                 HAL_INFO (("Removed device from GDL; udi=%s", hal_device_get_udi(device)));
 128                 hald_runner_kill_device(device);
 129         }
 130 
 131         /*hal_device_print (device);*/
 132 
 133         if (is_added) {
 134                 if (hal_device_are_all_addons_ready (device)) {
 135                         manager_send_signal_device_added (device);
 136                 }
 137         } else {
 138                 if (hal_device_are_all_addons_ready (device)) {
 139                         manager_send_signal_device_removed (device);
 140                 }
 141         }
 142 }
 143 
 144 static void
 145 gdl_property_changed (HalDeviceStore *store, HalDevice *device,
 146                       const char *key, gboolean added, gboolean removed,
 147                       gpointer user_data)
 148 {
 149         if (hal_device_are_all_addons_ready (device)) {
 150                 device_send_signal_property_modified (device, key, removed, added);
 151         }
 152 
 153         /* only execute the callouts if the property _changed_ */
 154         if (added == FALSE && removed == FALSE)
 155                 /*hal_callout_property (device, key)*/;
 156 }
 157 
 158 static void
 159 gdl_capability_added (HalDeviceStore *store, HalDevice *device,
 160                       const char *capability, gpointer user_data)
 161 {
 162         if (hal_device_are_all_addons_ready (device)) {
 163                 manager_send_signal_new_capability (device, capability);
 164         }
 165         /*hal_callout_capability (device, capability, TRUE)*/;
 166 }
 167 
 168 HalDeviceStore *
 169 hald_get_gdl (void)
 170 {
 171         if (global_device_list == NULL) {
 172                 global_device_list = hal_device_store_new ();
 173                 
 174                 g_signal_connect (global_device_list,
 175                                   "store_changed",
 176                                   G_CALLBACK (gdl_store_changed), NULL);
 177                 g_signal_connect (global_device_list,
 178                                   "device_property_changed",
 179                                   G_CALLBACK (gdl_property_changed), NULL);
 180                 g_signal_connect (global_device_list,
 181                                   "device_capability_added",
 182                                   G_CALLBACK (gdl_capability_added), NULL);
 183         }
 184 
 185         return global_device_list;
 186 }
 187 
 188 HalDeviceStore *
 189 hald_get_tdl (void)
 190 {
 191         if (temporary_device_list == NULL) {
 192                 temporary_device_list = hal_device_store_new ();
 193                 
 194         }
 195 
 196         return temporary_device_list;
 197 }
 198 
 199 /**
 200  * @defgroup MainDaemon Basic functions
 201  * @ingroup HalDaemon
 202  * @brief Basic functions in the HAL daemon
 203  * @{
 204  */
 205 
 206 /** Print out program usage.
 207  *
 208  */
 209 static void
 210 usage ()
 211 {
 212         fprintf (stderr, "\n" "usage : hald [--daemon=yes|no] [--verbose=yes|no] [--help]\n");
 213         fprintf (stderr,
 214                  "\n"
 215                  "        --daemon=yes|no      Become a daemon\n"
 216                  "        --verbose=yes|no     Print out debug (overrides HALD_VERBOSE)\n"
 217                  "        --use-syslog         Print out debug messages to syslog instead of stderr.\n"
 218                  "                             Use this option to get debug messages if HAL runs as\n"
 219                  "                             daemon.\n"
 220                  "        --help               Show this information and exit\n"
 221                  "        --version            Output version information and exit"
 222                  "\n"
 223                  "The HAL daemon detects devices present in the system and provides the\n"
 224                  "org.freedesktop.Hal service through the system-wide message bus provided\n"
 225                  "by D-BUS.\n"
 226                  "\n"
 227                  "For more information visit http://freedesktop.org/Software/hal\n"
 228                  "\n");
 229 }
 230 
 231 /** If #TRUE, we will daemonize */
 232 static dbus_bool_t opt_become_daemon = TRUE;
 233 
 234 /** If #TRUE, we will spew out debug */
 235 dbus_bool_t hald_is_verbose = FALSE;
 236 dbus_bool_t hald_use_syslog = FALSE;
 237 
 238 static int sigterm_unix_signal_pipe_fds[2];
 239 static GIOChannel *sigterm_iochn;
 240 
 241 static void 
 242 handle_sigterm (int value)
 243 {
 244         ssize_t written;
 245         static char marker[1] = {'S'};
 246 
 247         /* write a 'S' character to the other end to tell about
 248          * the signal. Note that 'the other end' is a GIOChannel thingy
 249          * that is only called from the mainloop - thus this is how we
 250          * defer this since UNIX signal handlers are evil
 251          *
 252          * Oh, and write(2) is indeed reentrant */
 253         written = write (sigterm_unix_signal_pipe_fds[1], marker, 1);
 254 }
 255 
 256 static gboolean
 257 sigterm_iochn_data (GIOChannel *source, 
 258                     GIOCondition condition, 
 259                     gpointer user_data)
 260 {
 261         GError *err = NULL;
 262         gchar data[1];
 263         gsize bytes_read;
 264 
 265         /* Empty the pipe */
 266         if (G_IO_STATUS_NORMAL != 
 267             g_io_channel_read_chars (source, data, 1, &bytes_read, &err)) {
 268                 HAL_ERROR (("Error emptying sigterm pipe: %s",
 269                                    err->message));
 270                 g_error_free (err);
 271                 goto out;
 272         }
 273 
 274         HAL_INFO (("Caught SIGTERM, initiating shutdown"));
 275         hald_runner_kill_all();
 276         exit (0);
 277 
 278 out:
 279         return TRUE;
 280 }
 281 
 282 
 283 /** This is set to #TRUE if we are probing and #FALSE otherwise */
 284 dbus_bool_t hald_is_initialising;
 285 
 286 static int startup_daemonize_pipe[2];
 287 
 288 
 289 /*--------------------------------------------------------------------------------------------------*/
 290 
 291 static gboolean child_died = FALSE;
 292 
 293 static void 
 294 handle_sigchld (int value)
 295 {
 296         child_died = TRUE;
 297 }
 298 
 299 static int 
 300 parent_wait_for_child (int child_fd, pid_t child_pid)
 301 {
 302         fd_set rfds;
 303         fd_set efds;
 304         struct timeval tv;
 305         int retval;
 306         int ret;
 307 
 308         signal(SIGCHLD, handle_sigchld);
 309 
 310         /* wait for either
 311          *
 312          * o Child writes something to the child_fd; means that device
 313          *   probing is completed and the parent should exit with success
 314          *
 315          * o Child is killed (segfault etc.); means that parent should exit
 316          *   with failure
 317          *
 318          * o Timeout; means that we should kill the child and exit with
 319          *   failure
 320          *
 321          */
 322 
 323         FD_ZERO(&rfds);
 324         FD_SET(child_fd, &rfds);
 325         FD_ZERO(&efds);
 326         FD_SET(child_fd, &efds);
 327         /* Wait up to 250 seconds for device probing */
 328         tv.tv_sec = 250;
 329         tv.tv_usec = 0;
 330 
 331         retval = select (child_fd + 1, &rfds, NULL, &efds, &tv);
 332 
 333         if (child_died) {
 334                 /* written from handle_sigchld */
 335                 ret = 1;
 336                 goto out;
 337         }
 338 
 339         if (retval > 0) {
 340                 /* means child wrote to socket or closed it; all good */
 341                 ret = 0;
 342                 goto out;
 343         }
 344 
 345         /* assume timeout; kill child */
 346         kill (child_pid, SIGTERM);
 347         ret = 2;
 348 
 349 out:
 350         return ret;
 351 }
 352 
 353 /*--------------------------------------------------------------------------------------------------*/
 354 
 355 /** Entry point for HAL daemon
 356  *
 357  *  @param  argc                Number of arguments
 358  *  @param  argv                Array of arguments
 359  *  @return                     Exit code
 360  */
 361 int
 362 main (int argc, char *argv[])
 363 {
 364         GMainLoop *loop;
 365         guint sigterm_iochn_listener_source_id;
 366         char *path;
 367         char newpath[512];
 368 
 369         openlog ("hald", LOG_PID, LOG_DAEMON);
 370 #if !GLIB_CHECK_VERSION(2,35,0)
 371         g_type_init ();
 372 #endif
 373         if (getenv ("HALD_VERBOSE"))
 374                 hald_is_verbose = TRUE;
 375         else
 376                 hald_is_verbose = FALSE;
 377 
 378         /* our helpers are installed into libexec, so adjust out $PATH
 379          * to include this at the end (since we want to overide in
 380          * run-hald.sh and friends)
 381          */
 382         path = getenv ("PATH");
 383         if (path != NULL) {
 384                 g_strlcpy (newpath, path, sizeof (newpath));
 385                 g_strlcat (newpath, ":", sizeof (newpath));
 386         } else {
 387                 /* No PATH was set */
 388                 newpath[0] = '\0';
 389         } 
 390 
 391         g_strlcat (newpath, PACKAGE_LIBEXEC_DIR, sizeof (newpath));
 392         g_strlcat (newpath, ":", sizeof (newpath));
 393         g_strlcat (newpath, PACKAGE_SCRIPT_DIR, sizeof (newpath));
 394 
 395         setenv ("PATH", newpath, TRUE);
 396 
 397         while (1) {
 398                 int c;
 399                 int option_index = 0;
 400                 const char *opt;
 401                 static struct option long_options[] = {
 402                         {"daemon", 1, NULL, 0},
 403                         {"verbose", 1, NULL, 0},
 404                         {"use-syslog", 0, NULL, 0},
 405                         {"help", 0, NULL, 0},
 406                         {"version", 0, NULL, 0},
 407                         {NULL, 0, NULL, 0}
 408                 };
 409 
 410                 c = getopt_long (argc, argv, "",
 411                                  long_options, &option_index);
 412                 if (c == -1)
 413                         break;
 414 
 415                 switch (c) {
 416                 case 0:
 417                         opt = long_options[option_index].name;
 418 
 419                         if (strcmp (opt, "help") == 0) {
 420                                 usage ();
 421                                 return 0;
 422                         } else if (strcmp (opt, "version") == 0) {
 423                                 fprintf (stderr, "HAL package version: " PACKAGE_VERSION "\n");
 424                                 return 0;
 425                         } else if (strcmp (opt, "daemon") == 0) {
 426                                 if (strcmp ("yes", optarg) == 0) {
 427                                         opt_become_daemon = TRUE;
 428                                 } else if (strcmp ("no", optarg) == 0) {
 429                                         opt_become_daemon = FALSE;
 430                                 } else {
 431                                         usage ();
 432                                         return 1;
 433                                 }
 434                         } else if (strcmp (opt, "verbose") == 0) {
 435                                 if (strcmp ("yes", optarg) == 0) {
 436                                         hald_is_verbose = TRUE;
 437                                 } else if (strcmp ("no", optarg) == 0) {
 438                                         hald_is_verbose = FALSE;
 439                                 } else {
 440                                         usage ();
 441                                         return 1;
 442                                 }
 443                         } else if (strcmp (opt, "use-syslog") == 0) {
 444                                 hald_use_syslog = TRUE;
 445                         }
 446 
 447                         break;
 448 
 449                 default:
 450                         usage ();
 451                         return 1;
 452                         break;
 453                 }
 454         }
 455 
 456         if (hald_is_verbose)
 457                 logger_enable ();
 458         else
 459                 logger_disable ();
 460 
 461         if (hald_use_syslog)
 462                 logger_enable_syslog ();
 463         else
 464                 logger_disable_syslog ();
 465 
 466         /* will fork into two; only the child will return here if we are successful */
 467         /*master_slave_setup ();
 468           sleep (100000000);*/
 469 
 470         loop = g_main_loop_new (NULL, FALSE);
 471 
 472         HAL_INFO ((PACKAGE_STRING));
 473 
 474         if (opt_become_daemon) {
 475                 int child_pid;
 476                 int dev_null_fd;
 477                 int pf;
 478                 ssize_t written;
 479                 char pid[9];
 480                 
 481                 HAL_INFO (("Will daemonize"));
 482                 HAL_INFO (("Becoming a daemon"));
 483 
 484                 if (pipe (startup_daemonize_pipe) != 0) {
 485                         fprintf (stderr, "Could not setup pipe: %s\n", strerror(errno));
 486                         exit (1);
 487                 }
 488 
 489 
 490                 if (chdir ("/") < 0) {
 491                         fprintf (stderr, "Could not chdir to /: %s\n", strerror(errno));
 492                         exit (1);
 493                 }
 494 
 495                 child_pid = fork ();
 496                 switch (child_pid) {
 497                 case -1:
 498                         fprintf (stderr, "Cannot fork(): %s\n", strerror(errno));
 499                         break;
 500 
 501                 case 0:
 502                         /* child */
 503 
 504                         dev_null_fd = open ("/dev/null", O_RDWR);
 505                         /* ignore if we can't open /dev/null */
 506                         if (dev_null_fd >= 0) {
 507                                 /* attach /dev/null to stdout, stdin, stderr */
 508                                 dup2 (dev_null_fd, 0);
 509                                 dup2 (dev_null_fd, 1);
 510                                 dup2 (dev_null_fd, 2);
 511                                 close (dev_null_fd);
 512                         }
 513 
 514                         umask (022);
 515                         break;
 516 
 517                 default:
 518                         /* parent, block until child writes */
 519                         exit (parent_wait_for_child (startup_daemonize_pipe[0], child_pid));
 520                         break;
 521                 }
 522 
 523                 /* Create session */
 524                 setsid ();
 525 
 526                 /* remove old pid file */
 527                 unlink (HALD_PID_FILE);
 528 
 529                 /* Make a new one */
 530                 if ((pf= open (HALD_PID_FILE, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644)) > 0) {
 531                         snprintf (pid, sizeof(pid), "%lu\n", (long unsigned) getpid ());
 532                         written = write (pf, pid, strlen(pid));
 533                         close (pf);
 534                         atexit (delete_pid);
 535                 }
 536         } else {
 537                 HAL_INFO (("Will not daemonize"));
 538         }
 539 
 540 
 541         /* we need to do stuff when we are expected to terminate, thus
 542          * this involves looking for SIGTERM; UNIX signal handlers are
 543          * evil though, so set up a pipe to transmit the signal.
 544          */
 545 
 546         /* create pipe */
 547         if (pipe (sigterm_unix_signal_pipe_fds) != 0) {
 548                 DIE (("Could not setup pipe, errno=%d", errno));
 549         }
 550         
 551         /* setup glib handler - 0 is for reading, 1 is for writing */
 552         sigterm_iochn = g_io_channel_unix_new (sigterm_unix_signal_pipe_fds[0]);
 553         if (sigterm_iochn == NULL)
 554                 DIE (("Could not create GIOChannel"));
 555         
 556         /* get callback when there is data to read */
 557         sigterm_iochn_listener_source_id = g_io_add_watch (
 558                 sigterm_iochn, G_IO_IN, sigterm_iochn_data, NULL);
 559         
 560         /* Finally, setup unix signal handler for TERM */
 561         signal (SIGTERM, handle_sigterm);
 562 
 563         /* set up the local dbus server */
 564         if (!hald_dbus_local_server_init ())
 565                 return 1;
 566         /* Start the runner helper daemon */
 567         if (!hald_runner_start_runner ()) {
 568                 return 1;
 569         }
 570 
 571         drop_privileges(0);
 572 
 573         /* initialize operating system specific parts */
 574         osspec_init ();
 575 
 576         hald_is_initialising = TRUE;
 577 
 578         /* detect devices */
 579         osspec_probe ();
 580 
 581         /* run the main loop and serve clients */
 582         g_main_loop_run (loop);
 583 
 584         return 0;
 585 }
 586 
 587 #ifdef HALD_MEMLEAK_DBG
 588 extern int dbg_hal_device_object_delta;
 589 
 590 /* useful for valgrinding; see below */
 591 static gboolean
 592 my_shutdown (gpointer data)
 593 {
 594         HalDeviceStore *gdl;
 595         
 596         printf ("Num devices in TDL: %d\n", g_slist_length ((hald_get_tdl ())->devices));
 597         printf ("Num devices in GDL: %d\n", g_slist_length ((hald_get_gdl ())->devices));
 598         
 599         gdl = hald_get_gdl ();
 600 next:
 601         if (g_slist_length (gdl->devices) > 0) {
 602                 HalDevice *d = HAL_DEVICE(gdl->devices->data);
 603                 hal_device_store_remove (gdl, d);
 604                 g_object_unref (d);
 605                 goto next;
 606         }
 607         
 608         printf ("hal_device_object_delta = %d (should be zero)\n", dbg_hal_device_object_delta);
 609         exit (1);
 610 }
 611 #endif
 612 
 613 void 
 614 osspec_probe_done (void)
 615 {
 616         ssize_t written;
 617         char buf[1] = {0};
 618 
 619         HAL_INFO (("Device probing completed"));
 620 
 621         if (!hald_dbus_init ()) {
 622                 hald_runner_kill_all();
 623                 exit (1);
 624         }
 625 
 626         /* tell parent to exit */
 627         written = write (startup_daemonize_pipe[1], buf, sizeof (buf));
 628         close (startup_daemonize_pipe[0]);
 629         close (startup_daemonize_pipe[1]);
 630 
 631         hald_is_initialising = FALSE;
 632 
 633 #ifdef HALD_MEMLEAK_DBG
 634         g_timeout_add ((HALD_MEMLEAK_DBG) * 1000,
 635                        my_shutdown,
 636                        NULL);
 637 #endif
 638 }
 639 
 640 
 641 /** @} */