src/dbus.c - vendor/opensource/dnsmasq - Git at Google

 /* dnsmasq is Copyright (c) 2000-2014 Simon Kelley

    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; version 2 dated June, 1991, or
    (at your option) version 3 dated 29 June, 2007.

    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, see <http://www.gnu.org/licenses/>.
 */

 #include "dnsmasq.h"

 #ifdef HAVE_DBUS

 #include <dbus/dbus.h>

 const char* introspection_xml_template =
 "<!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=\"" DNSMASQ_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=\"%s\">\n"
 "    <method name=\"ClearCache\">\n"
 "    </method>\n"
 "    <method name=\"GetVersion\">\n"
 "      <arg name=\"version\" direction=\"out\" type=\"s\"/>\n"
 "    </method>\n"
 "    <method name=\"SetServers\">\n"
 "      <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n"
 "    </method>\n"
 "    <method name=\"SetDomainServers\">\n"
 "      <arg name=\"servers\" direction=\"in\" type=\"as\"/>\n"
 "    </method>\n"
 "    <method name=\"SetServersEx\">\n"
 "      <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n"
 "    </method>\n"
 "    <method name=\"SetFilterWin2KOption\">\n"
 "      <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n"
 "    </method>\n"
 "    <method name=\"SetBogusPrivOption\">\n"
 "      <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n"
 "    </method>\n"
 "    <signal name=\"DhcpLeaseAdded\">\n"
 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
 "      <arg name=\"hostname\" type=\"s\"/>\n"
 "    </signal>\n"
 "    <signal name=\"DhcpLeaseDeleted\">\n"
 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
 "      <arg name=\"hostname\" type=\"s\"/>\n"
 "    </signal>\n"
 "    <signal name=\"DhcpLeaseUpdated\">\n"
 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
 "      <arg name=\"hostname\" type=\"s\"/>\n"
 "    </signal>\n"
 "  </interface>\n"
 "</node>\n";

 static char *introspection_xml = NULL;

 struct watch {
   DBusWatch *watch;
   struct watch *next;
 };


 static dbus_bool_t add_watch(DBusWatch *watch, void *data)
 {
   struct watch *w;

   for (w = daemon->watches; w; w = w->next)
     if (w->watch == watch)
       return TRUE;

   if (!(w = whine_malloc(sizeof(struct watch))))
     return FALSE;

   w->watch = watch;
   w->next = daemon->watches;
   daemon->watches = w;

   w = data; /* no warning */
   return TRUE;
 }

 static void remove_watch(DBusWatch *watch, void *data)
 {
   struct watch **up, *w, *tmp;

   for (up = &(daemon->watches), w = daemon->watches; w; w = tmp)
     {
       tmp = w->next;
       if (w->watch == watch)
 	{
 	  *up = tmp;
 	  free(w);
 	}
       else
 	up = &(w->next);
     }

   w = data; /* no warning */
 }

 static void dbus_read_servers(DBusMessage *message)
 {
   DBusMessageIter iter;
   union  mysockaddr addr, source_addr;
   char *domain;

   dbus_message_iter_init(message, &iter);

   mark_servers(SERV_FROM_DBUS);

   while (1)
     {
       int skip = 0;

       if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
 	{
 	  u32 a;

 	  dbus_message_iter_get_basic(&iter, &a);
 	  dbus_message_iter_next (&iter);

 #ifdef HAVE_SOCKADDR_SA_LEN
 	  source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
 #endif
 	  addr.in.sin_addr.s_addr = ntohl(a);
 	  source_addr.in.sin_family = addr.in.sin_family = AF_INET;
 	  addr.in.sin_port = htons(NAMESERVER_PORT);
 	  source_addr.in.sin_addr.s_addr = INADDR_ANY;
 	  source_addr.in.sin_port = htons(daemon->query_port);
 	}
       else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
 	{
 	  unsigned char p[sizeof(struct in6_addr)];
 	  unsigned int i;

 	  skip = 1;

 	  for(i = 0; i < sizeof(struct in6_addr); i++)
 	    {
 	      dbus_message_iter_get_basic(&iter, &p[i]);
 	      dbus_message_iter_next (&iter);
 	      if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
 		break;
 	    }

 #ifndef HAVE_IPV6
 	  my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
 #else
 	  if (i == sizeof(struct in6_addr)-1)
 	    {
 	      memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
 #ifdef HAVE_SOCKADDR_SA_LEN
               source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
 #endif
               source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
               addr.in6.sin6_port = htons(NAMESERVER_PORT);
               source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
 	      source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
               source_addr.in6.sin6_addr = in6addr_any;
               source_addr.in6.sin6_port = htons(daemon->query_port);
 	      skip = 0;
 	    }
 #endif
 	}
       else
 	/* At the end */
 	break;

       /* process each domain */
       do {
 	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
 	  {
 	    dbus_message_iter_get_basic(&iter, &domain);
 	    dbus_message_iter_next (&iter);
 	  }
 	else
 	  domain = NULL;

 	if (!skip)
 	  add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);

       } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
     }

   /* unlink and free anything still marked. */
   cleanup_servers();
 }

 static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
 {
   DBusMessageIter iter, array_iter, string_iter;
   DBusMessage *error = NULL;
   const char *addr_err;
   char *dup = NULL;

   if (!dbus_message_iter_init(message, &iter))
     {
       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
                                     "Failed to initialize dbus message iter");
     }

   /* check that the message contains an array of arrays */
   if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
       (dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
     {
       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
                                     strings ? "Expected array of string" : "Expected array of string arrays");
      }

   mark_servers(SERV_FROM_DBUS);

   /* array_iter points to each "as" element in the outer array */
   dbus_message_iter_recurse(&iter, &array_iter);
   while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
     {
       const char *str = NULL;
       union  mysockaddr addr, source_addr;
       int flags = 0;
       char interface[IF_NAMESIZE];
       char *str_addr, *str_domain = NULL;

       if (strings)
 	{
 	  dbus_message_iter_get_basic(&array_iter, &str);
 	  if (!str || !strlen (str))
 	    {
 	      error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 					     "Empty string");
 	      break;
 	    }

 	  /* dup the string because it gets modified during parsing */
 	  if (dup)
 	    free(dup);
 	  if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
 	    break;

 	  strcpy(str_domain, str);

 	  /* point to address part of old string for error message */
 	  if ((str_addr = strrchr(str, '/')))
 	    str = str_addr+1;

 	  if ((str_addr = strrchr(str_domain, '/')))
 	    {
 	      if (*str_domain != '/' || str_addr == str_domain)
 		{
 		  error = dbus_message_new_error_printf(message,
 							DBUS_ERROR_INVALID_ARGS,
 							"No domain terminator '%s'",
 							str);
 		  break;
 		}
 	      *str_addr++ = 0;
 	      str_domain++;
 	    }
 	  else
 	    {
 	      str_addr = str_domain;
 	      str_domain = NULL;
 	    }


 	}
       else
 	{
 	  /* check the types of the struct and its elements */
 	  if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
 	      (dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
 	    {
 	      error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 					     "Expected inner array of strings");
 	      break;
 	    }

 	  /* string_iter points to each "s" element in the inner array */
 	  dbus_message_iter_recurse(&array_iter, &string_iter);
 	  if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
 	    {
 	      /* no IP address given */
 	      error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 					     "Expected IP address");
 	      break;
 	    }

 	  dbus_message_iter_get_basic(&string_iter, &str);
 	  if (!str || !strlen (str))
 	    {
 	      error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 					     "Empty IP address");
 	      break;
 	    }

 	  /* dup the string because it gets modified during parsing */
 	  if (dup)
 	    free(dup);
 	  if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
 	    break;

 	  strcpy(str_addr, str);
 	}

       memset(&addr, 0, sizeof(addr));
       memset(&source_addr, 0, sizeof(source_addr));
       memset(&interface, 0, sizeof(interface));

       /* parse the IP address */
       if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
 	{
           error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                 "Invalid IP address '%s': %s",
                                                 str, addr_err);
           break;
         }

       /* 0.0.0.0 for server address == NULL, for Dbus */
       if (addr.in.sin_family == AF_INET &&
           addr.in.sin_addr.s_addr == 0)
         flags |= SERV_NO_ADDR;

       if (strings)
 	{
 	  char *p;

 	  do {
 	    if (str_domain)
 	      {
 		if ((p = strchr(str_domain, '/')))
 		  *p++ = 0;
 	      }
 	    else
 	      p = NULL;

 	    add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
 	  } while ((str_domain = p));
 	}
       else
 	{
 	  /* jump past the address to the domain list (if any) */
 	  dbus_message_iter_next (&string_iter);

 	  /* parse domains and add each server/domain pair to the list */
 	  do {
 	    str = NULL;
 	    if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
 	      dbus_message_iter_get_basic(&string_iter, &str);
 	    dbus_message_iter_next (&string_iter);

 	    add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
 	  } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
 	}

       /* jump to next element in outer array */
       dbus_message_iter_next(&array_iter);
     }

   cleanup_servers();

   if (dup)
     free(dup);

   return error;
 }

 static DBusMessage *dbus_set_bool(DBusMessage *message, int flag, char *name)
 {
   DBusMessageIter iter;
   dbus_bool_t enabled;

   if (!dbus_message_iter_init(message, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected boolean argument");

   dbus_message_iter_get_basic(&iter, &enabled);

   if (enabled)
     {
       my_syslog(LOG_INFO, "Enabling --%s option from D-Bus", name);
       set_option_bool(flag);
     }
   else
     {
       my_syslog(LOG_INFO, "Disabling --$s option from D-Bus", name);
       reset_option_bool(flag);
     }

   return NULL;
 }

 DBusHandlerResult message_handler(DBusConnection *connection,
 				  DBusMessage *message,
 				  void *user_data)
 {
   char *method = (char *)dbus_message_get_member(message);
   DBusMessage *reply = NULL;
   int clear_cache = 0, new_servers = 0;

   if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
     {
       /* string length: "%s" provides space for termination zero */
       if (!introspection_xml &&
 	  (introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name))))
 	sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name);

       if (introspection_xml)
 	{
 	  reply = dbus_message_new_method_return(message);
 	  dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
 	}
     }
   else if (strcmp(method, "GetVersion") == 0)
     {
       char *v = VERSION;
       reply = dbus_message_new_method_return(message);

       dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID);
     }
   else if (strcmp(method, "SetServers") == 0)
     {
       dbus_read_servers(message);
       new_servers = 1;
     }
   else if (strcmp(method, "SetServersEx") == 0)
     {
       reply = dbus_read_servers_ex(message, 0);
       new_servers = 1;
     }
   else if (strcmp(method, "SetDomainServers") == 0)
     {
       reply = dbus_read_servers_ex(message, 1);
       new_servers = 1;
     }
   else if (strcmp(method, "SetFilterWin2KOption") == 0)
     {
       reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k");
     }
   else if (strcmp(method, "SetBogusPrivOption") == 0)
     {
       reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv");
     }
   else if (strcmp(method, "ClearCache") == 0)
     clear_cache = 1;
   else
     return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);

   if (new_servers)
     {
       my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
       check_servers();
       if (option_bool(OPT_RELOAD))
 	clear_cache = 1;
     }

   if (clear_cache)
     clear_cache_and_reload(dnsmasq_time());

   method = user_data; /* no warning */

   /* If no reply or no error, return nothing */
   if (!reply)
     reply = dbus_message_new_method_return(message);

   if (reply)
     {
       dbus_connection_send (connection, reply, NULL);
       dbus_message_unref (reply);
     }

   return (DBUS_HANDLER_RESULT_HANDLED);
 }


 /* returns NULL or error message, may fail silently if dbus daemon not yet up. */
 char *dbus_init(void)
 {
   DBusConnection *connection = NULL;
   DBusObjectPathVTable dnsmasq_vtable = {NULL, &message_handler, NULL, NULL, NULL, NULL };
   DBusError dbus_error;
   DBusMessage *message;

   dbus_error_init (&dbus_error);
   if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
     return NULL;

   dbus_connection_set_exit_on_disconnect(connection, FALSE);
   dbus_connection_set_watch_functions(connection, add_watch, remove_watch,
 				      NULL, NULL, NULL);
   dbus_error_init (&dbus_error);
   dbus_bus_request_name (connection, daemon->dbus_name, 0, &dbus_error);
   if (dbus_error_is_set (&dbus_error))
     return (char *)dbus_error.message;

   if (!dbus_connection_register_object_path(connection,  DNSMASQ_PATH,
 					    &dnsmasq_vtable, NULL))
     return _("could not register a DBus message handler");

   daemon->dbus = connection;

   if ((message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, "Up")))
     {
       dbus_connection_send(connection, message, NULL);
       dbus_message_unref(message);
     }

   return NULL;
 }


 void set_dbus_listeners(int *maxfdp,
 			fd_set *rset, fd_set *wset, fd_set *eset)
 {
   struct watch *w;

   for (w = daemon->watches; w; w = w->next)
     if (dbus_watch_get_enabled(w->watch))
       {
 	unsigned int flags = dbus_watch_get_flags(w->watch);
 	int fd = dbus_watch_get_unix_fd(w->watch);

 	bump_maxfd(fd, maxfdp);

 	if (flags & DBUS_WATCH_READABLE)
 	  FD_SET(fd, rset);

 	if (flags & DBUS_WATCH_WRITABLE)
 	  FD_SET(fd, wset);

 	FD_SET(fd, eset);
       }
 }

 void check_dbus_listeners(fd_set *rset, fd_set *wset, fd_set *eset)
 {
   DBusConnection *connection = (DBusConnection *)daemon->dbus;
   struct watch *w;

   for (w = daemon->watches; w; w = w->next)
     if (dbus_watch_get_enabled(w->watch))
       {
 	unsigned int flags = 0;
 	int fd = dbus_watch_get_unix_fd(w->watch);

 	if (FD_ISSET(fd, rset))
 	  flags |= DBUS_WATCH_READABLE;

 	if (FD_ISSET(fd, wset))
 	  flags |= DBUS_WATCH_WRITABLE;

 	if (FD_ISSET(fd, eset))
 	  flags |= DBUS_WATCH_ERROR;

 	if (flags != 0)
 	  dbus_watch_handle(w->watch, flags);
       }

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

 #ifdef HAVE_DHCP
 void emit_dbus_signal(int action, struct dhcp_lease *lease, char *hostname)
 {
   DBusConnection *connection = (DBusConnection *)daemon->dbus;
   DBusMessage* message = NULL;
   DBusMessageIter args;
   char *action_str, *mac = daemon->namebuff;
   unsigned char *p;
   int i;

   if (!connection)
     return;

   if (!hostname)
     hostname = "";

 #ifdef HAVE_DHCP6
    if (lease->flags & (LEASE_TA | LEASE_NA))
      {
        print_mac(mac, lease->clid, lease->clid_len);
        inet_ntop(AF_INET6, lease->hwaddr, daemon->addrbuff, ADDRSTRLEN);
      }
    else
 #endif
      {
        p = extended_hwaddr(lease->hwaddr_type, lease->hwaddr_len,
 			   lease->hwaddr, lease->clid_len, lease->clid, &i);
        print_mac(mac, p, i);
        inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
      }

   if (action == ACTION_DEL)
     action_str = "DhcpLeaseDeleted";
   else if (action == ACTION_ADD)
     action_str = "DhcpLeaseAdded";
   else if (action == ACTION_OLD)
     action_str = "DhcpLeaseUpdated";
   else
     return;

   if (!(message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, action_str)))
     return;

   dbus_message_iter_init_append(message, &args);

   if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &daemon->addrbuff) &&
       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mac) &&
       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &hostname))
     dbus_connection_send(connection, message, NULL);

   dbus_message_unref(message);
 }
 #endif

 #endif
	/* dnsmasq is Copyright (c) 2000-2014 Simon Kelley

	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; version 2 dated June, 1991, or
	(at your option) version 3 dated 29 June, 2007.

	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, see <http://www.gnu.org/licenses/>.
	*/

	#include "dnsmasq.h"

	#ifdef HAVE_DBUS

	#include <dbus/dbus.h>

	const char* introspection_xml_template =
	"<!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=\"" DNSMASQ_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=\"%s\">\n"
	" <method name=\"ClearCache\">\n"
	" </method>\n"
	" <method name=\"GetVersion\">\n"
	" <arg name=\"version\" direction=\"out\" type=\"s\"/>\n"
	" </method>\n"
	" <method name=\"SetServers\">\n"
	" <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n"
	" </method>\n"
	" <method name=\"SetDomainServers\">\n"
	" <arg name=\"servers\" direction=\"in\" type=\"as\"/>\n"
	" </method>\n"
	" <method name=\"SetServersEx\">\n"
	" <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n"
	" </method>\n"
	" <method name=\"SetFilterWin2KOption\">\n"
	" <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n"
	" </method>\n"
	" <method name=\"SetBogusPrivOption\">\n"
	" <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n"
	" </method>\n"
	" <signal name=\"DhcpLeaseAdded\">\n"
	" <arg name=\"ipaddr\" type=\"s\"/>\n"
	" <arg name=\"hwaddr\" type=\"s\"/>\n"
	" <arg name=\"hostname\" type=\"s\"/>\n"
	" </signal>\n"
	" <signal name=\"DhcpLeaseDeleted\">\n"
	" <arg name=\"ipaddr\" type=\"s\"/>\n"
	" <arg name=\"hwaddr\" type=\"s\"/>\n"
	" <arg name=\"hostname\" type=\"s\"/>\n"
	" </signal>\n"
	" <signal name=\"DhcpLeaseUpdated\">\n"
	" <arg name=\"ipaddr\" type=\"s\"/>\n"
	" <arg name=\"hwaddr\" type=\"s\"/>\n"
	" <arg name=\"hostname\" type=\"s\"/>\n"
	" </signal>\n"
	" </interface>\n"
	"</node>\n";

	static char *introspection_xml = NULL;

	struct watch {
	DBusWatch *watch;
	struct watch *next;
	};


	static dbus_bool_t add_watch(DBusWatch watch, void data)
	{
	struct watch *w;

	for (w = daemon->watches; w; w = w->next)
	if (w->watch == watch)
	return TRUE;

	if (!(w = whine_malloc(sizeof(struct watch))))
	return FALSE;

	w->watch = watch;
	w->next = daemon->watches;
	daemon->watches = w;

	w = data; /* no warning */
	return TRUE;
	}

	static void remove_watch(DBusWatch watch, void data)
	{
	struct watch *up, w, *tmp;

	for (up = &(daemon->watches), w = daemon->watches; w; w = tmp)
	{
	tmp = w->next;
	if (w->watch == watch)
	{
	*up = tmp;
	free(w);
	}
	else
	up = &(w->next);
	}

	w = data; /* no warning */
	}

	static void dbus_read_servers(DBusMessage *message)
	{
	DBusMessageIter iter;
	union mysockaddr addr, source_addr;
	char *domain;

	dbus_message_iter_init(message, &iter);

	mark_servers(SERV_FROM_DBUS);

	while (1)
	{
	int skip = 0;

	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
	{
	u32 a;

	dbus_message_iter_get_basic(&iter, &a);
	dbus_message_iter_next (&iter);

	#ifdef HAVE_SOCKADDR_SA_LEN
	source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
	#endif
	addr.in.sin_addr.s_addr = ntohl(a);
	source_addr.in.sin_family = addr.in.sin_family = AF_INET;
	addr.in.sin_port = htons(NAMESERVER_PORT);
	source_addr.in.sin_addr.s_addr = INADDR_ANY;
	source_addr.in.sin_port = htons(daemon->query_port);
	}
	else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
	{
	unsigned char p[sizeof(struct in6_addr)];
	unsigned int i;

	skip = 1;

	for(i = 0; i < sizeof(struct in6_addr); i++)
	{
	dbus_message_iter_get_basic(&iter, &p[i]);
	dbus_message_iter_next (&iter);
	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
	break;
	}

	#ifndef HAVE_IPV6
	my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
	#else
	if (i == sizeof(struct in6_addr)-1)
	{
	memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
	#ifdef HAVE_SOCKADDR_SA_LEN
	source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
	#endif
	source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
	addr.in6.sin6_port = htons(NAMESERVER_PORT);
	source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
	source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
	source_addr.in6.sin6_addr = in6addr_any;
	source_addr.in6.sin6_port = htons(daemon->query_port);
	skip = 0;
	}
	#endif
	}
	else
	/* At the end */
	break;

	/* process each domain */
	do {
	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
	{
	dbus_message_iter_get_basic(&iter, &domain);
	dbus_message_iter_next (&iter);
	}
	else
	domain = NULL;

	if (!skip)
	add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);

	} while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
	}

	/* unlink and free anything still marked. */
	cleanup_servers();
	}

	static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
	{
	DBusMessageIter iter, array_iter, string_iter;
	DBusMessage *error = NULL;
	const char *addr_err;
	char *dup = NULL;

	if (!dbus_message_iter_init(message, &iter))
	{
	return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	"Failed to initialize dbus message iter");
	}

	/* check that the message contains an array of arrays */
	if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) \|\|
	(dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
	{
	return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	strings ? "Expected array of string" : "Expected array of string arrays");
	}

	mark_servers(SERV_FROM_DBUS);

	/* array_iter points to each "as" element in the outer array */
	dbus_message_iter_recurse(&iter, &array_iter);
	while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
	{
	const char *str = NULL;
	union mysockaddr addr, source_addr;
	int flags = 0;
	char interface[IF_NAMESIZE];
	char str_addr, str_domain = NULL;

	if (strings)
	{
	dbus_message_iter_get_basic(&array_iter, &str);
	if (!str \|\| !strlen (str))
	{
	error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	"Empty string");
	break;
	}

	/* dup the string because it gets modified during parsing */
	if (dup)
	free(dup);
	if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
	break;

	strcpy(str_domain, str);

	/* point to address part of old string for error message */
	if ((str_addr = strrchr(str, '/')))
	str = str_addr+1;

	if ((str_addr = strrchr(str_domain, '/')))
	{
	if (*str_domain != '/' \|\| str_addr == str_domain)
	{
	error = dbus_message_new_error_printf(message,
	DBUS_ERROR_INVALID_ARGS,
	"No domain terminator '%s'",
	str);
	break;
	}
	*str_addr++ = 0;
	str_domain++;
	}
	else
	{
	str_addr = str_domain;
	str_domain = NULL;
	}


	}
	else
	{
	/* check the types of the struct and its elements */
	if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) \|\|
	(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
	{
	error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	"Expected inner array of strings");
	break;
	}

	/* string_iter points to each "s" element in the inner array */
	dbus_message_iter_recurse(&array_iter, &string_iter);
	if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
	{
	/* no IP address given */
	error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	"Expected IP address");
	break;
	}

	dbus_message_iter_get_basic(&string_iter, &str);
	if (!str \|\| !strlen (str))
	{
	error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
	"Empty IP address");
	break;
	}

	/* dup the string because it gets modified during parsing */
	if (dup)
	free(dup);
	if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
	break;

	strcpy(str_addr, str);
	}

	memset(&addr, 0, sizeof(addr));
	memset(&source_addr, 0, sizeof(source_addr));
	memset(&interface, 0, sizeof(interface));

	/* parse the IP address */
	if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
	{
	error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
	"Invalid IP address '%s': %s",
	str, addr_err);
	break;
	}

	/* 0.0.0.0 for server address == NULL, for Dbus */
	if (addr.in.sin_family == AF_INET &&
	addr.in.sin_addr.s_addr == 0)
	flags \|= SERV_NO_ADDR;

	if (strings)
	{
	char *p;

	do {
	if (str_domain)
	{
	if ((p = strchr(str_domain, '/')))
	*p++ = 0;
	}
	else
	p = NULL;

	add_update_server(flags \| SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
	} while ((str_domain = p));
	}
	else
	{
	/* jump past the address to the domain list (if any) */
	dbus_message_iter_next (&string_iter);

	/* parse domains and add each server/domain pair to the list */
	do {
	str = NULL;
	if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
	dbus_message_iter_get_basic(&string_iter, &str);
	dbus_message_iter_next (&string_iter);

	add_update_server(flags \| SERV_FROM_DBUS, &addr, &source_addr, interface, str);
	} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
	}

	/* jump to next element in outer array */
	dbus_message_iter_next(&array_iter);
	}

	cleanup_servers();

	if (dup)
	free(dup);

	return error;
	}

	static DBusMessage dbus_set_bool(DBusMessage message, int flag, char *name)
	{
	DBusMessageIter iter;
	dbus_bool_t enabled;

	if (!dbus_message_iter_init(message, &iter) \|\| dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
	return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected boolean argument");

	dbus_message_iter_get_basic(&iter, &enabled);

	if (enabled)
	{
	my_syslog(LOG_INFO, "Enabling --%s option from D-Bus", name);
	set_option_bool(flag);
	}
	else
	{
	my_syslog(LOG_INFO, "Disabling --$s option from D-Bus", name);
	reset_option_bool(flag);
	}

	return NULL;
	}

	DBusHandlerResult message_handler(DBusConnection *connection,
	DBusMessage *message,
	void *user_data)
	{
	char method = (char )dbus_message_get_member(message);
	DBusMessage *reply = NULL;
	int clear_cache = 0, new_servers = 0;

	if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
	{
	/* string length: "%s" provides space for termination zero */
	if (!introspection_xml &&
	(introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name))))
	sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name);

	if (introspection_xml)
	{
	reply = dbus_message_new_method_return(message);
	dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
	}
	}
	else if (strcmp(method, "GetVersion") == 0)
	{
	char *v = VERSION;
	reply = dbus_message_new_method_return(message);

	dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID);
	}
	else if (strcmp(method, "SetServers") == 0)
	{
	dbus_read_servers(message);
	new_servers = 1;
	}
	else if (strcmp(method, "SetServersEx") == 0)
	{
	reply = dbus_read_servers_ex(message, 0);
	new_servers = 1;
	}
	else if (strcmp(method, "SetDomainServers") == 0)
	{
	reply = dbus_read_servers_ex(message, 1);
	new_servers = 1;
	}
	else if (strcmp(method, "SetFilterWin2KOption") == 0)
	{
	reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k");
	}
	else if (strcmp(method, "SetBogusPrivOption") == 0)
	{
	reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv");
	}
	else if (strcmp(method, "ClearCache") == 0)
	clear_cache = 1;
	else
	return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);

	if (new_servers)
	{
	my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
	check_servers();
	if (option_bool(OPT_RELOAD))
	clear_cache = 1;
	}

	if (clear_cache)
	clear_cache_and_reload(dnsmasq_time());

	method = user_data; /* no warning */

	/* If no reply or no error, return nothing */
	if (!reply)
	reply = dbus_message_new_method_return(message);

	if (reply)
	{
	dbus_connection_send (connection, reply, NULL);
	dbus_message_unref (reply);
	}

	return (DBUS_HANDLER_RESULT_HANDLED);
	}


	/* returns NULL or error message, may fail silently if dbus daemon not yet up. */
	char *dbus_init(void)
	{
	DBusConnection *connection = NULL;
	DBusObjectPathVTable dnsmasq_vtable = {NULL, &message_handler, NULL, NULL, NULL, NULL };
	DBusError dbus_error;
	DBusMessage *message;

	dbus_error_init (&dbus_error);
	if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
	return NULL;

	dbus_connection_set_exit_on_disconnect(connection, FALSE);
	dbus_connection_set_watch_functions(connection, add_watch, remove_watch,
	NULL, NULL, NULL);
	dbus_error_init (&dbus_error);
	dbus_bus_request_name (connection, daemon->dbus_name, 0, &dbus_error);
	if (dbus_error_is_set (&dbus_error))
	return (char *)dbus_error.message;

	if (!dbus_connection_register_object_path(connection, DNSMASQ_PATH,
	&dnsmasq_vtable, NULL))
	return _("could not register a DBus message handler");

	daemon->dbus = connection;

	if ((message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, "Up")))
	{
	dbus_connection_send(connection, message, NULL);
	dbus_message_unref(message);
	}

	return NULL;
	}


	void set_dbus_listeners(int *maxfdp,
	fd_set rset, fd_set wset, fd_set *eset)
	{
	struct watch *w;

	for (w = daemon->watches; w; w = w->next)
	if (dbus_watch_get_enabled(w->watch))
	{
	unsigned int flags = dbus_watch_get_flags(w->watch);
	int fd = dbus_watch_get_unix_fd(w->watch);

	bump_maxfd(fd, maxfdp);

	if (flags & DBUS_WATCH_READABLE)
	FD_SET(fd, rset);

	if (flags & DBUS_WATCH_WRITABLE)
	FD_SET(fd, wset);

	FD_SET(fd, eset);
	}
	}

	void check_dbus_listeners(fd_set rset, fd_set wset, fd_set *eset)
	{
	DBusConnection connection = (DBusConnection )daemon->dbus;
	struct watch *w;

	for (w = daemon->watches; w; w = w->next)
	if (dbus_watch_get_enabled(w->watch))
	{
	unsigned int flags = 0;
	int fd = dbus_watch_get_unix_fd(w->watch);

	if (FD_ISSET(fd, rset))
	flags \|= DBUS_WATCH_READABLE;

	if (FD_ISSET(fd, wset))
	flags \|= DBUS_WATCH_WRITABLE;

	if (FD_ISSET(fd, eset))
	flags \|= DBUS_WATCH_ERROR;

	if (flags != 0)
	dbus_watch_handle(w->watch, flags);
	}

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

	#ifdef HAVE_DHCP
	void emit_dbus_signal(int action, struct dhcp_lease lease, char hostname)
	{
	DBusConnection connection = (DBusConnection )daemon->dbus;
	DBusMessage* message = NULL;
	DBusMessageIter args;
	char action_str, mac = daemon->namebuff;
	unsigned char *p;
	int i;

	if (!connection)
	return;

	if (!hostname)
	hostname = "";

	#ifdef HAVE_DHCP6
	if (lease->flags & (LEASE_TA \| LEASE_NA))
	{
	print_mac(mac, lease->clid, lease->clid_len);
	inet_ntop(AF_INET6, lease->hwaddr, daemon->addrbuff, ADDRSTRLEN);
	}
	else
	#endif
	{
	p = extended_hwaddr(lease->hwaddr_type, lease->hwaddr_len,
	lease->hwaddr, lease->clid_len, lease->clid, &i);
	print_mac(mac, p, i);
	inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
	}

	if (action == ACTION_DEL)
	action_str = "DhcpLeaseDeleted";
	else if (action == ACTION_ADD)
	action_str = "DhcpLeaseAdded";
	else if (action == ACTION_OLD)
	action_str = "DhcpLeaseUpdated";
	else
	return;

	if (!(message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, action_str)))
	return;

	dbus_message_iter_init_append(message, &args);

	if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &daemon->addrbuff) &&
	dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mac) &&
	dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &hostname))
	dbus_connection_send(connection, message, NULL);

	dbus_message_unref(message);
	}
	#endif

	#endif