/*

 *

 *  BlueZ - Bluetooth protocol stack for Linux

 *

 *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>

 *

 *

 *  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 <errno.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include "lib/bluetooth.h"

#include "lib/sdp.h"

#include "gdbus/gdbus.h"

#include "src/dbus-common.h"

#include "src/plugin.h"

#include "src/adapter.h"

#include "src/log.h"

/* http://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm */

#define MAJOR_CLASS_MISCELLANEOUS	0x00

#define MAJOR_CLASS_COMPUTER		0x01

#define MINOR_CLASS_UNCATEGORIZED	0x00

#define MINOR_CLASS_DESKTOP		0x01

#define MINOR_CLASS_SERVER		0x02

#define MINOR_CLASS_LAPTOP		0x03

#define MINOR_CLASS_HANDHELD		0x04

#define MINOR_CLASS_PALM_SIZED		0x05

#define MINOR_CLASS_WEARABLE		0x06

#define MINOR_CLASS_TABLET		0x07

static uint8_t major_class = MAJOR_CLASS_MISCELLANEOUS;

static uint8_t minor_class = MINOR_CLASS_UNCATEGORIZED;

static char *pretty_hostname = NULL;

static char *static_hostname = NULL;

/*

 * Fallback to static hostname only if empty pretty hostname was already

 * received.

 */

static const char *get_hostname(void)

{

	if (pretty_hostname) {

		if (g_str_equal(pretty_hostname, "") == FALSE)

			return pretty_hostname;

		if (static_hostname &&

				g_str_equal(static_hostname, "") == FALSE)

			return static_hostname;

	}

	return NULL;

}

static void update_name(struct btd_adapter *adapter, gpointer user_data)

{

	const char *hostname = get_hostname();

	if (hostname == NULL)

		return;

	if (btd_adapter_is_default(adapter)) {

		DBG("name: %s", hostname);

		adapter_set_name(adapter, hostname);

	} else {

		uint16_t index = btd_adapter_get_index(adapter);

		char *str;

		/* Avoid "some device #0" names, start at #1 */

		str = g_strdup_printf("%s #%u", hostname, index + 1);

		DBG("name: %s", str);

		adapter_set_name(adapter, str);

		g_free(str);

	}

}

static void update_class(struct btd_adapter *adapter, gpointer user_data)

{

	if (major_class == MAJOR_CLASS_MISCELLANEOUS)

		return;

	DBG("major: 0x%02x minor: 0x%02x", major_class, minor_class);

	btd_adapter_set_class(adapter, major_class, minor_class);

}

static const struct {

	const char *chassis;

	uint8_t major_class;

	uint8_t minor_class;

} chassis_table[] = {

	{ "desktop",  MAJOR_CLASS_COMPUTER, MINOR_CLASS_DESKTOP  },

	{ "server",   MAJOR_CLASS_COMPUTER, MINOR_CLASS_SERVER   },

	{ "laptop",   MAJOR_CLASS_COMPUTER, MINOR_CLASS_LAPTOP   },

	{ "handset",  MAJOR_CLASS_COMPUTER, MINOR_CLASS_HANDHELD },

	{ "tablet",   MAJOR_CLASS_COMPUTER, MINOR_CLASS_TABLET   },

	{ }

};

static void property_changed(GDBusProxy *proxy, const char *name,

					DBusMessageIter *iter, void *user_data)

{

	if (g_str_equal(name, "PrettyHostname") == TRUE) {

		if (iter == NULL) {

			g_dbus_proxy_refresh_property(proxy, name);

			return;

		}

		if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {

			const char *str;

			dbus_message_iter_get_basic(iter, &str);

			DBG("pretty hostname: %s", str);

			g_free(pretty_hostname);

			pretty_hostname = g_strdup(str);

			adapter_foreach(update_name, NULL);

		}

	} else if (g_str_equal(name, "StaticHostname") == TRUE) {

		if (iter == NULL) {

			g_dbus_proxy_refresh_property(proxy, name);

			return;

		}

		if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {

			const char *str;

			dbus_message_iter_get_basic(iter, &str);

			DBG("static hostname: %s", str);

			g_free(static_hostname);

			static_hostname = g_strdup(str);

			adapter_foreach(update_name, NULL);

		}

	} else if (g_str_equal(name, "Chassis") == TRUE) {

		if (iter == NULL) {

			g_dbus_proxy_refresh_property(proxy, name);

			return;

		}

		if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {

			const char *str;

			int i;

			dbus_message_iter_get_basic(iter, &str);

			DBG("chassis: %s", str);

			for (i = 0; chassis_table[i].chassis; i++) {

				if (strcmp(chassis_table[i].chassis, str))

					continue;

				major_class = chassis_table[i].major_class;

				minor_class = chassis_table[i].minor_class;

				adapter_foreach(update_class, NULL);

				break;

			}

		}

	}

}

static int hostname_probe(struct btd_adapter *adapter)

{

	DBG("");

	update_name(adapter, NULL);

	update_class(adapter, NULL);

	return 0;

}

static void hostname_remove(struct btd_adapter *adapter)

{

	DBG("");

}

static struct btd_adapter_driver hostname_driver = {

	.name	= "hostname",

	.probe	= hostname_probe,

	.remove	= hostname_remove,

};

static void read_dmi_fallback(void)

{

	char *contents;

	int i, type;

	const char *str;

	if (g_file_get_contents("/sys/class/dmi/id/chassis_type",

					&contents, NULL, NULL) == FALSE)

		return;

	type = atoi(contents);

	if (type < 0 || type > 0x1D)

		return;

	g_free(contents);

	/* from systemd hostname chassis list */

	switch (type) {

	case 0x3:

	case 0x4:

	case 0x6:

	case 0x7:

		str = "desktop";

		break;

	case 0x8:

	case 0x9:

	case 0xA:

	case 0xE:

		str = "laptop";

		break;

	case 0xB:

		str = "handset";

		break;

	case 0x11:

	case 0x1C:

		str = "server";

		break;

	default:

		return;

	}

	DBG("chassis: %s", str);

	for (i = 0; chassis_table[i].chassis; i++) {

		if (!strcmp(chassis_table[i].chassis, str)) {

			major_class = chassis_table[i].major_class;

			minor_class = chassis_table[i].minor_class;

			break;

		}

	}

	DBG("major: 0x%02x minor: 0x%02x", major_class, minor_class);

}

static GDBusClient *hostname_client = NULL;

static GDBusProxy *hostname_proxy = NULL;

static int hostname_init(void)

{

	DBusConnection *conn = btd_get_dbus_connection();

	int err;

	read_dmi_fallback();

	hostname_client = g_dbus_client_new(conn, "org.freedesktop.hostname1",

						"/org/freedesktop/hostname1");

	if (!hostname_client)

		return -EIO;

	hostname_proxy = g_dbus_proxy_new(hostname_client,

						"/org/freedesktop/hostname1",

						"org.freedesktop.hostname1");

	if (!hostname_proxy) {

		g_dbus_client_unref(hostname_client);

		hostname_client = NULL;

		return -EIO;

	}

	g_dbus_proxy_set_property_watch(hostname_proxy, property_changed, NULL);

	err = btd_register_adapter_driver(&hostname_driver);

	if (err < 0) {

		g_dbus_proxy_unref(hostname_proxy);

		hostname_proxy = NULL;

		g_dbus_client_unref(hostname_client);

		hostname_client = NULL;

	} else {

		g_dbus_proxy_refresh_property(hostname_proxy, "PrettyHostname");

		g_dbus_proxy_refresh_property(hostname_proxy, "StaticHostname");

		g_dbus_proxy_refresh_property(hostname_proxy, "Chassis");

	}

	return err;

}

static void hostname_exit(void)

{

	btd_unregister_adapter_driver(&hostname_driver);

	if (hostname_proxy) {

		g_dbus_proxy_unref(hostname_proxy);

		hostname_proxy = NULL;

	}

	if (hostname_client) {

		g_dbus_client_unref(hostname_client);

		hostname_client = NULL;

	}

	g_free(pretty_hostname);

	g_free(static_hostname);

}

BLUETOOTH_PLUGIN_DEFINE(hostname, VERSION, BLUETOOTH_PLUGIN_PRIORITY_DEFAULT,

						hostname_init, hostname_exit)