/*

 *

 *  Embedded Linux library

 *

 *  Copyright (C) 2011-2014  Intel Corporation. All rights reserved.

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2.1 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; 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

#define _GNU_SOURCE

#include <stdarg.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include "util.h"

#include "queue.h"

#include "string.h"

#include "hashmap.h"

#include "dbus.h"

#include "dbus-service.h"

#include "dbus-private.h"

#include "private.h"

#include "idle.h"

#define XML_ID "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"

#define XML_DTD "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd"

#define XML_HEAD "\n"

static const char *static_introspectable =

		"\t<interface name=\"org.freedesktop.DBus.Introspectable\">\n"

		"\t\t<method name=\"Introspect\">\n"

		"\t\t\t<arg name=\"xml\" type=\"s\" direction=\"out\"/>\n"

		"\t\t</method>\n\t</interface>\n";

struct _dbus_method {

	l_dbus_interface_method_cb_t cb;

	uint32_t flags;

	unsigned char name_len;

	char metainfo[];

};

struct _dbus_signal {

	uint32_t flags;

	unsigned char name_len;

	char metainfo[];

};

struct _dbus_property {

	l_dbus_property_get_cb_t getter;

	l_dbus_property_set_cb_t setter;

	uint32_t flags;

	unsigned char name_len;

	char metainfo[];

};

struct l_dbus_interface {

	struct l_queue *methods;

	struct l_queue *signals;

	struct l_queue *properties;

	bool handle_old_style_properties;

	void (*instance_destroy)(void *);

	char name[];

};

struct child_node {

	struct object_node *node;

	struct child_node *next;

	char subpath[];

};

struct interface_instance {

	struct l_dbus_interface *interface;

	void *user_data;

};

struct object_node {

	struct object_node *parent;

	struct l_queue *instances;

	struct child_node *children;

	void *user_data;

	void (*destroy) (void *);

};

struct object_manager {

	char *path;

	struct l_dbus *dbus;

	struct l_queue *announce_added;

	struct l_queue *announce_removed;

};

struct interface_add_record {

	char *path;

	struct object_node *object;

	struct l_queue *instances;

};

struct interface_remove_record {

	char *path;

	struct object_node *object;

	struct l_queue *interface_names;

};

struct property_change_record {

	char *path;

	struct object_node *object;

	struct interface_instance *instance;

	struct l_queue *properties;

};

struct _dbus_object_tree {

	struct l_hashmap *interfaces;

	struct l_hashmap *objects;

	struct object_node *root;

	struct l_queue *object_managers;

	struct l_queue *property_changes;

	struct l_idle *emit_signals_work;

	bool flushing;

};

void _dbus_method_introspection(struct _dbus_method *info,

					struct l_string *buf)

{

	const char *sig;

	const char *end;

	const char *pname;

	unsigned int offset = info->name_len + 1;

	l_string_append_printf(buf, "\t\t<method name=\"%s\">\n",

				info->metainfo);

	sig = info->metainfo + offset;

	offset += strlen(sig) + 1;

	for (; *sig; sig++) {

		end = _dbus_signature_end(sig);

		pname = info->metainfo + offset;

		l_string_append_printf(buf, "\t\t\t

					"type=\"%.*s\" direction=\"in\"/>\n",

					pname, (int) (end - sig + 1), sig);

		sig = end;

		offset += strlen(pname) + 1;

	}

	sig = info->metainfo + offset;

	offset += strlen(sig) + 1;

	for (; *sig; sig++) {

		end = _dbus_signature_end(sig);

		pname = info->metainfo + offset;

		l_string_append_printf(buf, "\t\t\t

					"type=\"%.*s\" direction=\"out\"/>\n",

					pname, (int) (end - sig + 1), sig);

		sig = end;

		offset += strlen(pname) + 1;

	}

	if (info->flags & L_DBUS_METHOD_FLAG_DEPRECATED)

		l_string_append(buf, "\t\t\t

				"org.freedesktop.DBus.Deprecated\" "

				"value=\"true\"/>\n");

	if (info->flags & L_DBUS_METHOD_FLAG_NOREPLY)

		l_string_append(buf, "\t\t\t

				"org.freedesktop.DBus.Method.NoReply\" "

				"value=\"true\"/>\n");

	l_string_append(buf, "\t\t</method>\n");

}

void _dbus_signal_introspection(struct _dbus_signal *info,

					struct l_string *buf)

{

	const char *sig;

	const char *end;

	const char *pname;

	unsigned int offset = info->name_len + 1;

	l_string_append_printf(buf, "\t\t<signal name=\"%s\">\n",

				info->metainfo);

	sig = info->metainfo + offset;

	offset += strlen(sig) + 1;

	for (; *sig; sig++) {

		end = _dbus_signature_end(sig);

		pname = info->metainfo + offset;

		l_string_append_printf(buf, "\t\t\t

					"type=\"%.*s\"/>\n",

					pname, (int) (end - sig + 1), sig);

		sig = end;

		offset += strlen(pname) + 1;

	}

	if (info->flags & L_DBUS_SIGNAL_FLAG_DEPRECATED)

		l_string_append(buf, "\t\t\t

				"org.freedesktop.DBus.Deprecated\" "

				"value=\"true\"/>\n");

	l_string_append(buf, "\t\t</signal>\n");

}

void _dbus_property_introspection(struct _dbus_property *info,

						struct l_string *buf)

{

	unsigned int offset = info->name_len + 1;

	const char *signature = info->metainfo + offset;

	l_string_append_printf(buf, "\t\t

				info->metainfo, signature);

	if (info->setter)

		l_string_append(buf, "access=\"readwrite\"");

	else

		l_string_append(buf, "access=\"read\"");

	if (info->flags & L_DBUS_METHOD_FLAG_DEPRECATED) {

		l_string_append(buf, ">\n");

		l_string_append(buf, "\t\t\t

				"org.freedesktop.DBus.Deprecated\" "

				"value=\"true\"/>\n");

		l_string_append(buf, "\t\t</property>\n");

	} else

		l_string_append(buf, "/>\n");

}

void _dbus_interface_introspection(struct l_dbus_interface *interface,

						struct l_string *buf)

{

	l_string_append_printf(buf, "\t<interface name=\"%s\">\n",

				interface->name);

	l_queue_foreach(interface->methods,

		(l_queue_foreach_func_t) _dbus_method_introspection, buf);

	l_queue_foreach(interface->signals,

		(l_queue_foreach_func_t) _dbus_signal_introspection, buf);

	l_queue_foreach(interface->properties,

		(l_queue_foreach_func_t) _dbus_property_introspection, buf);

	l_string_append(buf, "\t</interface>\n");

}

#define COPY_PARAMS(dest, signature, args)	\

	do {	\

		const char *pname;	\

		const char *sig;	\

		dest = stpcpy(dest, signature) + 1;	\

		for (sig = signature; *sig; sig++) {	\

			sig = _dbus_signature_end(sig);	\

			pname = va_arg(args, const char *);	\

			dest = stpcpy(dest, pname) + 1;	\

		}	\

	} while(0)

#define SIZE_PARAMS(signature, args)	\

	({	\

		unsigned int len = strlen(signature) + 1;	\

		const char *pname;	\

		const char *sig;	\

		for (sig = signature; *sig; sig++) {	\

			sig = _dbus_signature_end(sig);	\

			if (!sig) {	\

				len = 0;	\

				break;	\

			}	\

			pname = va_arg(args, const char *);	\

			len += strlen(pname) + 1;	\

		}	\

		len;	\

	})

LIB_EXPORT bool l_dbus_interface_method(struct l_dbus_interface *interface,

					const char *name, uint32_t flags,

					l_dbus_interface_method_cb_t cb,

					const char *return_sig,

					const char *param_sig, ...)

{

	va_list args;

	unsigned int return_info_len;

	unsigned int param_info_len;

	struct _dbus_method *info;

	char *p;

	if (!_dbus_valid_method(name))

		return false;

	if (unlikely(!return_sig || !param_sig))

		return false;

	if (return_sig[0] && !_dbus_valid_signature(return_sig))

		return false;

	if (param_sig[0] && !_dbus_valid_signature(param_sig))

		return false;

	/* Pre-calculate the needed meta-info length */

	va_start(args, param_sig);

	return_info_len = SIZE_PARAMS(return_sig, args);

	param_info_len = SIZE_PARAMS(param_sig, args);

	va_end(args);

	if (!return_info_len || !param_info_len)

		return false;

	info = l_malloc(sizeof(*info) + return_info_len +

					param_info_len + strlen(name) + 1);

	info->cb = cb;

	info->flags = flags;

	info->name_len = strlen(name);

	strcpy(info->metainfo, name);

	va_start(args, param_sig);

	/*

	 * We store param signature + parameter names first, to speed up

	 * lookups during the message dispatch procedures.

	 */

	p = info->metainfo + info->name_len + param_info_len + 1;

	COPY_PARAMS(p, return_sig, args);

	p = info->metainfo + info->name_len + 1;

	COPY_PARAMS(p, param_sig, args);

	va_end(args);

	l_queue_push_tail(interface->methods, info);

	return true;

}

LIB_EXPORT bool l_dbus_interface_signal(struct l_dbus_interface *interface,

					const char *name, uint32_t flags,

					const char *signature, ...)

{

	va_list args;

	unsigned int metainfo_len;

	struct _dbus_signal *info;

	char *p;

	if (!_dbus_valid_method(name))

		return false;

	if (unlikely(!signature))

		return false;

	if (signature[0] && !_dbus_valid_signature(signature))

		return false;

	/* Pre-calculate the needed meta-info length */

	va_start(args, signature);

	metainfo_len = SIZE_PARAMS(signature, args);

	va_end(args);

	if (!metainfo_len)

		return false;

	metainfo_len += strlen(name) + 1;

	info = l_malloc(sizeof(*info) + metainfo_len);

	info->flags = flags;

	info->name_len = strlen(name);

	p = stpcpy(info->metainfo, name) + 1;

	va_start(args, signature);

	COPY_PARAMS(p, signature, args);

	va_end(args);

	l_queue_push_tail(interface->signals, info);

	return true;

}

LIB_EXPORT bool l_dbus_interface_property(struct l_dbus_interface *interface,

					const char *name, uint32_t flags,

					const char *signature,

					l_dbus_property_get_cb_t getter,

					l_dbus_property_set_cb_t setter)

{

	unsigned int metainfo_len;

	struct _dbus_property *info;

	char *p;

	if (!_dbus_valid_method(name))

		return false;

	if (unlikely(!signature || !getter))

		return false;

	if (_dbus_num_children(signature) != 1)

		return false;

	/* Pre-calculate the needed meta-info length */

	metainfo_len = strlen(name) + 1;

	metainfo_len += strlen(signature) + 1;

	info = l_malloc(sizeof(*info) + metainfo_len);

	info->flags = flags;

	info->name_len = strlen(name);

	info->getter = getter;

	info->setter = setter;

	p = stpcpy(info->metainfo, name) + 1;

	strcpy(p, signature);

	l_queue_push_tail(interface->properties, info);

	return true;

}

struct l_dbus_interface *_dbus_interface_new(const char *name)

{

	struct l_dbus_interface *interface;

	interface = l_malloc(sizeof(*interface) + strlen(name) + 1);

	interface->methods = l_queue_new();

	interface->signals = l_queue_new();

	interface->properties = l_queue_new();

	strcpy(interface->name, name);

	return interface;

}

void _dbus_interface_free(struct l_dbus_interface *interface)

{

	l_queue_destroy(interface->methods, l_free);

	l_queue_destroy(interface->signals, l_free);

	l_queue_destroy(interface->properties, l_free);

	l_free(interface);

}

static bool match_method(const void *a, const void *b)

{

	const struct _dbus_method *method = a;

	const char *name = b;

	if (!strcmp(method->metainfo, name))

		return true;

	return false;

}

struct _dbus_method *_dbus_interface_find_method(struct l_dbus_interface *i,

							const char *method)

{

	return l_queue_find(i->methods, match_method, (char *) method);

}

static bool match_signal(const void *a, const void *b)

{

	const struct _dbus_signal *signal = a;

	const char *name = b;

	if (!strcmp(signal->metainfo, name))

		return true;

	return false;

}

struct _dbus_signal *_dbus_interface_find_signal(struct l_dbus_interface *i,

							const char *signal)

{

	return l_queue_find(i->signals, match_signal, (char *) signal);

}

static bool match_property(const void *a, const void *b)

{

	const struct _dbus_property *property = a;

	const char *name = b;

	if (!strcmp(property->metainfo, name))

		return true;

	return false;

}

struct _dbus_property *_dbus_interface_find_property(struct l_dbus_interface *i,

							const char *property)

{

	return l_queue_find(i->properties, match_property, (char *) property);

}

static void interface_instance_free(struct interface_instance *instance)

{

	if (instance->interface->instance_destroy)

		instance->interface->instance_destroy(instance->user_data);

	l_free(instance);

}

static bool match_interface_instance(const void *a, const void *b)

{

	const struct interface_instance *instance = a;

	const char *name = b;

	if (!strcmp(instance->interface->name, name))

		return true;

	return false;

}

static bool match_interface_instance_ptr(const void *a, const void *b)

{

	const struct interface_instance *instance = a;

	return instance->interface == b;

}

static void interface_add_record_free(void *data)

{

	struct interface_add_record *rec = data;

	l_free(rec->path);

	l_queue_destroy(rec->instances, NULL);

	l_free(rec);

}

static void interface_removed_record_free(void *data)

{

	struct interface_remove_record *rec = data;

	l_free(rec->path);

	l_queue_destroy(rec->interface_names, l_free);

	l_free(rec);

}

static void property_change_record_free(void *data)

{

	struct property_change_record *rec = data;

	l_free(rec->path);

	l_queue_destroy(rec->properties, NULL);

	l_free(rec);

}

static void properties_setup_func(struct l_dbus_interface *);

static void object_manager_setup_func(struct l_dbus_interface *);

struct _dbus_object_tree *_dbus_object_tree_new()

{

	struct _dbus_object_tree *tree;

	tree = l_new(struct _dbus_object_tree, 1);

	tree->interfaces = l_hashmap_new();

	l_hashmap_set_hash_function(tree->interfaces, l_str_hash);

	l_hashmap_set_compare_function(tree->interfaces,

					(l_hashmap_compare_func_t)strcmp);

	tree->objects = l_hashmap_string_new();

	tree->root = l_new(struct object_node, 1);

	tree->property_changes = l_queue_new();

	_dbus_object_tree_register_interface(tree, L_DBUS_INTERFACE_PROPERTIES,

						properties_setup_func, NULL,

						false);

	tree->object_managers = l_queue_new();

	_dbus_object_tree_register_interface(tree,

						L_DBUS_INTERFACE_OBJECT_MANAGER,

						object_manager_setup_func, NULL,

						false);

	return tree;

}

static void subtree_free(struct object_node *node)

{

	struct child_node *child;

	while (node->children) {

		child = node->children;

		node->children = child->next;

		subtree_free(child->node);

		l_free(child);

	}

	l_queue_destroy(node->instances,

			(l_queue_destroy_func_t) interface_instance_free);

	if (node->destroy)

		node->destroy(node->user_data);

	l_free(node);

}

static void object_manager_free(void *data)

{

	struct object_manager *manager = data;

	l_free(manager->path);

	l_queue_destroy(manager->announce_added, interface_add_record_free);

	l_queue_destroy(manager->announce_removed,

						interface_removed_record_free);

	l_free(manager);

}

void _dbus_object_tree_free(struct _dbus_object_tree *tree)

{

	subtree_free(tree->root);

	l_hashmap_destroy(tree->interfaces,

			(l_hashmap_destroy_func_t) _dbus_interface_free);

	l_hashmap_destroy(tree->objects, NULL);

	l_queue_destroy(tree->object_managers, object_manager_free);

	l_queue_destroy(tree->property_changes, property_change_record_free);

	if (tree->emit_signals_work)

		l_idle_remove(tree->emit_signals_work);

	l_free(tree);

}

static struct object_node *makepath_recurse(struct object_node *node,

						const char *path)

{

	const char *end;

	struct child_node *child;

	if (*path == '\0')

		return node;

	path += 1;

	end = strchrnul(path, '/');

	child = node->children;

	while (child) {

		if (!strncmp(child->subpath, path, end - path) &&

				child->subpath[end - path] == '\0')

			goto done;

		child = child->next;

	}

	child = l_malloc(sizeof(*child) + end - path + 1);

	child->node = l_new(struct object_node, 1);

	child->node->parent = node;

	memcpy(child->subpath, path, end - path);

	child->subpath[end-path] = '\0';

	child->next = node->children;

	node->children = child;

done:

	return makepath_recurse(child->node, end);

}

struct object_node *_dbus_object_tree_makepath(struct _dbus_object_tree *tree,

						const char *path)

{

	if (path[0] == '/' && path[1] == '\0')

		return tree->root;

	return makepath_recurse(tree->root, path);

}

static struct object_node *lookup_recurse(struct object_node *node,

						const char *path)

{

	const char *end;

	struct child_node *child;

	if (*path == '\0')

		return node;

	path += 1;

	end = strchrnul(path, '/');

	child = node->children;

	while (child) {

		if (!strncmp(child->subpath, path, end - path) &&

				child->subpath[end - path] == '\0')

			return lookup_recurse(child->node, end);

		child = child->next;

	}

	return NULL;

}

struct object_node *_dbus_object_tree_lookup(struct _dbus_object_tree *tree,

						const char *path)

{

	if (path[0] == '/' && path[1] == '\0')

		return tree->root;

	return lookup_recurse(tree->root, path);

}

void _dbus_object_tree_prune_node(struct object_node *node)

{

	struct object_node *parent = node->parent;

	struct child_node *p = NULL, *c;

	while (parent) {

		for (c = parent->children, p = NULL; c; p = c, c = c->next) {

			if (c->node != node)

				continue;

			if (p)

				p->next = c->next;

			else

				parent->children = c->next;

			subtree_free(c->node);

			l_free(c);

			break;

		}

		if (parent->children != NULL)

			return;

		if (parent->instances)

			return;

		node = parent;

		parent = node->parent;

	}

}

struct object_node *_dbus_object_tree_new_object(struct _dbus_object_tree *tree,

						const char *path,

						void *user_data,

						void (*destroy) (void *))

{

	struct object_node *node;

	if (!_dbus_valid_object_path(path))

		return NULL;

	if (l_hashmap_lookup(tree->objects, path))

		return NULL;

	node = _dbus_object_tree_makepath(tree, path);

	node->user_data = user_data;

	node->destroy = destroy;

	/*

	 * Registered objects in the tree are marked by being present in the

	 * tree->objects hash and having non-null node->instances.  Remaining

	 * nodes are intermediate path elements added and removed

	 * automatically.

	 */

	node->instances = l_queue_new();

	l_hashmap_insert(tree->objects, path, node);

	return node;

}

bool _dbus_object_tree_object_destroy(struct _dbus_object_tree *tree,

					const char *path)

{

	struct object_node *node;

	const struct l_queue_entry *entry;

	const struct interface_instance *instance;

	node = l_hashmap_lookup(tree->objects, path);

	if (!node)

		return false;

	while ((entry = l_queue_get_entries(node->instances))) {

		instance = entry->data;

		if (!_dbus_object_tree_remove_interface(tree, path,

						instance->interface->name))

			return false;

	}

	l_hashmap_remove(tree->objects, path);

	l_queue_destroy(node->instances, NULL);

	node->instances = NULL;

	if (node->destroy) {

		node->destroy(node->user_data);

		node->destroy = NULL;

	}

	if (!node->children)

		_dbus_object_tree_prune_node(node);

	return true;

}

static bool get_properties_dict(struct l_dbus *dbus,

				struct l_dbus_message *message,

				struct l_dbus_message_builder *builder,

				const struct l_dbus_interface *interface,

				void *user_data)

{

	const struct l_queue_entry *entry;

	const struct _dbus_property *property;

	const char *signature;

	l_dbus_message_builder_enter_array(builder, "{sv}");

	_dbus_message_builder_mark(builder);

	for (entry = l_queue_get_entries(interface->properties); entry;

			entry = entry->next) {

		property = entry->data;

		signature = property->metainfo + strlen(property->metainfo) + 1;

		l_dbus_message_builder_enter_dict(builder, "sv");

		l_dbus_message_builder_append_basic(builder, 's',

							property->metainfo);

		l_dbus_message_builder_enter_variant(builder, signature);

		if (!property->getter(dbus, message, builder, user_data)) {

			if (!_dbus_message_builder_rewind(builder))

				return false;

			continue;

		}

		l_dbus_message_builder_leave_variant(builder);

		l_dbus_message_builder_leave_dict(builder);

		_dbus_message_builder_mark(builder);

	}

	l_dbus_message_builder_leave_array(builder);

	return true;

}

static struct l_dbus_message *build_interfaces_removed_signal(

				const struct object_manager *manager,

				const struct interface_remove_record *rec)

{

	struct l_dbus_message *signal;

	struct l_dbus_message_builder *builder;

	const struct l_queue_entry *entry;

	signal = l_dbus_message_new_signal(manager->dbus, manager->path,

						L_DBUS_INTERFACE_OBJECT_MANAGER,

						"InterfacesRemoved");

	builder = l_dbus_message_builder_new(signal);

	l_dbus_message_builder_append_basic(builder, 'o', rec->path);

	l_dbus_message_builder_enter_array(builder, "s");

	for (entry = l_queue_get_entries(rec->interface_names); entry;

			entry = entry->next)

		l_dbus_message_builder_append_basic(builder, 's', entry->data);

	l_dbus_message_builder_leave_array(builder);

	l_dbus_message_builder_finalize(builder);

	l_dbus_message_builder_destroy(builder);