/***************************************************************************
 *
 * devinfo.c : main file for libdevinfo-based device enumeration
 *
 * Copyright 2013 Garrett D'Amore <garrett@damore.org>
 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 *
 * Licensed under the Academic Free License version 2.1
 *
 **************************************************************************/

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

#include <stdio.h>
#include <string.h>
#include <libdevinfo.h>

#include "../osspec.h"
#include "../logger.h"
#include "../hald.h"
#include "../hald_dbus.h"
#include "../device_info.h"
#include "../util.h"
#include "../hald_runner.h"
#include "osspec_solaris.h"
#include "hotplug.h"
#include "devinfo.h"
#include "devinfo_pci.h"
#include "devinfo_storage.h"
#include "devinfo_ieee1394.h"
#include "devinfo_usb.h"
#include "devinfo_misc.h"
#include "devinfo_acpi.h"
#include "devinfo_cpu.h"

void devinfo_add_subtree(HalDevice *parent, di_node_t node, gboolean is_root);
HalDevice *devinfo_add_node(HalDevice *parent, di_node_t node);

void
devinfo_add(HalDevice *parent, gchar *path)
{
        di_node_t       root;

        if (strcmp (path, "/") == 0) {
                if ((root = di_init(path, DINFOCACHE)) == DI_NODE_NIL) {
                        HAL_INFO (("di_init() failed %d", errno));
                        return;
                }
        } else {
                if ((root = di_init(path, DINFOCPYALL)) == DI_NODE_NIL) {
                        HAL_INFO (("di_init() failed %d", errno));
                        return;
                }
        }

        devinfo_add_subtree(parent, root, TRUE);

        di_fini (root);
}

void
devinfo_add_subtree(HalDevice *parent, di_node_t node, gboolean is_root)
{
        HalDevice *d;
        di_node_t root_node, child_node;

        HAL_INFO (("add_subtree: %s", di_node_name (node)));

        root_node = node;
        do {
                d = devinfo_add_node (parent, node);

                if ((d != NULL) &&
                    (child_node = di_child_node (node)) != DI_NODE_NIL) {
                        devinfo_add_subtree (d, child_node, FALSE);
                }

                node = di_sibling_node (node);
        } while ((node != DI_NODE_NIL) &&
                (!is_root || di_parent_node (node) == root_node));
}

void
devinfo_set_default_properties (HalDevice *d, HalDevice *parent, di_node_t node, char *devfs_path)
{
        char    *driver_name, *s;
        const char *s1;
        char    udi[HAL_PATH_MAX];

        if (parent != NULL) {
                hal_device_property_set_string (d, "info.parent", hal_device_get_udi (parent));
        } else {
                hal_device_property_set_string (d, "info.parent", "/org/freedesktop/Hal/devices/local");
        }

        hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),
                                "/org/freedesktop/Hal/devices%s_%d",
                                devfs_path,
                                di_instance (node));
        hal_device_set_udi (d, udi);
        hal_device_property_set_string (d, "info.udi", udi);

        if (di_prop_lookup_strings (DDI_DEV_T_ANY, node, "model", &s) > 0) {
                hal_device_property_set_string (d, "info.product", s);
        } else {
                hal_device_property_set_string (d, "info.product", di_node_name (node));
        }

        hal_device_property_set_string (d, "solaris.devfs_path", devfs_path);

        if ((driver_name = di_driver_name (node)) != NULL) {
                hal_device_property_set_string (d, "info.solaris.driver",
                                                driver_name);
        }


        /* inherit parent's claim attributes */
        if (hal_device_property_get_bool (parent, "info.claimed")) {
                s1 = hal_device_property_get_string (parent, "info.claimed.service");
                if (s1 != NULL) {
                        hal_device_property_set_bool (d, "info.claimed", TRUE);
                        hal_device_property_set_string (d, "info.claimed.service", s1);
                }
        }
}

/* device handlers, ordered specific to generic */
static DevinfoDevHandler *devinfo_handlers[] = {
        &devinfo_computer_handler,
        &devinfo_cpu_handler,
        &devinfo_ide_handler,
        &devinfo_scsi_handler,
        &devinfo_blkdev_handler,
        &devinfo_floppy_handler,
        &devinfo_usb_handler,
        &devinfo_ieee1394_handler,
        &devinfo_lofi_handler,
        &devinfo_acpi_handler,
        &devinfo_power_button_handler,
        &devinfo_keyboard_handler,
        &devinfo_mouse_handler,
        &devinfo_pci_handler,
        &devinfo_default_handler,
        NULL
};

HalDevice *
devinfo_add_node(HalDevice *parent, di_node_t node)
{
        HalDevice *d = NULL;
        char    *devfs_path;
        char    *device_type = NULL;
        DevinfoDevHandler *handler;
        int     i;

        devfs_path = di_devfs_path (node);

        (void) di_prop_lookup_strings (DDI_DEV_T_ANY, node, "device_type",
            &device_type);

        for (i = 0; (d == NULL) && (devinfo_handlers[i] != NULL); i++) {
                handler = devinfo_handlers[i];
                d = handler->add (parent, node, devfs_path, device_type);
        }

        di_devfs_path_free(devfs_path);

        HAL_INFO (("add_node: %s", d ? hal_device_get_udi (d) : "none"));
        return (d);
}

void
devinfo_hotplug_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler, int action, int front)
{
        HotplugEvent *hotplug_event;

        hotplug_event = g_new0 (HotplugEvent, 1);
        hotplug_event->action = action;
        hotplug_event->type = HOTPLUG_EVENT_DEVFS;
        hotplug_event->d = d;
        strlcpy (hotplug_event->un.devfs.devfs_path, devfs_path,
                sizeof (hotplug_event->un.devfs.devfs_path));
        hotplug_event->un.devfs.handler = handler;

        hotplug_event_enqueue (hotplug_event, front);
}

void
devinfo_add_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
{
        devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 0);
}

void
devinfo_add_enqueue_at_front(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
{
        devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 1);
}

void
devinfo_remove_enqueue(gchar *devfs_path, DevinfoDevHandler *handler)
{
        devinfo_hotplug_enqueue (NULL, devfs_path, handler, HOTPLUG_ACTION_REMOVE, 0);
}

void
devinfo_callouts_add_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
{
        void *end_token = (void *) userdata1;

        /* Move from temporary to global device store */
        hal_device_store_remove (hald_get_tdl (), d);
        hal_device_store_add (hald_get_gdl (), d);

        hotplug_event_end (end_token);
}

void
devinfo_callouts_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2)
{
        void *end_token = (void *) userdata1;

        /* Discard device if probing reports failure */
        if (exit_type != HALD_RUN_SUCCESS || (return_code != 0)) {
                HAL_INFO (("Probing for %s failed %d", hal_device_get_udi (d), return_code));
                hal_device_store_remove (hald_get_tdl (), d);
                g_object_unref (d);
                hotplug_event_end (end_token);
                return;
        }

        /* Merge properties from .fdi files */
        di_search_and_merge (d, DEVICE_INFO_TYPE_INFORMATION);
        di_search_and_merge (d, DEVICE_INFO_TYPE_POLICY);

        hal_util_callout_device_add (d, devinfo_callouts_add_done, end_token, NULL);
}

void
devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
{
        void *end_token = (void *) userdata1;
        DevinfoDevHandler *handler = (DevinfoDevHandler *) userdata2;
        void (*probing_done) (HalDevice *, guint32, gint, char **, gpointer, gpointer);
        const gchar *prober;
        int prober_timeout;

        if (hal_device_property_get_bool (d, "info.ignore")) {
                HAL_INFO (("Preprobing merged info.ignore==TRUE"));

                /* Leave device with info.ignore==TRUE so we won't pick up children */
                hal_device_property_remove (d, "info.category");
                hal_device_property_remove (d, "info.capabilities");

                hal_device_store_remove (hald_get_tdl (), d);
                hal_device_store_add (hald_get_gdl (), d);

                hotplug_event_end (end_token);
                return;
        }

        if (handler != NULL && handler->get_prober != NULL) {
                prober = handler->get_prober (d, &prober_timeout);
        } else {
                prober = NULL;
        }

        if (handler->probing_done != NULL) {
                probing_done = handler->probing_done;
        } else {
                probing_done = devinfo_callouts_probing_done;
        }

        if (prober != NULL) {
                /* probe the device */
                HAL_INFO(("Probing udi=%s", hal_device_get_udi (d)));
                hald_runner_run (d,
                                prober, NULL,
                                prober_timeout,
                                probing_done,
                                (gpointer) end_token, (gpointer) handler);
        } else {
                probing_done (d, 0, 0, NULL, userdata1, userdata2);
        }
}

/* This is the beginning of hotplug even handling */
void
hotplug_event_begin_add_devinfo (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token)
{
        HotplugEvent *hotplug_event = (HotplugEvent *)end_token;

        HAL_INFO(("Preprobing udi=%s", hal_device_get_udi (d)));

        if (parent == NULL && (strcmp(hotplug_event->un.devfs.devfs_path, "/") != 0)) {
                HAL_ERROR (("Parent is NULL, devfs_path=%s", hotplug_event->un.devfs.devfs_path));

                goto skip;
        }


        if (parent != NULL && hal_device_property_get_bool (parent, "info.ignore")) {
                HAL_INFO (("Ignoring device since parent has info.ignore==TRUE"));

                goto skip;
        }

        if (hal_device_store_find (hald_get_tdl (), hal_device_get_udi (d)) == NULL) {

                /* add to TDL so preprobing callouts and prober can access it */
                hal_device_store_add (hald_get_tdl (), d);
        }

        /* Process preprobe fdi files */
        di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE);

        /* Run preprobe callouts */
        hal_util_callout_device_preprobe (d, devinfo_callouts_preprobing_done, end_token, handler);

        return;

skip:
        if (hal_device_store_find (hald_get_tdl (), hal_device_get_udi (d)))
                hal_device_store_remove (hald_get_tdl (), d);

        g_object_unref (d);
        hotplug_event_end (end_token);

        return;
}

void
devinfo_remove (gchar *devfs_path)
{
        devinfo_remove_enqueue ((gchar *)devfs_path, NULL);
}

/* generate hotplug event for each device in this branch */
void
devinfo_remove_branch (gchar *devfs_path, HalDevice *d)
{
        GSList *i;
        GSList *children;
        HalDevice *child;
        char *child_devfs_path;

        if (d == NULL) {
                d = hal_device_store_match_key_value_string (hald_get_gdl (),
                        "solaris.devfs_path", devfs_path);
                if (d == NULL)
                        return;
        }

        HAL_INFO (("remove_branch: %s %s\n", devfs_path, hal_device_get_udi (d)));

        /* first remove children */
        children = hal_device_store_match_multiple_key_value_string (hald_get_gdl(),
                "info.parent", hal_device_get_udi (d));
        for (i = children; i != NULL; i = g_slist_next (i)) {
                child = HAL_DEVICE (i->data);
                HAL_INFO (("remove_branch: child %s\n", hal_device_get_udi (child)));
                devinfo_remove_branch ((gchar *)hal_device_property_get_string (child, "solaris.devfs_path"), child);
        }
        g_slist_free (children);
        HAL_INFO (("remove_branch: done with children"));

        /* then remove self */
        HAL_INFO (("remove_branch: queueing %s", devfs_path));
        devinfo_remove_enqueue (devfs_path, NULL);
}

void
devinfo_callouts_remove_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
{
        void *end_token = (void *) userdata1;

        HAL_INFO (("Remove callouts completed udi=%s", hal_device_get_udi (d)));

        if (!hal_device_store_remove (hald_get_gdl (), d)) {
                HAL_WARNING (("Error removing device"));
        }
        g_object_unref (d);

        hotplug_event_end (end_token);
}

void
hotplug_event_begin_remove_devinfo (HalDevice *d, gchar *devfs_path, void *end_token)
{
        if (hal_device_has_capability (d, "volume")) {
                devinfo_volume_hotplug_begin_remove (d, devfs_path, end_token);
        } else {
                hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);
        }
}

gboolean
devinfo_device_rescan (HalDevice *d)
{
        if (hal_device_has_capability (d, "block")) {
                return (devinfo_storage_device_rescan (d));
        } else if (hal_device_has_capability (d, "button")) {
                return (devinfo_lid_rescan (d));
        } else {
                return (FALSE);
        }
}

static int
walk_devlinks(di_devlink_t devlink, void *arg)
{
        char    **path= (char **)arg;

        *path = strdup(di_devlink_path(devlink));

        return (DI_WALK_TERMINATE);
}

char *
get_devlink(di_devlink_handle_t devlink_hdl, char *re, char *path)
{
        char    *devlink_path = NULL;

        (void) di_devlink_walk(devlink_hdl, re, path,
            DI_PRIMARY_LINK, &devlink_path, walk_devlinks);

        return (devlink_path);
}