dbus/rpc-dbus.c

/*
 * dhcpcd - DHCP client daemon
 * Copyright (c) 2006-2015 Roy Marples <roy@marples.name>
 * All rights reserved

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

#include <dbus/dbus.h>

#include "../config.h"
#include "../eloop.h"
#include "../dhcp.h"
#ifdef INET6
#include "../dhcp6.h"
#endif
#include "../rpc-interface.h"
#include "dbus-dict.h"

#define SERVICE_NAME 	"org.chromium.dhcpcd"
#define SERVICE_PATH    "/org/chromium/dhcpcd"
#define S_EINVAL	SERVICE_NAME ".InvalidArgument"
#define S_ARGS		"Not enough arguments"

static DBusConnection *connection;
static struct dhcpcd_ctx *dhcpcd_ctx;

static const char dhcpcd_introspection_xml[] =
    "    <method name=\"GetVersion\">\n"
    "      <arg name=\"version\" direction=\"out\" type=\"s\"/>\n"
    "    </method>\n"
    "    <method name=\"Rebind\">\n"
    "      <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"
    "    </method>\n"
    "    <method name=\"Release\">\n"
    "      <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"
    "    </method>\n"
    "    <method name=\"Stop\">\n"
    "      <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"
    "    </method>\n"
    "    <signal name=\"Event\">\n"
    "      <arg name=\"configuration\" type=\"usa{sv}\"/>\n"
    "    </signal>\n"
    "    <signal name=\"StatusChanged\">\n"
    "      <arg name=\"status\" type=\"us\"/>\n"
    "    </signal>\n";

static const char service_watch_rule[] = "interface=" DBUS_INTERFACE_DBUS
	",type=signal,member=NameOwnerChanged";

static const char introspection_header_xml[] =
    "<!DOCTYPE node PUBLIC \"-//freedesktop//"
    "DTD D-BUS Object Introspection 1.0//EN\"\n"
    "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
    "<node name=\"" SERVICE_PATH "\">\n"
    "  <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
    "    <method name=\"Introspect\">\n"
    "      <arg name=\"data\" direction=\"out\" type=\"s\"/>\n"
    "    </method>\n"
    "  </interface>\n"
    "  <interface name=\"" SERVICE_NAME "\">\n";

static const char introspection_footer_xml[] =
    "  </interface>\n"
    "</node>\n";

static const struct o_dbus dhos[] = {
	{ "ip_address=", DBUS_TYPE_UINT32, 0, "IPAddress" },
	{ "server_name=", DBUS_TYPE_STRING, 0, "ServerName"},
	{ "subnet_mask=", DBUS_TYPE_UINT32, 0, "SubnetMask" },
	{ "subnet_cidr=", DBUS_TYPE_BYTE, 0, "SubnetCIDR" },
	{ "network_number=", DBUS_TYPE_UINT32, 0, "NetworkNumber" },
	{ "classless_static_routes=", DBUS_TYPE_STRING, 0,
	  "ClasslessStaticRoutes" },
	{ "ms_classless_static_routes=", DBUS_TYPE_STRING, 0,
	  "MSClasslessStaticRoutes" },
	{ "static_routes=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "StaticRoutes"} ,
	{ "routers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "Routers" },
	{ "time_offset=", DBUS_TYPE_UINT32, 0, "TimeOffset" },
	{ "time_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "TimeServers" },
	{ "ien116_name_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "IEN116NameServers" },
	{ "domain_name_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "DomainNameServers" },
	{ "log_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "LogServers" },
	{ "cookie_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "CookieServers" },
	{ "lpr_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "LPRServers" },
	{ "impress_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "ImpressServers" },
	{ "resource_location_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "ResourceLocationServers" },
	{ "host_name=", DBUS_TYPE_STRING, 0, "Hostname" },
	{ "boot_size=", DBUS_TYPE_UINT16, 0, "BootSize" },
	{ "merit_dump=", DBUS_TYPE_STRING, 0, "MeritDump" },
	{ "domain_name=", DBUS_TYPE_STRING, 0, "DomainName" },
	{ "swap_server=", DBUS_TYPE_UINT32, 0, "SwapServer" },
	{ "root_path=", DBUS_TYPE_STRING, 0, "RootPath" },
	{ "extensions_path=", DBUS_TYPE_STRING, 0, "ExtensionsPath" },
	{ "ip_forwarding=", DBUS_TYPE_BOOLEAN, 0, "IPForwarding" },
	{ "non_local_source_routing=", DBUS_TYPE_BOOLEAN, 0,
	  "NonLocalSourceRouting" },
	{ "policy_filter=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "PolicyFilter" },
	{ "max_dgram_reassembly=", DBUS_TYPE_INT16, 0,
	  "MaxDatagramReassembly" },
	{ "default_ip_ttl=", DBUS_TYPE_UINT16, 0, "DefaultIPTTL" },
	{ "path_mtu_aging_timeout=", DBUS_TYPE_UINT32, 0,
	  "PathMTUAgingTimeout" },
	{ "path_mtu_plateau_table=" ,DBUS_TYPE_ARRAY, DBUS_TYPE_UINT16,
	  "PolicyFilter"} ,
	{ "interface_mtu=", DBUS_TYPE_UINT16, 0, "InterfaceMTU" },
	{ "all_subnets_local=", DBUS_TYPE_BOOLEAN, 0, "AllSubnetsLocal" },
	{ "broadcast_address=", DBUS_TYPE_UINT32, 0, "BroadcastAddress" },
	{ "perform_mask_discovery=", DBUS_TYPE_BOOLEAN, 0,
	  "PerformMaskDiscovery" },
	{ "mask_supplier=", DBUS_TYPE_BOOLEAN, 0, "MaskSupplier" },
	{ "router_discovery=", DBUS_TYPE_BOOLEAN, 0, "RouterDiscovery" },
	{ "router_solicitiation_address=", DBUS_TYPE_UINT32, 0,
	  "RouterSolicationAddress" },
	{ "trailer_encapsulation=", DBUS_TYPE_BOOLEAN, 0,
	  "TrailerEncapsulation" },
	{ "arp_cache_timeout=", DBUS_TYPE_UINT32, 0, "ARPCacheTimeout" },
	{ "ieee802_3_encapsulation=", DBUS_TYPE_UINT16, 0,
	  "IEEE8023Encapsulation" },
	{ "default_tcp_ttl=", DBUS_TYPE_BYTE, 0, "DefaultTCPTTL" },
	{ "tcp_keepalive_interval=", DBUS_TYPE_UINT32, 0,
	  "TCPKeepAliveInterval" },
	{ "tcp_keepalive_garbage=", DBUS_TYPE_BOOLEAN, 0,
	  "TCPKeepAliveGarbage" },
	{ "nis_domain=", DBUS_TYPE_STRING, 0, "NISDomain" },
	{ "nis_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "NISServers" },
	{ "ntp_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "NTPServers" },
	{ "vendor_encapsulated_options=", DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
	  "VendorEncapsulatedOptions" },
	{ "netbios_name_servers=" ,DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "NetBIOSNameServers" },
	{ "netbios_dd_server=", DBUS_TYPE_UINT32, 0, "NetBIOSDDServer" },
	{ "netbios_node_type=", DBUS_TYPE_BYTE, 0, "NetBIOSNodeType" },
	{ "netbios_scope=", DBUS_TYPE_STRING, 0, "NetBIOSScope" },
	{ "font_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "FontServers" },
	{ "x_display_manager=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "XDisplayManager" },
	{ "dhcp_requested_address=", DBUS_TYPE_UINT32, 0,
	  "DHCPRequestedAddress" },
	{ "dhcp_lease_time=", DBUS_TYPE_UINT32, 0, "DHCPLeaseTime" },
	{ "dhcp_option_overload=", DBUS_TYPE_BOOLEAN, 0,
	  "DHCPOptionOverload" },
	{ "dhcp_message_type=", DBUS_TYPE_BYTE, 0, "DHCPMessageType" },
	{ "dhcp_server_identifier=", DBUS_TYPE_UINT32, 0,
	  "DHCPServerIdentifier" },
	{ "dhcp_message=", DBUS_TYPE_STRING, 0, "DHCPMessage" },
	{ "dhcp_max_message_size=", DBUS_TYPE_UINT16, 0,
	  "DHCPMaxMessageSize" },
	{ "dhcp_renewal_time=", DBUS_TYPE_UINT32, 0, "DHCPRenewalTime" },
	{ "dhcp_rebinding_time=", DBUS_TYPE_UINT32, 0, "DHCPRebindingTime" },
	{ "nisplus_domain=", DBUS_TYPE_STRING, 0, "NISPlusDomain" },
	{ "nisplus_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "NISPlusServers" },
	{ "tftp_server_name=", DBUS_TYPE_STRING, 0, "TFTPServerName" },
	{ "bootfile_name=", DBUS_TYPE_STRING, 0, "BootFileName" },
	{ "mobile_ip_home_agent=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "MobileIPHomeAgent" },
	{ "smtp_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "SMTPServer" },
	{ "pop_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "POPServer" },
	{ "nntp_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "NNTPServer" },
	{ "www_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "WWWServer" },
	{ "finger_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "FingerServer" },
	{ "irc_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "IRCServer" },
	{ "streettalk_server=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "StreetTalkServer" },
	{ "streettalk_directory_assistance_server=", DBUS_TYPE_ARRAY,
	  DBUS_TYPE_UINT32, "StreetTalkDirectoryAssistanceServer" },
	{ "user_class=", DBUS_TYPE_STRING, 0, "UserClass" },
	{ "new_fqdn_name=", DBUS_TYPE_STRING, 0, "FQDNName" },
	{ "nds_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "NDSServers" },
	{ "nds_tree_name=", DBUS_TYPE_STRING, 0, "NDSTreeName" },
	{ "nds_context=", DBUS_TYPE_STRING, 0, "NDSContext" },
	{ "bcms_controller_names=", DBUS_TYPE_STRING, 0,
	  "BCMSControllerNames" },
	{ "client_last_transaction_time=", DBUS_TYPE_UINT32, 0,
	  "ClientLastTransactionTime" },
	{ "associated_ip=", DBUS_TYPE_UINT32, 0, "AssociatedIP" },
	{ "uap_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, "UAPServers" },
	{ "netinfo_server_address=", DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
	  "NetinfoServerAddress" },
	{ "netinfo_server_tag=", DBUS_TYPE_STRING, 0, "NetinfoServerTag" },
	{ "default_url=", DBUS_TYPE_STRING, 0, "DefaultURL" },
	{ "subnet_selection=", DBUS_TYPE_UINT32, 0, "SubnetSelection" },
	{ "domain_search=", DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
	  "DomainSearch" },
	{ "wpad_url=", DBUS_TYPE_STRING, 0, "WebProxyAutoDiscoveryUrl" },
#ifdef INET6
	{ "dhcp6_server_id=", DBUS_TYPE_STRING, 0,
	  "DHCPv6ServerIdentifier" },
	{ "dhcp6_ia_na1_ia_addr1=", DBUS_TYPE_STRING, 0, "DHCPv6Address" },
	{ "dhcp6_ia_na1_ia_addr1_vltime=", DBUS_TYPE_UINT32, 0,
	  "DHCPv6AddressLeaseTime" },
	{ "dhcp6_name_servers=", DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
	  "DHCPv6NameServers" },
	{ "dhcp6_domain_search=", DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
	  "DHCPv6DomainSearch" },
	{ "dhcp6_ia_pd1_prefix1=", DBUS_TYPE_STRING, 0,
	  "DHCPv6DelegatedPrefix" },
	{ "dhcp6_ia_pd1_prefix1_length=", DBUS_TYPE_UINT32, 0,
	  "DHCPv6DelegatedPrefixLength" },
	{ "dhcp6_ia_pd1_prefix1_vltime=", DBUS_TYPE_UINT32, 0,
	  "DHCPv6DelegatedPrefixLeaseTime" },
#endif
	{ NULL, 0, 0, NULL }
};

static int
append_config(DBusMessageIter *iter,
    const char *prefix, char **env, ssize_t elen)
{
	char **eenv, *p;
	const struct o_dbus *dhop;
	size_t l, lp;
	int retval;

	retval = 0;
	lp = strlen(prefix);
	for (eenv = env + elen; env < eenv; env++) {
		p = env[0];
		for (dhop = dhos; dhop->var; dhop++) {
			l = strlen(dhop->var);
			if (strncmp(p, dhop->var, l) == 0) {
				retval = dict_append_config_item(iter,
				    dhop, p + l);
				break;
			}
			if (strncmp(p, prefix, lp) == 0 &&
			    strncmp(p + lp, dhop->var, l) == 0)
			{
				retval = dict_append_config_item(iter,
				    dhop, p + l + lp);
				break;
			}
		}
		if (retval == -1)
			break;
	}
	return retval;
}

static DBusHandlerResult
get_dbus_error(DBusConnection *con, DBusMessage *msg,
		  const char *name, const char *fmt, ...)
{
	char buffer[1024];
	DBusMessage *reply;
	va_list args;

	va_start(args, fmt);
	vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);
	reply = dbus_message_new_error(msg, name, buffer);
	dbus_connection_send(con, reply, NULL);
	dbus_message_unref(reply);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static dbus_bool_t
dbus_send_message(const struct interface *ifp, const char *reason,
    const char *prefix, struct dhcp_message *message)
{
	const struct if_options *ifo = ifp->options;
	DBusMessage* msg;
	DBusMessageIter args, dict;
	int pid = getpid();
	char **env = NULL;
	ssize_t e, elen;
	int retval;
	int success = FALSE;

	syslog(LOG_INFO, "event %s on interface %s", reason, ifp->name);

	msg = dbus_message_new_signal(SERVICE_PATH, SERVICE_NAME, "Event");
	if (msg == NULL) {
		syslog(LOG_ERR, "failed to make a configure message");
		return FALSE;
	}
	dbus_message_iter_init_append(msg, &args);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &pid);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &reason);
	dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
	    DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
	    DBUS_TYPE_STRING_AS_STRING
	    DBUS_TYPE_VARIANT_AS_STRING
	    DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	    &dict);
	if (prefix == NULL || message == NULL)
		retval = 0;
	else {
		e = dhcp_env(NULL, NULL, message, ifp);
		if (e > 0) {
			char *config_prefix = strdup(prefix);
			if (config_prefix == NULL) {
				logger(dhcpcd_ctx, LOG_ERR,
				       "Memory exhausted (strdup)");
				eloop_exit(dhcpcd_ctx->eloop, EXIT_FAILURE);
			}
			char *p = config_prefix + strlen(config_prefix) - 1;
			if (p >= config_prefix && *p == '_')
				*p = '\0';
			env = calloc(e + 1, sizeof(char *));
			if (env == NULL) {
				logger(dhcpcd_ctx, LOG_ERR,
				       "Memory exhausted (calloc)");
				eloop_exit(dhcpcd_ctx->eloop, EXIT_FAILURE);
			}
			elen = dhcp_env(env, config_prefix, message, ifp);
			free(config_prefix);
		}
		retval = append_config(&dict, prefix, env, elen);
	}

	/* Release memory allocated for env. */
	if (env) {
		char **current = env;
		while (*current)
			free(*current++);
		free(env);
	}

	dbus_message_iter_close_container(&args, &dict);
	if (retval == 0) {
		success = dbus_connection_send(connection, msg, NULL);
		if (!success)
			syslog(LOG_ERR, "failed to send dhcp to dbus");
	} else
		syslog(LOG_ERR, "failed to construct dbus message");
	dbus_message_unref(msg);

	return success;
}

#ifdef INET6
static dbus_bool_t
dbus_send_dhcpv6_message(const struct interface *ifp, const char *reason,
    const char *prefix, struct dhcp6_message *message, size_t length)
{
	const struct if_options *ifo = ifp->options;
	DBusMessage* msg;
	DBusMessageIter args, dict;
	int pid = getpid();
	char **env = NULL;
	ssize_t e, elen;
	int retval;
	int success = FALSE;

	syslog(LOG_INFO, "event %s on interface %s", reason, ifp->name);

	msg = dbus_message_new_signal(SERVICE_PATH, SERVICE_NAME, "Event");
	if (msg == NULL) {
		syslog(LOG_ERR, "failed to make a configure message");
		return FALSE;
	}
	dbus_message_iter_init_append(msg, &args);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &pid);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &reason);
	dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
	    DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
	    DBUS_TYPE_STRING_AS_STRING
	    DBUS_TYPE_VARIANT_AS_STRING
	    DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	    &dict);
	if (prefix == NULL || message == NULL)
		retval = 0;
	else {
		e = dhcp6_env(NULL, NULL, ifp, message, length);
		if (e > 0) {
			char *config_prefix = strdup(prefix);
			if (config_prefix == NULL) {
				logger(dhcpcd_ctx, LOG_ERR,
				       "Memory exhausted (strdup)");
				eloop_exit(dhcpcd_ctx->eloop, EXIT_FAILURE);
			}
			char *p = config_prefix + strlen(config_prefix) - 1;
			if (p >= config_prefix && *p == '_')
				*p = '\0';
			env = calloc(e + 1, sizeof(char *));
			if (env == NULL) {
				logger(dhcpcd_ctx, LOG_ERR,
				       "Memory exhausted (calloc)");
				eloop_exit(dhcpcd_ctx->eloop, EXIT_FAILURE);
			}
			elen = dhcp6_env(env, "new", ifp, message, length);
			free(config_prefix);
		}
		retval = append_config(&dict, prefix, env, elen);
	}

	/* Release memory allocated for env. */
	if (env) {
		char **current = env;
		while (*current)
			free(*current++);
		free(env);
	}

	dbus_message_iter_close_container(&args, &dict);
	if (retval == 0) {
		success = dbus_connection_send(connection, msg, NULL);
		if (!success)
			syslog(LOG_ERR, "failed to send dhcpv6 to dbus");
	} else
		syslog(LOG_ERR, "failed to construct dbus message");
	dbus_message_unref(msg);

	return success;
}
#endif

static DBusHandlerResult
introspect(DBusConnection *con, DBusMessage *msg)
{
	DBusMessage *reply;
	char *xml;
	size_t len;

	len = sizeof(introspection_header_xml) - 1
	    + sizeof(dhcpcd_introspection_xml) - 1
	    + sizeof(introspection_footer_xml) - 1
	    + 1; /* terminal \0 */
	xml = malloc(len);
	if (xml == NULL)
		return DBUS_HANDLER_RESULT_HANDLED;
	snprintf(xml, len, "%s%s%s",
	    introspection_header_xml,
	    dhcpcd_introspection_xml,
	    introspection_footer_xml);
	reply = dbus_message_new_method_return(msg);
	dbus_message_append_args(reply,
	    DBUS_TYPE_STRING, &xml,
	    DBUS_TYPE_INVALID);
	dbus_connection_send(con, reply, NULL);
	dbus_message_unref(reply);
	free(xml);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
version(DBusConnection *con, DBusMessage *msg, const char *ver)
{
	DBusMessage *reply;

	reply = dbus_message_new_method_return(msg);
	dbus_message_append_args(reply,
	    DBUS_TYPE_STRING, &ver,
	    DBUS_TYPE_INVALID);
	dbus_connection_send(con, reply, NULL);
	dbus_message_unref(reply);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
dbus_ack(DBusConnection *con, DBusMessage *msg)
{
	DBusMessage *reply;

	reply = dbus_message_new_method_return(msg);
	dbus_connection_send(con, reply, NULL);
	dbus_message_unref(reply);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
msg_handler(DBusConnection *con, DBusMessage *msg, __unused void *data)
{
#define	IsMethod(msg, method) \
	dbus_message_is_method_call(msg, SERVICE_NAME, method)

	if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE,
					"Introspect")) {
		return introspect(con, msg);
	} else if (IsMethod(msg, "GetVersion")) {
		return version(con, msg, VERSION);
	} else if (IsMethod(msg, "Rebind")) {
		const char *iface_name;
		if (!dbus_message_get_args(msg, NULL,
				   DBUS_TYPE_STRING, &iface_name,
				   DBUS_TYPE_INVALID)) {
			logger(dhcpcd_ctx, LOG_ERR,
			       "Invalid arguments for Rebind");
			return get_dbus_error(con, msg, S_EINVAL, S_ARGS);
		}
		dhcpcd_start_interface(dhcpcd_ctx, iface_name);
		return dbus_ack(con, msg);
	} else if (IsMethod(msg, "Release")) {
		const char *iface_name;
		if (!dbus_message_get_args(msg, NULL,
				   DBUS_TYPE_STRING, &iface_name,
				   DBUS_TYPE_INVALID)) {
			logger(dhcpcd_ctx, LOG_ERR,
			       "Invalid arguments for Release");
			return get_dbus_error(con, msg, S_EINVAL, S_ARGS);
		}
		dhcpcd_release_ipv4(dhcpcd_ctx, iface_name);
		return dbus_ack(con, msg);
	} else if (IsMethod(msg, "Stop")) {
		const char *iface_name;
		if (!dbus_message_get_args(msg, NULL,
				   DBUS_TYPE_STRING, &iface_name,
				   DBUS_TYPE_INVALID)) {
			logger(dhcpcd_ctx, LOG_ERR,
			       "Invalid arguments for Stop");
			return get_dbus_error(con, msg, S_EINVAL, S_ARGS);
		}
		dhcpcd_stop_interface(dhcpcd_ctx, iface_name);
		(void) dbus_ack(con, msg);
		exit(EXIT_FAILURE);
	} else if (dbus_message_is_signal(msg, DBUS_INTERFACE_LOCAL,
					  "Disconnected")) {
		dhcpcd_stop_interfaces(dhcpcd_ctx);
		exit(EXIT_FAILURE);
	}
	return get_dbus_error(con, msg, S_EINVAL, S_ARGS);
#undef IsMethod
}

static void
dbus_handle_event(DBusWatch *watch, int flags)
{
	dbus_watch_handle((DBusWatch *)watch, flags);

	if (connection != NULL) {
		dbus_connection_ref(connection);
		while (dbus_connection_dispatch(connection) ==
				DBUS_DISPATCH_DATA_REMAINS)
				;
		dbus_connection_unref(connection);
	}
}

static void
dbus_read_event(void *watch)
{
	dbus_handle_event((DBusWatch *)watch, DBUS_WATCH_READABLE);
}

static void
dbus_write_event(void *watch)
{
	dbus_handle_event((DBusWatch *)watch, DBUS_WATCH_WRITABLE);
}

static dbus_bool_t
add_watch(DBusWatch *watch, __unused void *data)
{
	int fd, flags;
	void (*read_event)(void *) = NULL;
	void *read_arg = NULL;
	void (*write_event)(void *) = NULL;
	void *write_arg = NULL;

	fd = dbus_watch_get_unix_fd(watch);
	flags = dbus_watch_get_flags(watch);
	if (flags & DBUS_WATCH_READABLE) {
		read_event = dbus_read_event;
		read_arg = watch;
	}
	if (flags & DBUS_WATCH_WRITABLE) {
		write_event = dbus_write_event;
		write_arg = watch;
	}

	if (eloop_event_add(dhcpcd_ctx->eloop, fd, read_event, read_arg,
			    write_event, write_arg) == 0)
		return TRUE;
	return FALSE;
}

static void
remove_watch(DBusWatch *watch, __unused void *data)
{
	int fd, flags;
	int write_only = 0;
	fd = dbus_watch_get_unix_fd(watch);
	flags = dbus_watch_get_flags(watch);
	if (!(flags & DBUS_WATCH_READABLE) && (flags & DBUS_WATCH_WRITABLE))
		write_only = 1;
	eloop_event_delete(dhcpcd_ctx->eloop, fd, write_only);
}

static DBusHandlerResult
dhcpcd_dbus_filter(DBusConnection *conn, DBusMessage *msg, void *user_data)
{
	const char *service = NULL;
	const char *old_owner = NULL;
	const char *new_owner = NULL;

	if (!dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS,
				    "NameOwnerChanged"))
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

	if (!dbus_message_get_args(msg, NULL,
				   DBUS_TYPE_STRING, &service,
				   DBUS_TYPE_STRING, &old_owner,
				   DBUS_TYPE_STRING, &new_owner,
				   DBUS_TYPE_INVALID)) {
		syslog(LOG_ERR,
		       "Invalid arguments for NameOwnerChanged signal");
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}
	if (strcmp(service, "org.chromium.flimflam") == 0 &&
	    strlen(new_owner) == 0) {
		syslog(LOG_INFO, "exiting because flimflamd has died");
		dhcpcd_stop_interfaces(dhcpcd_ctx);
		exit(EXIT_FAILURE);
	}
	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

int
rpc_init(struct dhcpcd_ctx *ctx)
{
	DBusObjectPathVTable vt = {
		NULL, &msg_handler, NULL, NULL, NULL, NULL
	};
	DBusError err;
	int ret;

	dhcpcd_ctx = ctx;

	dbus_error_init(&err);
	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
	if (connection == NULL) {
		if (dbus_error_is_set(&err))
			syslog(LOG_ERR, "%s", err.message);
		else
			syslog(LOG_ERR, "failed to get a dbus connection");
		return -1;
	}
	atexit(rpc_close);

	if (!dbus_connection_set_watch_functions(connection,
		add_watch, remove_watch, NULL, NULL, NULL))
	{
		syslog(LOG_ERR, "dbus: failed to set watch functions");
		return -1;
	}
	if (!dbus_connection_register_object_path(connection,
		SERVICE_PATH, &vt, NULL))
	{
		syslog(LOG_ERR, "dbus: failed to register object path");
		return -1;
	}
	dbus_connection_add_filter(connection, dhcpcd_dbus_filter, NULL, NULL);
	dbus_bus_add_match(connection, service_watch_rule, &err);
	if (dbus_error_is_set(&err)) {
		syslog(LOG_ERR, "Cannot add rule: %s", err.message);
		return -1;
	}
	return 0;
}

void
rpc_close(void)
{
	if (connection) {
		dbus_bus_remove_match(connection, service_watch_rule, NULL);
		dbus_connection_remove_filter(connection,
					      dhcpcd_dbus_filter,
					      NULL);
		dbus_connection_unref(connection);
		connection = NULL;
	}
}

void
rpc_signal_status(const char *status)
{
	DBusMessage *msg;
	DBusMessageIter args;
	int pid = getpid();

	syslog(LOG_INFO, "status changed to %s", status);

	msg = dbus_message_new_signal(SERVICE_PATH, SERVICE_NAME,
	    "StatusChanged");
	if (msg == NULL) {
		syslog(LOG_ERR, "failed to make a status changed message");
		return;
	}
	dbus_message_iter_init_append(msg, &args);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &pid);
	dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &status);
	if (!dbus_connection_send(connection, msg, NULL))
		syslog(LOG_ERR, "failed to send status to dbus");
	dbus_message_unref(msg);
}


int
rpc_update_ipv4(struct interface *ifp)
{
	struct dhcp_state *state = D_STATE(ifp);
	if (state->new != NULL) {
		/* push state over d-bus */
		dbus_send_message(ifp, state->reason, "new_", state->new);
		rpc_signal_status("Bound");
	} else {
		rpc_signal_status("Release");
	}
	return 0;
}

#ifdef INET6
int
rpc_update_ipv6(struct interface *ifp)
{
	struct dhcp6_state *state = D6_STATE(ifp);
	if (state->new != NULL) {
		/* push state over d-bus */
		dbus_send_dhcpv6_message(ifp, state->reason, "new_",
					 state->new, state->new_len);
		rpc_signal_status("Bound6");
	} else {
		rpc_signal_status("Release6");
	}
	return 0;
}
#endif

int
rpc_notify_unicast_arp(struct interface *ifp) {
	struct dhcp_state *state = D_STATE(ifp);
	return dbus_send_message(ifp, "GATEWAY-ARP", "saved_", state->offer);
}