/*      $OpenBSD: hotplugd.c,v 1.11 2009/06/26 01:06:04 kurt Exp $      */
/*
 * Copyright (c) 2004 Alexander Yurchenko <grange@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * Devices hot plugging daemon.
 */

#include <sys/types.h>
#include <sys/device.h>
#include <sys/wait.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <devattr.h>

#define _PATH_DEV_HOTPLUG               "/dev/hotplug"
#define _PATH_ETC_HOTPLUG               "/etc/hotplug"
#define _PATH_ETC_HOTPLUG_ATTACH        _PATH_ETC_HOTPLUG "/attach"
#define _PATH_ETC_HOTPLUG_DETACH        _PATH_ETC_HOTPLUG "/detach"
#define _LOG_TAG                        "hotplugd"
#define _LOG_FACILITY                   LOG_DAEMON
#define _LOG_OPT                        (LOG_NDELAY | LOG_PID)

enum obsd_devclass {
        DV_DULL,                /* generic, no special info */
        DV_CPU,                 /* CPU (carries resource utilization) */
        DV_DISK,                /* disk drive (label, etc) */
        DV_IFNET,               /* network interface */
        DV_TAPE,                /* tape device */
        DV_TTY                  /* serial line interface (???) */
};

extern char *__progname;

volatile sig_atomic_t quit = 0;

void exec_script(const char *, int, const char *);
void sigchild(int);
void sigquit(int);
__dead2 void usage(void);

int
main(int argc, char *argv[])
{
        int ch, class, ret;
        struct sigaction sact;
        struct udev *udev;
        struct udev_enumerate *udev_enum;
        struct udev_list_entry *udev_le, *udev_le_first;
        struct udev_monitor *udev_monitor;
        struct udev_device *udev_dev;
        enum obsd_devclass devclass;
        const char *prop;

        while ((ch = getopt(argc, argv, "?")) != -1)
                switch (ch) {
                case '?':
                default:
                        usage();
                        /* NOTREACHED */
                }

        argc -= optind;
        argv += optind;
        if (argc > 0)
                usage();

        udev = udev_new();
        if (udev == NULL)
                err(1, "udev_new");

        bzero(&sact, sizeof(sact));
        sigemptyset(&sact.sa_mask);
        sact.sa_flags = 0;
        sact.sa_handler = sigquit;
        sigaction(SIGINT, &sact, NULL);
        sigaction(SIGQUIT, &sact, NULL);
        sigaction(SIGTERM, &sact, NULL);
        sact.sa_handler = SIG_IGN;
        sigaction(SIGHUP, &sact, NULL);
        sact.sa_handler = sigchild;
        sact.sa_flags = SA_NOCLDSTOP;
        sigaction(SIGCHLD, &sact, NULL);

        openlog(_LOG_TAG, _LOG_OPT, _LOG_FACILITY);

        if (daemon(0, 0) == -1)
                err(1, "daemon");

        syslog(LOG_INFO, "started");

        udev_enum = udev_enumerate_new(udev);
        if (udev_enum == NULL)
                err(1, "udev_enumerate_new");

        ret = udev_enumerate_scan_devices(udev_enum);
        if (ret != 0)
                err(1, "udev_enumerate_scan_device ret = %d", ret);

        udev_le_first = udev_enumerate_get_list_entry(udev_enum);
        if (udev_le_first == NULL)
                err(1, "udev_enumerate_get_list_entry error");

        udev_list_entry_foreach(udev_le, udev_le_first) {
                udev_dev = udev_list_entry_get_device(udev_le);

                class = atoi(udev_device_get_property_value(udev_dev, "devtype"));
                devclass = ((class == D_TTY) ? DV_TTY : ((class == D_TAPE) ? DV_TAPE : ((class == D_DISK) ? DV_DISK : DV_DULL)));

                syslog(LOG_INFO, "%s attached, class %d",
                    udev_device_get_devnode(udev_dev), devclass);
                exec_script(_PATH_ETC_HOTPLUG_ATTACH, devclass,
                   udev_device_get_devnode(udev_dev));
        }

        udev_enumerate_unref(udev_enum);
        udev_monitor = udev_monitor_new(udev);

        ret = udev_monitor_enable_receiving(udev_monitor);
        if (ret != 0)
                err(1, "udev_monitor_enable_receiving ret = %d", ret);

        while (!quit) {
                if ((udev_dev = udev_monitor_receive_device(udev_monitor)) == NULL) {
                        syslog(LOG_ERR, "read: %m");
                        exit(1);
                }

                prop = udev_device_get_action(udev_dev);
                class = atoi(udev_device_get_property_value(udev_dev, "devtype"));
                devclass = ((class == D_TTY) ? DV_TTY : ((class == D_TAPE) ? DV_TAPE : ((class == D_DISK) ? DV_DISK : DV_DULL)));

                if (strcmp(prop, "attach") == 0) {
                        syslog(LOG_INFO, "%s attached, class %d",
                            udev_device_get_devnode(udev_dev), devclass);
                        exec_script(_PATH_ETC_HOTPLUG_ATTACH, devclass,
                            udev_device_get_devnode(udev_dev));
                } else if (strcmp(prop, "detach") == 0) {
                        syslog(LOG_INFO, "%s detached, class %d",
                            udev_device_get_devnode(udev_dev), devclass);
                        exec_script(_PATH_ETC_HOTPLUG_DETACH, devclass,
                            udev_device_get_devnode(udev_dev));
                } else {
                        syslog(LOG_NOTICE, "unknown event (%s)", prop);
                }
        }

        syslog(LOG_INFO, "terminated");

        closelog();

        udev_monitor_unref(udev_monitor);
        udev_unref(udev);

        return (0);
}

void
exec_script(const char *file, int class, const char *name)
{
        char strclass[8];
        pid_t pid;

        snprintf(strclass, sizeof(strclass), "%d", class);

        if (access(file, X_OK | R_OK)) {
                syslog(LOG_ERR, "could not access %s", file);
                return;
        }

        if ((pid = fork()) == -1) {
                syslog(LOG_ERR, "fork: %m");
                return;
        }
        if (pid == 0) {
                /* child process */
                execl(file, basename(strdup(file)), strclass, name, NULL);
                syslog(LOG_ERR, "execl %s: %m", file);
                _exit(1);
                /* NOTREACHED */
        }
}

/* ARGSUSED */
void
sigchild(int signum __unused)
{
        int saved_errno, status;
        pid_t pid;

        saved_errno = errno;

        while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
                if (pid == -1) {
                        if (errno == EINTR)
                                continue;
                        if (errno != ECHILD)
                                /* XXX syslog_r() */
                                syslog(LOG_ERR, "waitpid: %m");
                        break;
                }

                if (WIFEXITED(status)) {
                        if (WEXITSTATUS(status) != 0) {
                                /* XXX syslog_r() */
                                syslog(LOG_NOTICE, "child exit status: %d",
                                    WEXITSTATUS(status));
                        }
                } else {
                        /* XXX syslog_r() */
                        syslog(LOG_NOTICE, "child is terminated abnormally");
                }
        }

        errno = saved_errno;
}

/* ARGSUSED */
void
sigquit(int signum __unused)
{
        quit = 1;
}

__dead2 void
usage(void)
{
        fprintf(stderr, "usage: %s [-d device]\n", __progname);
        exit(1);
}