src/dbus.c

   1 /* dnsmasq is Copyright (c) 2000-2015 Simon Kelley
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 dated June, 1991, or
   6    (at your option) version 3 dated 29 June, 2007.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15 */
  16
  17 #include "dnsmasq.h"
  18
  19 #ifdef HAVE_DBUS
  20
  21 #include <dbus/dbus.h>
  22
  23 const char* introspection_xml_template =
  24 "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
  25 "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
  26 "<node name=\"" DNSMASQ_PATH "\">\n"
  27 "  <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
  28 "    <method name=\"Introspect\">\n"
  29 "      <arg name=\"data\" direction=\"out\" type=\"s\"/>\n"
  30 "    </method>\n"
  31 "  </interface>\n"
  32 "  <interface name=\"%s\">\n"
  33 "    <method name=\"ClearCache\">\n"
  34 "    </method>\n"
  35 "    <method name=\"GetVersion\">\n"
  36 "      <arg name=\"version\" direction=\"out\" type=\"s\"/>\n"
  37 "    </method>\n"
  38 #ifdef HAVE_LOOP
  39 "    <method name=\"GetLoopServers\">\n"
  40 "      <arg name=\"server\" direction=\"out\" type=\"as\"/>\n"
  41 "    </method>\n"
  42 #endif
  43 "    <method name=\"SetServers\">\n"
  44 "      <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n"
  45 "    </method>\n"
  46 "    <method name=\"SetDomainServers\">\n"
  47 "      <arg name=\"servers\" direction=\"in\" type=\"as\"/>\n"
  48 "    </method>\n"
  49 "    <method name=\"SetServersEx\">\n"
  50 "      <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n"
  51 "    </method>\n"
  52 "    <method name=\"SetFilterWin2KOption\">\n"
  53 "      <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n"
  54 "    </method>\n"
  55 "    <method name=\"SetBogusPrivOption\">\n"
  56 "      <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n"
  57 "    </method>\n"
  58 "    <signal name=\"DhcpLeaseAdded\">\n"
  59 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
  60 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
  61 "      <arg name=\"hostname\" type=\"s\"/>\n"
  62 "    </signal>\n"
  63 "    <signal name=\"DhcpLeaseDeleted\">\n"
  64 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
  65 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
  66 "      <arg name=\"hostname\" type=\"s\"/>\n"
  67 "    </signal>\n"
  68 "    <signal name=\"DhcpLeaseUpdated\">\n"
  69 "      <arg name=\"ipaddr\" type=\"s\"/>\n"
  70 "      <arg name=\"hwaddr\" type=\"s\"/>\n"
  71 "      <arg name=\"hostname\" type=\"s\"/>\n"
  72 "    </signal>\n"
  73 #ifdef HAVE_DHCP
  74 "    <method name=\"AddDhcpLease\">\n"
  75 "       <arg name=\"ipaddr\" type=\"s\"/>\n"
  76 "       <arg name=\"hwaddr\" type=\"s\"/>\n"
  77 "       <arg name=\"hostname\" type=\"ay\"/>\n"
  78 "       <arg name=\"clid\" type=\"ay\"/>\n"
  79 "       <arg name=\"lease_duration\" type=\"u\"/>\n"
  80 "       <arg name=\"ia_id\" type=\"u\"/>\n"
  81 "       <arg name=\"is_temporary\" type=\"b\"/>\n"
  82 "    </method>\n"
  83 "    <method name=\"DeleteDhcpLease\">\n"
  84 "       <arg name=\"ipaddr\" type=\"s\"/>\n"
  85 "       <arg name=\"success\" type=\"b\" direction=\"out\"/>\n"
  86 "    </method>\n"
  87 #endif
  88 "  </interface>\n"
  89 "</node>\n";
  90
  91 static char *introspection_xml = NULL;
  92
  93 struct watch {
  94   DBusWatch *watch;
  95   struct watch *next;
  96 };
  97
  98
  99 static dbus_bool_t add_watch(DBusWatch *watch, void *data)
 100 {
 101   struct watch *w;
 102
 103   for (w = daemon->watches; w; w = w->next)
 104     if (w->watch == watch)
 105       return TRUE;
 106
 107   if (!(w = whine_malloc(sizeof(struct watch))))
 108     return FALSE;
 109
 110   w->watch = watch;
 111   w->next = daemon->watches;
 112   daemon->watches = w;
 113
 114   w = data; /* no warning */
 115   return TRUE;
 116 }
 117
 118 static void remove_watch(DBusWatch *watch, void *data)
 119 {
 120   struct watch **up, *w, *tmp;
 121
 122   for (up = &(daemon->watches), w = daemon->watches; w; w = tmp)
 123     {
 124       tmp = w->next;
 125       if (w->watch == watch)
 126         {
 127           *up = tmp;
 128           free(w);
 129         }
 130       else
 131         up = &(w->next);
 132     }
 133
 134   w = data; /* no warning */
 135 }
 136
 137 static void dbus_read_servers(DBusMessage *message)
 138 {
 139   DBusMessageIter iter;
 140   union  mysockaddr addr, source_addr;
 141   char *domain;
 142
 143   dbus_message_iter_init(message, &iter);
 144
 145   mark_servers(SERV_FROM_DBUS);
 146
 147   while (1)
 148     {
 149       int skip = 0;
 150
 151       if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
 152         {
 153           u32 a;
 154
 155           dbus_message_iter_get_basic(&iter, &a);
 156           dbus_message_iter_next (&iter);
 157
 158 #ifdef HAVE_SOCKADDR_SA_LEN
 159           source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
 160 #endif
 161           addr.in.sin_addr.s_addr = ntohl(a);
 162           source_addr.in.sin_family = addr.in.sin_family = AF_INET;
 163           addr.in.sin_port = htons(NAMESERVER_PORT);
 164           source_addr.in.sin_addr.s_addr = INADDR_ANY;
 165           source_addr.in.sin_port = htons(daemon->query_port);
 166         }
 167       else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
 168         {
 169           unsigned char p[sizeof(struct in6_addr)];
 170           unsigned int i;
 171
 172           skip = 1;
 173
 174           for(i = 0; i < sizeof(struct in6_addr); i++)
 175             {
 176               dbus_message_iter_get_basic(&iter, &p[i]);
 177               dbus_message_iter_next (&iter);
 178               if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
 179                 {
 180                   i++;
 181                   break;
 182                 }
 183             }
 184
 185 #ifndef HAVE_IPV6
 186           my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
 187 #else
 188           if (i == sizeof(struct in6_addr))
 189             {
 190               memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
 191 #ifdef HAVE_SOCKADDR_SA_LEN
 192               source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
 193 #endif
 194               source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
 195               addr.in6.sin6_port = htons(NAMESERVER_PORT);
 196               source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
 197               source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
 198               source_addr.in6.sin6_addr = in6addr_any;
 199               source_addr.in6.sin6_port = htons(daemon->query_port);
 200               skip = 0;
 201             }
 202 #endif
 203         }
 204       else
 205         /* At the end */
 206         break;
 207
 208       /* process each domain */
 209       do {
 210         if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
 211           {
 212             dbus_message_iter_get_basic(&iter, &domain);
 213             dbus_message_iter_next (&iter);
 214           }
 215         else
 216           domain = NULL;
 217
 218         if (!skip)
 219           add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);
 220
 221       } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
 222     }
 223
 224   /* unlink and free anything still marked. */
 225   cleanup_servers();
 226 }
 227
 228 #ifdef HAVE_LOOP
 229 static DBusMessage *dbus_reply_server_loop(DBusMessage *message)
 230 {
 231   DBusMessageIter args, args_iter;
 232   struct server *serv;
 233   DBusMessage *reply = dbus_message_new_method_return(message);
 234
 235   dbus_message_iter_init_append (reply, &args);
 236   dbus_message_iter_open_container (&args, DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING, &args_iter);
 237
 238   for (serv = daemon->servers; serv; serv = serv->next)
 239     if (serv->flags & SERV_LOOP)
 240       {
 241         prettyprint_addr(&serv->addr, daemon->addrbuff);
 242         dbus_message_iter_append_basic (&args_iter, DBUS_TYPE_STRING, &daemon->addrbuff);
 243       }
 244
 245   dbus_message_iter_close_container (&args, &args_iter);
 246
 247   return reply;
 248 }
 249 #endif
 250
 251 static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
 252 {
 253   DBusMessageIter iter, array_iter, string_iter;
 254   DBusMessage *error = NULL;
 255   const char *addr_err;
 256   char *dup = NULL;
 257
 258   if (!dbus_message_iter_init(message, &iter))
 259     {
 260       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 261                                     "Failed to initialize dbus message iter");
 262     }
 263
 264   /* check that the message contains an array of arrays */
 265   if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
 266       (dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
 267     {
 268       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 269                                     strings ? "Expected array of string" : "Expected array of string arrays");
 270      }
 271
 272   mark_servers(SERV_FROM_DBUS);
 273
 274   /* array_iter points to each "as" element in the outer array */
 275   dbus_message_iter_recurse(&iter, &array_iter);
 276   while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
 277     {
 278       const char *str = NULL;
 279       union  mysockaddr addr, source_addr;
 280       int flags = 0;
 281       char interface[IF_NAMESIZE];
 282       char *str_addr, *str_domain = NULL;
 283
 284       if (strings)
 285         {
 286           dbus_message_iter_get_basic(&array_iter, &str);
 287           if (!str || !strlen (str))
 288             {
 289               error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 290                                              "Empty string");
 291               break;
 292             }
 293
 294           /* dup the string because it gets modified during parsing */
 295           if (dup)
 296             free(dup);
 297           if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
 298             break;
 299
 300           strcpy(str_domain, str);
 301
 302           /* point to address part of old string for error message */
 303           if ((str_addr = strrchr(str, '/')))
 304             str = str_addr+1;
 305
 306           if ((str_addr = strrchr(str_domain, '/')))
 307             {
 308               if (*str_domain != '/' || str_addr == str_domain)
 309                 {
 310                   error = dbus_message_new_error_printf(message,
 311                                                         DBUS_ERROR_INVALID_ARGS,
 312                                                         "No domain terminator '%s'",
 313                                                         str);
 314                   break;
 315                 }
 316               *str_addr++ = 0;
 317               str_domain++;
 318             }
 319           else
 320             {
 321               str_addr = str_domain;
 322               str_domain = NULL;
 323             }
 324
 325
 326         }
 327       else
 328         {
 329           /* check the types of the struct and its elements */
 330           if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
 331               (dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
 332             {
 333               error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 334                                              "Expected inner array of strings");
 335               break;
 336             }
 337
 338           /* string_iter points to each "s" element in the inner array */
 339           dbus_message_iter_recurse(&array_iter, &string_iter);
 340           if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
 341             {
 342               /* no IP address given */
 343               error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 344                                              "Expected IP address");
 345               break;
 346             }
 347
 348           dbus_message_iter_get_basic(&string_iter, &str);
 349           if (!str || !strlen (str))
 350             {
 351               error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 352                                              "Empty IP address");
 353               break;
 354             }
 355
 356           /* dup the string because it gets modified during parsing */
 357           if (dup)
 358             free(dup);
 359           if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
 360             break;
 361
 362           strcpy(str_addr, str);
 363         }
 364
 365       memset(&addr, 0, sizeof(addr));
 366       memset(&source_addr, 0, sizeof(source_addr));
 367       memset(&interface, 0, sizeof(interface));
 368
 369       /* parse the IP address */
 370       if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
 371         {
 372           error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
 373                                                 "Invalid IP address '%s': %s",
 374                                                 str, addr_err);
 375           break;
 376         }
 377
 378       /* 0.0.0.0 for server address == NULL, for Dbus */
 379       if (addr.in.sin_family == AF_INET &&
 380           addr.in.sin_addr.s_addr == 0)
 381         flags |= SERV_NO_ADDR;
 382
 383       if (strings)
 384         {
 385           char *p;
 386
 387           do {
 388             if (str_domain)
 389               {
 390                 if ((p = strchr(str_domain, '/')))
 391                   *p++ = 0;
 392               }
 393             else
 394               p = NULL;
 395
 396             add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
 397           } while ((str_domain = p));
 398         }
 399       else
 400         {
 401           /* jump past the address to the domain list (if any) */
 402           dbus_message_iter_next (&string_iter);
 403
 404           /* parse domains and add each server/domain pair to the list */
 405           do {
 406             str = NULL;
 407             if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
 408               dbus_message_iter_get_basic(&string_iter, &str);
 409             dbus_message_iter_next (&string_iter);
 410
 411             add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
 412           } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
 413         }
 414
 415       /* jump to next element in outer array */
 416       dbus_message_iter_next(&array_iter);
 417     }
 418
 419   cleanup_servers();
 420
 421   if (dup)
 422     free(dup);
 423
 424   return error;
 425 }
 426
 427 static DBusMessage *dbus_set_bool(DBusMessage *message, int flag, char *name)
 428 {
 429   DBusMessageIter iter;
 430   dbus_bool_t enabled;
 431
 432   if (!dbus_message_iter_init(message, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
 433     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected boolean argument");
 434
 435   dbus_message_iter_get_basic(&iter, &enabled);
 436
 437   if (enabled)
 438     {
 439       my_syslog(LOG_INFO, _("Enabling --%s option from D-Bus"), name);
 440       set_option_bool(flag);
 441     }
 442   else
 443     {
 444       my_syslog(LOG_INFO, _("Disabling --%s option from D-Bus"), name);
 445       reset_option_bool(flag);
 446     }
 447
 448   return NULL;
 449 }
 450
 451 #ifdef HAVE_DHCP
 452 static DBusMessage *dbus_add_lease(DBusMessage* message)
 453 {
 454   struct dhcp_lease *lease;
 455   const char *ipaddr, *hwaddr, *hostname, *tmp;
 456   const unsigned char* clid;
 457   int clid_len, hostname_len, hw_len, hw_type;
 458   dbus_uint32_t expires, ia_id;
 459   dbus_bool_t is_temporary;
 460   struct all_addr addr;
 461   time_t now = dnsmasq_time();
 462   unsigned char dhcp_chaddr[DHCP_CHADDR_MAX];
 463
 464   DBusMessageIter iter, array_iter;
 465   if (!dbus_message_iter_init(message, &iter))
 466     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 467                                   "Failed to initialize dbus message iter");
 468
 469   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 470     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 471                                   "Expected string as first argument");
 472
 473   dbus_message_iter_get_basic(&iter, &ipaddr);
 474   dbus_message_iter_next(&iter);
 475
 476   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 477     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 478                                   "Expected string as second argument");
 479
 480   dbus_message_iter_get_basic(&iter, &hwaddr);
 481   dbus_message_iter_next(&iter);
 482
 483   if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
 484       (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
 485     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 486                                   "Expected byte array as third argument");
 487
 488   dbus_message_iter_recurse(&iter, &array_iter);
 489   dbus_message_iter_get_fixed_array(&array_iter, &hostname, &hostname_len);
 490   tmp = memchr(hostname, '\0', hostname_len);
 491   if (tmp)
 492     {
 493       if (tmp == &hostname[hostname_len - 1])
 494         hostname_len--;
 495       else
 496         return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 497                                       "Hostname contains an embedded NUL character");
 498     }
 499   dbus_message_iter_next(&iter);
 500
 501   if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
 502       (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
 503     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 504                                   "Expected byte array as fourth argument");
 505
 506   dbus_message_iter_recurse(&iter, &array_iter);
 507   dbus_message_iter_get_fixed_array(&array_iter, &clid, &clid_len);
 508   dbus_message_iter_next(&iter);
 509
 510   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
 511     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 512                                   "Expected uint32 as fifth argument");
 513
 514   dbus_message_iter_get_basic(&iter, &expires);
 515   dbus_message_iter_next(&iter);
 516
 517   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
 518     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 519                                     "Expected uint32 as sixth argument");
 520
 521   dbus_message_iter_get_basic(&iter, &ia_id);
 522   dbus_message_iter_next(&iter);
 523
 524   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
 525     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 526                                   "Expected uint32 as sixth argument");
 527
 528   dbus_message_iter_get_basic(&iter, &is_temporary);
 529
 530   if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))
 531     {
 532       if (ia_id != 0 || is_temporary)
 533         return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 534                                       "ia_id and is_temporary must be zero for IPv4 lease");
 535
 536       if (!(lease = lease_find_by_addr(addr.addr.addr4)))
 537         lease = lease4_allocate(addr.addr.addr4);
 538     }
 539 #ifdef HAVE_DHCP6
 540   else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))
 541     {
 542       if (!(lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0)))
 543         lease = lease6_allocate(&addr.addr.addr6,
 544                                 is_temporary ? LEASE_TA : LEASE_NA);
 545       lease_set_iaid(lease, ia_id);
 546     }
 547 #endif
 548   else
 549     return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
 550                                          "Invalid IP address '%s'", ipaddr);
 551
 552   hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL,
 553                      &hw_type);
 554   if (hw_type == 0 && hw_len != 0)
 555     hw_type = ARPHRD_ETHER;
 556
 557     lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type,
 558                    clid_len, now, 0);
 559   lease_set_expires(lease, expires, now);
 560   if (hostname_len != 0)
 561     lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL);
 562
 563   lease_update_file(now);
 564   lease_update_dns(0);
 565
 566   return NULL;
 567 }
 568
 569 static DBusMessage *dbus_del_lease(DBusMessage* message)
 570 {
 571   struct dhcp_lease *lease;
 572   DBusMessageIter iter;
 573   const char *ipaddr;
 574   DBusMessage *reply;
 575   struct all_addr addr;
 576   dbus_bool_t ret = 1;
 577   time_t now = dnsmasq_time();
 578
 579   if (!dbus_message_iter_init(message, &iter))
 580     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 581                                   "Failed to initialize dbus message iter");
 582
 583   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 584     return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
 585                                   "Expected string as first argument");
 586
 587   dbus_message_iter_get_basic(&iter, &ipaddr);
 588
 589   if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))
 590     lease = lease_find_by_addr(addr.addr.addr4);
 591 #ifdef HAVE_DHCP6
 592   else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))
 593     lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0);
 594 #endif
 595   else
 596     return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
 597                                          "Invalid IP address '%s'", ipaddr);
 598
 599   if (lease)
 600     {
 601       lease_prune(lease, now);
 602       lease_update_file(now);
 603       lease_update_dns(0);
 604     }
 605   else
 606     ret = 0;
 607
 608   if ((reply = dbus_message_new_method_return(message)))
 609     dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
 610                              DBUS_TYPE_INVALID);
 611
 612
 613   return reply;
 614 }
 615 #endif
 616
 617 DBusHandlerResult message_handler(DBusConnection *connection,
 618                                   DBusMessage *message,
 619                                   void *user_data)
 620 {
 621   char *method = (char *)dbus_message_get_member(message);
 622   DBusMessage *reply = NULL;
 623   int clear_cache = 0, new_servers = 0;
 624
 625   if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
 626     {
 627       /* string length: "%s" provides space for termination zero */
 628       if (!introspection_xml &&
 629           (introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name))))
 630         sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name);
 631
 632       if (introspection_xml)
 633         {
 634           reply = dbus_message_new_method_return(message);
 635           dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
 636         }
 637     }
 638   else if (strcmp(method, "GetVersion") == 0)
 639     {
 640       char *v = VERSION;
 641       reply = dbus_message_new_method_return(message);
 642
 643       dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID);
 644     }
 645 #ifdef HAVE_LOOP
 646   else if (strcmp(method, "GetLoopServers") == 0)
 647     {
 648       reply = dbus_reply_server_loop(message);
 649     }
 650 #endif
 651   else if (strcmp(method, "SetServers") == 0)
 652     {
 653       dbus_read_servers(message);
 654       new_servers = 1;
 655     }
 656   else if (strcmp(method, "SetServersEx") == 0)
 657     {
 658       reply = dbus_read_servers_ex(message, 0);
 659       new_servers = 1;
 660     }
 661   else if (strcmp(method, "SetDomainServers") == 0)
 662     {
 663       reply = dbus_read_servers_ex(message, 1);
 664       new_servers = 1;
 665     }
 666   else if (strcmp(method, "SetFilterWin2KOption") == 0)
 667     {
 668       reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k");
 669     }
 670   else if (strcmp(method, "SetBogusPrivOption") == 0)
 671     {
 672       reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv");
 673     }
 674 #ifdef HAVE_DHCP
 675   else if (strcmp(method, "AddDhcpLease") == 0)
 676     {
 677       reply = dbus_add_lease(message);
 678     }
 679   else if (strcmp(method, "DeleteDhcpLease") == 0)
 680     {
 681       reply = dbus_del_lease(message);
 682     }
 683 #endif
 684   else if (strcmp(method, "ClearCache") == 0)
 685     clear_cache = 1;
 686   else
 687     return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 688
 689   if (new_servers)
 690     {
 691       my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
 692       check_servers();
 693       if (option_bool(OPT_RELOAD))
 694         clear_cache = 1;
 695     }
 696
 697   if (clear_cache)
 698     clear_cache_and_reload(dnsmasq_time());
 699
 700   method = user_data; /* no warning */
 701
 702   /* If no reply or no error, return nothing */
 703   if (!reply)
 704     reply = dbus_message_new_method_return(message);
 705
 706   if (reply)
 707     {
 708       dbus_connection_send (connection, reply, NULL);
 709       dbus_message_unref (reply);
 710     }
 711
 712   return (DBUS_HANDLER_RESULT_HANDLED);
 713 }
 714
 715
 716 /* returns NULL or error message, may fail silently if dbus daemon not yet up. */
 717 char *dbus_init(void)
 718 {
 719   DBusConnection *connection = NULL;
 720   DBusObjectPathVTable dnsmasq_vtable = {NULL, &message_handler, NULL, NULL, NULL, NULL };
 721   DBusError dbus_error;
 722   DBusMessage *message;
 723
 724   dbus_error_init (&dbus_error);
 725   if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
 726     return NULL;
 727
 728   dbus_connection_set_exit_on_disconnect(connection, FALSE);
 729   dbus_connection_set_watch_functions(connection, add_watch, remove_watch,
 730                                       NULL, NULL, NULL);
 731   dbus_error_init (&dbus_error);
 732   dbus_bus_request_name (connection, daemon->dbus_name, 0, &dbus_error);
 733   if (dbus_error_is_set (&dbus_error))
 734     return (char *)dbus_error.message;
 735
 736   if (!dbus_connection_register_object_path(connection,  DNSMASQ_PATH,
 737                                             &dnsmasq_vtable, NULL))
 738     return _("could not register a DBus message handler");
 739
 740   daemon->dbus = connection;
 741
 742   if ((message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, "Up")))
 743     {
 744       dbus_connection_send(connection, message, NULL);
 745       dbus_message_unref(message);
 746     }
 747
 748   return NULL;
 749 }
 750
 751
 752 void set_dbus_listeners(int *maxfdp,
 753                         fd_set *rset, fd_set *wset, fd_set *eset)
 754 {
 755   struct watch *w;
 756
 757   for (w = daemon->watches; w; w = w->next)
 758     if (dbus_watch_get_enabled(w->watch))
 759       {
 760         unsigned int flags = dbus_watch_get_flags(w->watch);
 761         int fd = dbus_watch_get_unix_fd(w->watch);
 762
 763         bump_maxfd(fd, maxfdp);
 764
 765         if (flags & DBUS_WATCH_READABLE)
 766           FD_SET(fd, rset);
 767
 768         if (flags & DBUS_WATCH_WRITABLE)
 769           FD_SET(fd, wset);
 770
 771         FD_SET(fd, eset);
 772       }
 773 }
 774
 775 void check_dbus_listeners(fd_set *rset, fd_set *wset, fd_set *eset)
 776 {
 777   DBusConnection *connection = (DBusConnection *)daemon->dbus;
 778   struct watch *w;
 779
 780   for (w = daemon->watches; w; w = w->next)
 781     if (dbus_watch_get_enabled(w->watch))
 782       {
 783         unsigned int flags = 0;
 784         int fd = dbus_watch_get_unix_fd(w->watch);
 785
 786         if (FD_ISSET(fd, rset))
 787           flags |= DBUS_WATCH_READABLE;
 788
 789         if (FD_ISSET(fd, wset))
 790           flags |= DBUS_WATCH_WRITABLE;
 791
 792         if (FD_ISSET(fd, eset))
 793           flags |= DBUS_WATCH_ERROR;
 794
 795         if (flags != 0)
 796           dbus_watch_handle(w->watch, flags);
 797       }
 798
 799   if (connection)
 800     {
 801       dbus_connection_ref (connection);
 802       while (dbus_connection_dispatch (connection) == DBUS_DISPATCH_DATA_REMAINS);
 803       dbus_connection_unref (connection);
 804     }
 805 }
 806
 807 #ifdef HAVE_DHCP
 808 void emit_dbus_signal(int action, struct dhcp_lease *lease, char *hostname)
 809 {
 810   DBusConnection *connection = (DBusConnection *)daemon->dbus;
 811   DBusMessage* message = NULL;
 812   DBusMessageIter args;
 813   char *action_str, *mac = daemon->namebuff;
 814   unsigned char *p;
 815   int i;
 816
 817   if (!connection)
 818     return;
 819
 820   if (!hostname)
 821     hostname = "";
 822
 823 #ifdef HAVE_DHCP6
 824    if (lease->flags & (LEASE_TA | LEASE_NA))
 825      {
 826        print_mac(mac, lease->clid, lease->clid_len);
 827        inet_ntop(AF_INET6, &lease->addr6, daemon->addrbuff, ADDRSTRLEN);
 828      }
 829    else
 830 #endif
 831      {
 832        p = extended_hwaddr(lease->hwaddr_type, lease->hwaddr_len,
 833                            lease->hwaddr, lease->clid_len, lease->clid, &i);
 834        print_mac(mac, p, i);
 835        inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
 836      }
 837
 838   if (action == ACTION_DEL)
 839     action_str = "DhcpLeaseDeleted";
 840   else if (action == ACTION_ADD)
 841     action_str = "DhcpLeaseAdded";
 842   else if (action == ACTION_OLD)
 843     action_str = "DhcpLeaseUpdated";
 844   else
 845     return;
 846
 847   if (!(message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, action_str)))
 848     return;
 849
 850   dbus_message_iter_init_append(message, &args);
 851
 852   if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &daemon->addrbuff) &&
 853       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mac) &&
 854       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &hostname))
 855     dbus_connection_send(connection, message, NULL);
 856
 857   dbus_message_unref(message);
 858 }
 859 #endif
 860
 861 #endif