hal/hald/hald.c

/***************************************************************************
 * CVSID: $Id$
 *
 * hald.c : main startup for HAL daemon
 *
 * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
 * Copyright (C) 2005 Danny Kukawka, <danny.kukawka@web.de>
 *
 * Licensed under the Academic Free License version 2.1
 *
 * 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
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 **************************************************************************/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <pwd.h>
#include <stdint.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <grp.h>
#include <syslog.h>

#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

/*#include "master_slave.h"*/

#include "logger.h"
#include "hald.h"
#include "device_store.h"
#include "device_info.h"
#include "osspec.h"
#include "hald_dbus.h"
#include "util.h"
#include "hald_runner.h"
#include "util_helper.h"

static void delete_pid(void)
{
    unlink(HALD_PID_FILE);
}

/**
 * @defgroup HalDaemon HAL daemon
 * @brief The HAL daemon manages persistent device objects available through
 *        a D-BUS network API
 */

static HalDeviceStore *global_device_list = NULL;

static HalDeviceStore *temporary_device_list = NULL;


static void
addon_terminated (HalDevice *device, guint32 exit_type,
          gint return_code, gchar **error,
          gpointer data1, gpointer data2)
{
    HAL_INFO (("in addon_terminated for udi=%s", device->udi));

    /* TODO: log to syslog - addons shouldn't just terminate, this is a bug with the addon */

    /* however, the world can stop, mark this addon as ready
     * (TODO: potential bug if the addon crashed after calling libhal_device_addon_is_ready())
     */
    if (hal_device_inc_num_ready_addons (device)) {
        if (hal_device_are_all_addons_ready (device)) {
            manager_send_signal_device_added (device);
        }
    }
}


static void
gdl_store_changed (HalDeviceStore *store, HalDevice *device,
           gboolean is_added, gpointer user_data)
{
    if (is_added) {
        GSList *addons;

        HAL_INFO (("Added device to GDL; udi=%s", hal_device_get_udi(device)));

        if ((addons = hal_device_property_get_strlist (device, "info.addons")) != NULL) {
            GSList *i;

            for (i = addons; i != NULL; i = g_slist_next (i)) {
                const gchar *command_line;
                gchar *extra_env[2] = {"HALD_ACTION=addon", NULL};

                command_line = (const gchar *) i->data;
                if (hald_runner_start(device, command_line, extra_env, addon_terminated, NULL, NULL)) {
                    HAL_INFO (("Started addon %s for udi %s",
                           command_line, hal_device_get_udi(device)));
                    hal_device_inc_num_addons (device);
                } else {
                    HAL_ERROR (("Cannot start addon %s for udi %s",
                            command_line, hal_device_get_udi(device)));
                }
            }
        }
    } else {
        HAL_INFO (("Removed device from GDL; udi=%s", hal_device_get_udi(device)));
        hald_runner_kill_device(device);
    }

    /*hal_device_print (device);*/

    if (is_added) {
        if (hal_device_are_all_addons_ready (device)) {
            manager_send_signal_device_added (device);
        }
    } else {
        if (hal_device_are_all_addons_ready (device)) {
            manager_send_signal_device_removed (device);
        }
    }
}

static void
gdl_property_changed (HalDeviceStore *store, HalDevice *device,
              const char *key, gboolean added, gboolean removed,
              gpointer user_data)
{
    if (hal_device_are_all_addons_ready (device)) {
        device_send_signal_property_modified (device, key, removed, added);
    }

    /* only execute the callouts if the property _changed_ */
    if (added == FALSE && removed == FALSE)
        /*hal_callout_property (device, key)*/;
}

static void
gdl_capability_added (HalDeviceStore *store, HalDevice *device,
              const char *capability, gpointer user_data)
{
    if (hal_device_are_all_addons_ready (device)) {
        manager_send_signal_new_capability (device, capability);
    }
    /*hal_callout_capability (device, capability, TRUE)*/;
}

HalDeviceStore *
hald_get_gdl (void)
{
    if (global_device_list == NULL) {
        global_device_list = hal_device_store_new ();

        g_signal_connect (global_device_list,
                  "store_changed",
                  G_CALLBACK (gdl_store_changed), NULL);
        g_signal_connect (global_device_list,
                  "device_property_changed",
                  G_CALLBACK (gdl_property_changed), NULL);
        g_signal_connect (global_device_list,
                  "device_capability_added",
                  G_CALLBACK (gdl_capability_added), NULL);
    }

    return global_device_list;
}

HalDeviceStore *
hald_get_tdl (void)
{
    if (temporary_device_list == NULL) {
        temporary_device_list = hal_device_store_new ();

    }

    return temporary_device_list;
}

/**
 * @defgroup MainDaemon Basic functions
 * @ingroup HalDaemon
 * @brief Basic functions in the HAL daemon
 * @{
 */

/** Print out program usage.
 *
 */
static void
usage ()
{
    fprintf (stderr, "\n" "usage : hald [--daemon=yes|no] [--verbose=yes|no] [--help]\n");
    fprintf (stderr,
         "\n"
         "        --daemon=yes|no      Become a daemon\n"
         "        --verbose=yes|no     Print out debug (overrides HALD_VERBOSE)\n"
         "        --use-syslog         Print out debug messages to syslog instead of stderr.\n"
         "                             Use this option to get debug messages if HAL runs as\n"
         "                             daemon.\n"
         "        --help               Show this information and exit\n"
         "        --version            Output version information and exit"
         "\n"
         "The HAL daemon detects devices present in the system and provides the\n"
         "org.freedesktop.Hal service through the system-wide message bus provided\n"
         "by D-BUS.\n"
         "\n"
         "For more information visit http://freedesktop.org/Software/hal\n"
         "\n");
}

/** If #TRUE, we will daemonize */
static dbus_bool_t opt_become_daemon = TRUE;

/** If #TRUE, we will spew out debug */
dbus_bool_t hald_is_verbose = FALSE;
dbus_bool_t hald_use_syslog = FALSE;

static int sigterm_unix_signal_pipe_fds[2];
static GIOChannel *sigterm_iochn;

static void
handle_sigterm (int value)
{
    ssize_t written;
    static char marker[1] = {'S'};

    /* write a 'S' character to the other end to tell about
     * the signal. Note that 'the other end' is a GIOChannel thingy
     * that is only called from the mainloop - thus this is how we
     * defer this since UNIX signal handlers are evil
     *
     * Oh, and write(2) is indeed reentrant */
    written = write (sigterm_unix_signal_pipe_fds[1], marker, 1);
}

static gboolean
sigterm_iochn_data (GIOChannel *source,
            GIOCondition condition,
            gpointer user_data)
{
    GError *err = NULL;
    gchar data[1];
    gsize bytes_read;

    /* Empty the pipe */
    if (G_IO_STATUS_NORMAL !=
        g_io_channel_read_chars (source, data, 1, &bytes_read, &err)) {
        HAL_ERROR (("Error emptying sigterm pipe: %s",
                   err->message));
        g_error_free (err);
        goto out;
    }

    HAL_INFO (("Caught SIGTERM, initiating shutdown"));
    hald_runner_kill_all();
    exit (0);

out:
    return TRUE;
}


/** This is set to #TRUE if we are probing and #FALSE otherwise */
dbus_bool_t hald_is_initialising;

static int startup_daemonize_pipe[2];


/*--------------------------------------------------------------------------------------------------*/

static gboolean child_died = FALSE;

static void
handle_sigchld (int value)
{
    child_died = TRUE;
}

static int
parent_wait_for_child (int child_fd, pid_t child_pid)
{
    fd_set rfds;
    fd_set efds;
    struct timeval tv;
    int retval;
    int ret;

    signal(SIGCHLD, handle_sigchld);

    /* wait for either
     *
     * o Child writes something to the child_fd; means that device
     *   probing is completed and the parent should exit with success
     *
     * o Child is killed (segfault etc.); means that parent should exit
     *   with failure
     *
     * o Timeout; means that we should kill the child and exit with
     *   failure
     *
     */

    FD_ZERO(&rfds);
    FD_SET(child_fd, &rfds);
    FD_ZERO(&efds);
    FD_SET(child_fd, &efds);
    /* Wait up to 250 seconds for device probing */
    tv.tv_sec = 250;
    tv.tv_usec = 0;

    retval = select (child_fd + 1, &rfds, NULL, &efds, &tv);

    if (child_died) {
        /* written from handle_sigchld */
        ret = 1;
        goto out;
    }

    if (retval > 0) {
        /* means child wrote to socket or closed it; all good */
        ret = 0;
        goto out;
    }

    /* assume timeout; kill child */
    kill (child_pid, SIGTERM);
    ret = 2;

out:
    return ret;
}

/*--------------------------------------------------------------------------------------------------*/

/** Entry point for HAL daemon
 *
 *  @param  argc                Number of arguments
 *  @param  argv                Array of arguments
 *  @return                     Exit code
 */
int
main (int argc, char *argv[])
{
    GMainLoop *loop;
    guint sigterm_iochn_listener_source_id;
    char *path;
    char newpath[512];

    openlog ("hald", LOG_PID, LOG_DAEMON);
#if !GLIB_CHECK_VERSION(2,35,0)
    g_type_init ();
#endif
    if (getenv ("HALD_VERBOSE"))
        hald_is_verbose = TRUE;
    else
        hald_is_verbose = FALSE;

    /* our helpers are installed into libexec, so adjust out $PATH
     * to include this at the end (since we want to overide in
     * run-hald.sh and friends)
     */
    path = getenv ("PATH");
    if (path != NULL) {
        g_strlcpy (newpath, path, sizeof (newpath));
        g_strlcat (newpath, ":", sizeof (newpath));
    } else {
        /* No PATH was set */
        newpath[0] = '\0';
    }

    g_strlcat (newpath, PACKAGE_LIBEXEC_DIR, sizeof (newpath));
    g_strlcat (newpath, ":", sizeof (newpath));
    g_strlcat (newpath, PACKAGE_SCRIPT_DIR, sizeof (newpath));

    setenv ("PATH", newpath, TRUE);

    while (1) {
        int c;
        int option_index = 0;
        const char *opt;
        static struct option long_options[] = {
            {"daemon", 1, NULL, 0},
            {"verbose", 1, NULL, 0},
            {"use-syslog", 0, NULL, 0},
            {"help", 0, NULL, 0},
            {"version", 0, NULL, 0},
            {NULL, 0, NULL, 0}
        };

        c = getopt_long (argc, argv, "",
                 long_options, &option_index);
        if (c == -1)
            break;

        switch (c) {
        case 0:
            opt = long_options[option_index].name;

            if (strcmp (opt, "help") == 0) {
                usage ();
                return 0;
            } else if (strcmp (opt, "version") == 0) {
                fprintf (stderr, "HAL package version: " PACKAGE_VERSION "\n");
                return 0;
            } else if (strcmp (opt, "daemon") == 0) {
                if (strcmp ("yes", optarg) == 0) {
                    opt_become_daemon = TRUE;
                } else if (strcmp ("no", optarg) == 0) {
                    opt_become_daemon = FALSE;
                } else {
                    usage ();
                    return 1;
                }
            } else if (strcmp (opt, "verbose") == 0) {
                if (strcmp ("yes", optarg) == 0) {
                    hald_is_verbose = TRUE;
                } else if (strcmp ("no", optarg) == 0) {
                    hald_is_verbose = FALSE;
                } else {
                    usage ();
                    return 1;
                }
            } else if (strcmp (opt, "use-syslog") == 0) {
                                hald_use_syslog = TRUE;
            }

            break;

        default:
            usage ();
            return 1;
            break;
        }
    }

    if (hald_is_verbose)
        logger_enable ();
    else
        logger_disable ();

    if (hald_use_syslog)
        logger_enable_syslog ();
    else
        logger_disable_syslog ();

    /* will fork into two; only the child will return here if we are successful */
    /*master_slave_setup ();
      sleep (100000000);*/

    loop = g_main_loop_new (NULL, FALSE);

    HAL_INFO ((PACKAGE_STRING));

    if (opt_become_daemon) {
        int child_pid;
        int dev_null_fd;
        int pf;
        ssize_t written;
        char pid[9];

        HAL_INFO (("Will daemonize"));
        HAL_INFO (("Becoming a daemon"));

        if (pipe (startup_daemonize_pipe) != 0) {
            fprintf (stderr, "Could not setup pipe: %s\n", strerror(errno));
            exit (1);
        }


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

        child_pid = fork ();
        switch (child_pid) {
        case -1:
            fprintf (stderr, "Cannot fork(): %s\n", strerror(errno));
            break;

        case 0:
            /* child */

            dev_null_fd = open ("/dev/null", O_RDWR);
            /* ignore if we can't open /dev/null */
            if (dev_null_fd >= 0) {
                /* attach /dev/null to stdout, stdin, stderr */
                dup2 (dev_null_fd, 0);
                dup2 (dev_null_fd, 1);
                dup2 (dev_null_fd, 2);
                close (dev_null_fd);
            }

            umask (022);
            break;

        default:
            /* parent, block until child writes */
            exit (parent_wait_for_child (startup_daemonize_pipe[0], child_pid));
            break;
        }

        /* Create session */
        setsid ();

        /* remove old pid file */
        unlink (HALD_PID_FILE);

        /* Make a new one */
        if ((pf= open (HALD_PID_FILE, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644)) > 0) {
            snprintf (pid, sizeof(pid), "%lu\n", (long unsigned) getpid ());
            written = write (pf, pid, strlen(pid));
            close (pf);
            atexit (delete_pid);
        }
    } else {
        HAL_INFO (("Will not daemonize"));
    }


    /* we need to do stuff when we are expected to terminate, thus
     * this involves looking for SIGTERM; UNIX signal handlers are
     * evil though, so set up a pipe to transmit the signal.
     */

    /* create pipe */
    if (pipe (sigterm_unix_signal_pipe_fds) != 0) {
        DIE (("Could not setup pipe, errno=%d", errno));
    }

    /* setup glib handler - 0 is for reading, 1 is for writing */
    sigterm_iochn = g_io_channel_unix_new (sigterm_unix_signal_pipe_fds[0]);
    if (sigterm_iochn == NULL)
        DIE (("Could not create GIOChannel"));

    /* get callback when there is data to read */
    sigterm_iochn_listener_source_id = g_io_add_watch (
        sigterm_iochn, G_IO_IN, sigterm_iochn_data, NULL);

    /* Finally, setup unix signal handler for TERM */
    signal (SIGTERM, handle_sigterm);

    /* set up the local dbus server */
    if (!hald_dbus_local_server_init ())
        return 1;
    /* Start the runner helper daemon */
    if (!hald_runner_start_runner ()) {
        return 1;
    }

    drop_privileges(0);

    /* initialize operating system specific parts */
    osspec_init ();

    hald_is_initialising = TRUE;

    /* detect devices */
    osspec_probe ();

    /* run the main loop and serve clients */
    g_main_loop_run (loop);

    return 0;
}

#ifdef HALD_MEMLEAK_DBG
extern int dbg_hal_device_object_delta;

/* useful for valgrinding; see below */
static gboolean
my_shutdown (gpointer data)
{
    HalDeviceStore *gdl;

    printf ("Num devices in TDL: %d\n", g_slist_length ((hald_get_tdl ())->devices));
    printf ("Num devices in GDL: %d\n", g_slist_length ((hald_get_gdl ())->devices));

    gdl = hald_get_gdl ();
next:
    if (g_slist_length (gdl->devices) > 0) {
        HalDevice *d = HAL_DEVICE(gdl->devices->data);
        hal_device_store_remove (gdl, d);
        g_object_unref (d);
        goto next;
    }

    printf ("hal_device_object_delta = %d (should be zero)\n", dbg_hal_device_object_delta);
    exit (1);
}
#endif

void
osspec_probe_done (void)
{
    ssize_t written;
    char buf[1] = {0};

    HAL_INFO (("Device probing completed"));

    if (!hald_dbus_init ()) {
        hald_runner_kill_all();
        exit (1);
    }

    /* tell parent to exit */
    written = write (startup_daemonize_pipe[1], buf, sizeof (buf));
    close (startup_daemonize_pipe[0]);
    close (startup_daemonize_pipe[1]);

    hald_is_initialising = FALSE;

#ifdef HALD_MEMLEAK_DBG
    g_timeout_add ((HALD_MEMLEAK_DBG) * 1000,
               my_shutdown,
               NULL);
#endif
}


/** @} */