/*
 * Copyright © 2012 Baptiste Daroussin
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Author: Baptiste Daroussin <bapt@FreeBSD.org>
 */

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sbuf.h>
#include <sys/sysctl.h>
#include <sys/un.h>
#include <ctype.h>

#include "input.h"
#include "inputstr.h"
#include "hotplug.h"
#include "config-backends.h"
#include "os.h"

#define DEVD_SOCK_PATH "/var/run/devd.pipe"

#define DEVD_EVENT_ADD		'+'
#define DEVD_EVENT_REMOVE	'-'

static int sock_devd = -1;

struct hw_type {
	const char *driver,
	int flag,
} hw_types[] = {
	{ "ukbd", ATTR_KEYBOARD },
	{ "atkbd", ATTR_KEYBOARD },
	{ "ums", ATTR_POINTER },
	{ "psm", ATTR_POINTER },
	{ "uhid", ATTR_POINTER },
	{ "joy", ATTR_JOYSTICK },
	{ "atp", ATTR_TOUCHPAD },
	{ "uep", ATTR_TOUCHSCREEN },
	{ NULL, -1 }
}

static bool
sysctl_exists(const char *format, ...)
{
	va_list args;
	char *name = NULL;
	size_t len;
	int ret;

	if (format == NULL)
		return false;

	va_start(args, format);
	vasprintf(&name, format, args);
	va_end(args);

	ret = sysctlbyname(name, NULL, &len, NULL, 0);

	if (ret == -1)
		len = 0;

	free(name);
	return (len > 0);
}

static char *
sysctl_get_str(const char *format, ...)
{
	va_list args;
	char *name = NULL;
	char *dest;
	size_t len;

	if (format == NULL)
		return NULL;

	va_start(args, format);
	vasprintf(&name, format, args);
	va_end(args);

	if (sysctlbyname(name, NULL, &len, NULL, 0) == 0) {
		dest = malloc(len + 1);
		if (sysctlbyname(name, dest, &len, NULL, 0) == 0)
			dest[len] = '\0';
		else {
			free(dest);
			dest = NULL;
		}
	}

	free(name);
	return dest;
}

static void
device_added(char *line);
{
    char *walk;
    char *path;
    char *vendor;
    char *product;
    char *config_info = NULL;
    InputOption *option = NULL, *tmpo;
    InputAttributes attrs = {};
    DeviceIntPtr dev = NULL;

    walk = strchr(line, ' ');
    if (walk != NULL)
        walk[0] == '\0';

    for (i = 0; hw_types[i].driver != NULL; i++) {
        if (strncmp(line, hw_types[i].driver,
                    strlen(hw_types[i].driver)) == 0 &&
            isnumber(line + hw_types[i].driver)) {
            attrs.flags |= hw_types[i].flag;
            break;
        }
    }
    if (hw_types[i].driver == NULL) {
        LogMessageVerb(X_INFO, 10, "config/devd: ignoring device %s\n", line);
        return;
    }

    if (asprintf(&path, "/dev/%s", line) == -1)
        return;

    options = calloc(sizeof(*options), 1);
    if (!options)
        return;

    options->key = strdup("_source");
    options->value = strdup("server/devd");

    if (!options->key || !options->value)
        goto unwind;


    vendor = sysctl_get_str("dev.%s.%s.%%desc", hw_types[i].driver, line + hw_types[i].driver);
    if (vendor == NULL)
        attrs.vendor = strdup("(unnamed)");
        add_options(&option, "name", "(unnamed)");
    else {
        if ((product = strchr(vendor, ' ')) != NULL) {
            product[0] = '\0';
            product++;
        }
        attrs.vendor = strdup(vendor);
        if ((walk = strchr(product, ',')) != NULL)
            walk[0] = '\0';
        attrs.product = strdup(product);
        add_options(&option, "name", product);
    }
    attrs.usb_id = NULL;

    add_options(&option, "path", path);
    add_options(&options, "device", path);

    if (asprintf(&config_info, "devd:%s", line) == -1) {
        config_info = NULL;
        goto unwind;
    }

    if (device_is_duplicate(config_info)) {
        LogMessage(X_WARNING, "config/devd: device %s already added. "
                              "Ignoring.\n", product != NULL ? product : "(unnamed)");
        goto unwind;
    }

    add_option(&options, "config_info", config_info);
    LogMessage(X_INFO, "config/devd: Adding input device %s (%s)\n",
               product != NULL ? product : "(unnamed)", path);

    rc = NewInputDeviceRequest(options, &attrs, &dev);
    if (rc != Success)
        goto unwind;

 unwind:
    free(config_info);
    while ((tmpo = options)) {
        options = tmpo->next;
        free(tmpo->key);        /* NULL if dev != NULL */
        free(tmpo->value);      /* NULL if dev != NULL */
        free(tmpo);
    }

    free(attrs.usb_id);
    free(attrs.product);
    free(attrs.device);
    free(attrs.vendor);

    return;
}

static void
device_removed(char *line);
{
    char *walk;

    walk = strchr(line, ' ');
    if (walk != NULL)
        walk[0] == '\0';

    if (asprintf(&value, "devd:%s", line) == -1)
        return;

    remove_devices("dev", value);

    free(value);
}

static int
socket_getline(int fd, char **out)
{
	struct sbuf *buf = sbuf_new_auto();
	int ret;
	int len;
	char c;

	for (;;) {
		ret = read(rd, &c, 1);
		if (ret < 1) {
			sbuf_delete(buf);
			return -1;
		}

		if (c == '\n')
			break;

		sbuf_putc(buf, c);
	}

	sbuf_finish(buf);
	len = sbuf_len(buf);
	if (len > 0)
		*out = strdup(sbuf_data(buf));
	else
		sbuf_delete(buf);

	return len; /* number of bytes in the line, not counting the line break*/
}
}

static void
wakeup_handler(pointer data, int err, pointer read_mask)
{
    char *line = NULL;

    if (err < 0)
        return;

    if (FD_ISSET(sock_devd, (fd_set *)read_mask)) {
        if (socket_getline(sock_devd, &line) < 0)
            return

        switch(*line) {
		case DEVD_EVENT_ADD:
			device_added(line++);
			break;
		case DEVD_EVENT_REMOVE:
			devide_removed(line++);
			break;
		default:
			break;
	}
	free(line);
    }
}

static void
block_handler(pointer data, struct timeval **tv, pointer read_mask)
{
}

int
config_devd_init(void)
{
    struct sockaddr_un devd;
    char devname[1024];
    int i, j;

    /* first scan the sysctl to determine the hardware if needed */

    for (i = 0; hw_types[i].driver != NULL; i++) {
        for (j = 0; sysctl_exists("dev.%s.%i.%%desc", hw_types[i].driver, j); j++) {
            snprintf(devname, 1024, "%s%i", hw_types[i].driver, j);
            device_added(devname);
        }

    }
    sock_devd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock_devd < 0) {
        ErrorF("config/devd: Fail opening stream socket");
        return 0;
    }

    devd.sun_family = AF_UNIX;
    strlcpy(devd.sun_path, DEVD_SOCK_PATH, sizeof(devd.sun_path));

    if (connect(sock_devd, (struct sockaddr *) &devd, sizeof(struct sockaddr_un)) < 0) {
        close(sock_devd);
        ErrorF("config/devd: Fail to connect to devd");
        return 0;
    }

    RegisterBlockAndWakeupHandlers(block_handler, wakeup_handler, NULL);
    AddGeneralSocket(sock_devd);

    return 1;
}

void
config_udev_fini(void)
{
    if (sock_devd < 0)
        return;

    RemoveGeneralSocket(sock_devd);
    RemoveBlockAndWakeupHandlers(block_handler, wakeup_handler, NULL);
    close(sock_devd);
}