/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Licensed under the Academic Free License version 2.1
 */


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

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/dkio.h>
#include <sys/stat.h>
#include <priv.h>
#include <glib.h>

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

#include "../../hald/logger.h"

#include "network-discovery.h"
#include "printer.h"

#define DBUS_INTERFACE  "org.freedesktop.Hal.Device.NetworkDiscovery"
#define NP(x)   (x?x:"NULL")
#define STRDUP(x)       (x?strdup(x):NULL)

typedef struct {
        LibHalContext *ctx;
        gboolean enabled;
        char *parent;
        char *community;
        char *network;
} nds_snmp_cbdata_t;

static nds_snmp_cbdata_t *snmp_cb_data = NULL;

static int
nds_snmp_scan(LibHalContext *ctx, char *parent, char *community, char *network)
{
        time_t start;

        HAL_DEBUG(("nds_snmp_scan(0x%8.8x, %s, %s, %s)",
                        ctx, NP(parent), NP(community), NP(network)));
        HAL_DEBUG(("NetworkDiscovery snmp scan initated"));

        /* scan for devices */
        time(&start);
        if (network == NULL) {
                GList *elem, *list = broadcast_addresses();

                for (elem = list; elem != NULL; elem = g_list_next(elem)) {
                        scan_for_devices_using_snmp(ctx, parent, community,
                                                (char *)elem->data);
                        free(elem->data);
                }
                g_list_free(list);
        } else
                scan_for_devices_using_snmp(ctx, parent, community, network);

        /* remove devices that haven't been seen since before this scan */
        scan_for_stale_devices(ctx, start);

        HAL_DEBUG(("NetworkDiscovery snmp scan completed"));

        return (0);
}

static gboolean
nds_snmp_scan_cb(gpointer data)
{
        nds_snmp_cbdata_t *args = data;

        if (args->enabled == FALSE) {
                if (args->parent) free(args->parent);
                if (args->community) free(args->community);
                if (args->network) free(args->network);
                free(args);
                return (FALSE);
        }

        nds_snmp_scan(args->ctx, args->parent, args->community, args->network);

        return (TRUE);
}

static int
nds_EnablePrinterScanningViaSNMP(LibHalContext *ctx, char *parent, int interval,
                char *community, char *network)
{
        HAL_DEBUG(("NetworkDiscovery.EnablePrinterScanningViaSNMP(0x%8.8x, %s, %d, %s, %s)",
                        ctx, NP(parent), interval, NP(community), NP(network)));

        /* are we already discoverying network devices ? */
        if (snmp_cb_data != NULL) {
                snmp_cb_data->enabled = FALSE; /* cancel it */
        }

        /* setup for network device discovery */
        if ((snmp_cb_data = calloc(1, sizeof (*snmp_cb_data))) != NULL) {
                snmp_cb_data->ctx = ctx;
                snmp_cb_data->enabled = TRUE;
                snmp_cb_data->parent = STRDUP(parent);
                snmp_cb_data->community = STRDUP(community);
                snmp_cb_data->network = STRDUP(network);

                /* prime the pump with an initial scan */
                nds_snmp_scan(ctx, parent, community, network);

                /* add a regular network scan */
                g_timeout_add(interval * 1000, nds_snmp_scan_cb, snmp_cb_data);
        }

        return (0);
}

static int
nds_DisablePrinterScanningViaSNMP(LibHalContext *ctx)
{
        HAL_DEBUG(("NetworkDiscovery.DisablePrinterScanningViaSNMP(0x%8.8x)", ctx));

        if (snmp_cb_data != NULL)
                snmp_cb_data->enabled = FALSE;
        snmp_cb_data = NULL;

        return (0);
}

static int
nds_ScanForPrintersViaSNMP(LibHalContext *ctx, char *parent, char *community,
                char *network)
{
        time_t start, stop;

        HAL_DEBUG(("NetworkDiscovery.ScanForPrintersViaSNMP(0x%8.8x, %s, %s, %s)",
                        ctx, NP(parent), NP(community), NP(network)));

        return (nds_snmp_scan(ctx, parent, community, network));
}

static DBusHandlerResult
nds_filter_function(DBusConnection *connection, DBusMessage *message,
                void *user_data)
{
        LibHalContext *ctx = user_data;
        DBusMessage *reply;
        DBusError error;
        const char *member = dbus_message_get_member(message);
        const char *path = dbus_message_get_path(message);
        int rc = -1;

        dbus_error_init(&error);

        HAL_DEBUG(("DBus message: %s, %s ", member, path));

        if (dbus_message_is_method_call(message,
                                DBUS_INTERFACE, "EnablePrinterScanningViaSNMP")) {
                int interval = -1;
                char *udi = getenv("UDI");
                char *community = "public";
                char *network = "0.0.0.0";

                dbus_message_get_args(message, &error,
                                DBUS_TYPE_INT32, &interval,
                                DBUS_TYPE_STRING, &community,
                                DBUS_TYPE_STRING, &network,
                                DBUS_TYPE_INVALID);

                if (strcmp(network, "0.0.0.0") == 0)
                        network = NULL;

                rc = nds_EnablePrinterScanningViaSNMP(ctx, udi, interval,
                                community, network);
        } else if (dbus_message_is_method_call(message,
                                DBUS_INTERFACE, "ScanForPrintersViaSNMP")) {
                int interval = -1;
                char *udi = getenv("UDI");
                char *community = "public";
                char *network = "0.0.0.0";

                dbus_message_get_args(message, &error,
                                DBUS_TYPE_STRING, &community,
                                DBUS_TYPE_STRING, &network,
                                DBUS_TYPE_INVALID);

                if (strcmp(network, "0.0.0.0") == 0)
                        network = NULL;

                rc = nds_ScanForPrintersViaSNMP(ctx, udi, community, network);
        } else if (dbus_message_is_method_call(message,
                                DBUS_INTERFACE, "DisablePrinterScanningViaSNMP")) {
                rc = nds_DisablePrinterScanningViaSNMP(ctx);
        } else {
                /* bypass not-handled messages */
                HAL_WARNING(("Unknown DBus message: %s, %s ", member, path));
                return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
        }

        if (dbus_error_is_set(&error))
                dbus_error_free(&error);

        if ((reply = dbus_message_new_method_return(message)) == NULL) {
                HAL_WARNING(("Could not allocate memory for the DBus reply"));
                return (FALSE);
        }

        dbus_message_append_args(reply, DBUS_TYPE_INT32, &rc,
                        DBUS_TYPE_INVALID);

        if (!dbus_connection_send(connection, reply, NULL)) {
                HAL_WARNING(("Could not sent reply"));
        }
        dbus_connection_flush(connection);
        dbus_message_unref(reply);

        return (DBUS_HANDLER_RESULT_HANDLED);
}

static int
nds_claim_interface(LibHalContext *ctx, char *udi, DBusError *error)
{
        DBusConnection *connection;
        char *interface_xml =
                "<method name=\"EnablePrinterScanningViaSNMP\">\n"
                "  <arg name=\"interval\" direction=\"in\" type=\"i\"/>\n"
                "  <arg name=\"community\" direction=\"in\" type=\"s\"/>\n"
                "  <arg name=\"network\" direction=\"in\" type=\"s\"/>\n"
                "  <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n"
                "</method>\n"
                "<method name=\"DisablePrinterScanningViaSNMP\">\n"
                "  <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n"
                "</method>\n"
                "<method name=\"ScanForPrintersViaSNMP\">\n"
                "  <arg name=\"community\" direction=\"in\" type=\"s\"/>\n"
                "  <arg name=\"network\" direction=\"in\" type=\"s\"/>\n"
                "  <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n"
                "</method>\n";

        HAL_DEBUG(("nds_claim_interface(0x%8.8x, %s, 0x%8.8x): %s",
                        ctx, udi, error, DBUS_INTERFACE));

        if ((connection = libhal_ctx_get_dbus_connection(ctx)) == NULL) {
                HAL_WARNING(("Could not get DBus connection"));
                return (-1);
        }

        if (libhal_device_claim_interface(ctx, udi,
                        DBUS_INTERFACE, interface_xml, error) == 0) {
                HAL_WARNING(("Could not claim interface: %s", error->message));
                return (-1);
        }

        dbus_connection_setup_with_g_main(connection, NULL);
        dbus_connection_add_filter(connection, nds_filter_function, ctx, NULL);
        dbus_connection_set_exit_on_disconnect(connection, 0);

        return (0);
}

static void
drop_privileges()
{
        priv_set_t *pPrivSet = NULL;
        priv_set_t *lPrivSet = NULL;

        /*
         * Start with the 'basic' privilege set and then remove any
         * of the 'basic' privileges that will not be needed.
         */
        if ((pPrivSet = priv_str_to_set("basic", ",", NULL)) == NULL) {
                return;
        }

        /* Clear privileges we will not need from the 'basic' set */
        (void) priv_delset(pPrivSet, PRIV_FILE_LINK_ANY);
        (void) priv_delset(pPrivSet, PRIV_PROC_EXEC);
        (void) priv_delset(pPrivSet, PRIV_PROC_FORK);
        (void) priv_delset(pPrivSet, PRIV_PROC_INFO);
        (void) priv_delset(pPrivSet, PRIV_PROC_SESSION);

        /* Set the permitted privilege set. */
        if (setppriv(PRIV_SET, PRIV_PERMITTED, pPrivSet) != 0) {
                return;
        }

        /* Clear the limit set. */
        if ((lPrivSet = priv_allocset()) == NULL) {
                return;
        }

        priv_emptyset(lPrivSet);

        if (setppriv(PRIV_SET, PRIV_LIMIT, lPrivSet) != 0) {
                return;
        }

        priv_freeset(lPrivSet);
}


int
main(int argc, char **argv)
{
        LibHalContext *ctx = NULL;
        DBusError error;
        GMainLoop *loop = g_main_loop_new(NULL, FALSE);
        char *udi;

        if ((udi = getenv("UDI")) == NULL) {
                return (0);
        }

        drop_privileges();

        setup_logger();

        dbus_error_init(&error);

        if ((ctx = libhal_ctx_init_direct(&error)) == NULL) {
                return (0);
        }

        if (!libhal_device_addon_is_ready(ctx, udi, &error)) {
                return (0);
        }

        if (nds_claim_interface(ctx, udi, &error) != 0) {
                return (0);
        }

        g_main_loop_run(loop);

        /* NOTREACHED */
}