source: src/router/dnsmasq/src/dbus.c @ 29632

Last change on this file since 29632 was 29632, checked in by BrainSlayer, 11 months ago

update dnsmasq

File size: 24.6 KB
Line 
1/* dnsmasq is Copyright (c) 2000-2016 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
23const 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
91static char *introspection_xml = NULL;
92
93struct watch {
94  DBusWatch *watch;     
95  struct watch *next;
96};
97
98
99static 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
118static 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
137static 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
229static 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
251static 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
427static 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
452static 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
569static 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
617DBusHandlerResult 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. */
717char *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
752void set_dbus_listeners(void)
753{
754  struct watch *w;
755 
756  for (w = daemon->watches; w; w = w->next)
757    if (dbus_watch_get_enabled(w->watch))
758      {
759        unsigned int flags = dbus_watch_get_flags(w->watch);
760        int fd = dbus_watch_get_unix_fd(w->watch);
761       
762        if (flags & DBUS_WATCH_READABLE)
763          poll_listen(fd, POLLIN);
764       
765        if (flags & DBUS_WATCH_WRITABLE)
766          poll_listen(fd, POLLOUT);
767       
768        poll_listen(fd, POLLERR);
769      }
770}
771
772void check_dbus_listeners()
773{
774  DBusConnection *connection = (DBusConnection *)daemon->dbus;
775  struct watch *w;
776
777  for (w = daemon->watches; w; w = w->next)
778    if (dbus_watch_get_enabled(w->watch))
779      {
780        unsigned int flags = 0;
781        int fd = dbus_watch_get_unix_fd(w->watch);
782       
783        if (poll_check(fd, POLLIN))
784          flags |= DBUS_WATCH_READABLE;
785       
786        if (poll_check(fd, POLLOUT))
787          flags |= DBUS_WATCH_WRITABLE;
788       
789        if (poll_check(fd, POLLERR))
790          flags |= DBUS_WATCH_ERROR;
791
792        if (flags != 0)
793          dbus_watch_handle(w->watch, flags);
794      }
795
796  if (connection)
797    {
798      dbus_connection_ref (connection);
799      while (dbus_connection_dispatch (connection) == DBUS_DISPATCH_DATA_REMAINS);
800      dbus_connection_unref (connection);
801    }
802}
803
804#ifdef HAVE_DHCP
805void emit_dbus_signal(int action, struct dhcp_lease *lease, char *hostname)
806{
807  DBusConnection *connection = (DBusConnection *)daemon->dbus;
808  DBusMessage* message = NULL;
809  DBusMessageIter args;
810  char *action_str, *mac = daemon->namebuff;
811  unsigned char *p;
812  int i;
813
814  if (!connection)
815    return;
816 
817  if (!hostname)
818    hostname = "";
819 
820#ifdef HAVE_DHCP6
821   if (lease->flags & (LEASE_TA | LEASE_NA))
822     {
823       print_mac(mac, lease->clid, lease->clid_len);
824       inet_ntop(AF_INET6, &lease->addr6, daemon->addrbuff, ADDRSTRLEN);
825     }
826   else
827#endif
828     {
829       p = extended_hwaddr(lease->hwaddr_type, lease->hwaddr_len,
830                           lease->hwaddr, lease->clid_len, lease->clid, &i);
831       print_mac(mac, p, i);
832       inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
833     }
834
835  if (action == ACTION_DEL)
836    action_str = "DhcpLeaseDeleted";
837  else if (action == ACTION_ADD)
838    action_str = "DhcpLeaseAdded";
839  else if (action == ACTION_OLD)
840    action_str = "DhcpLeaseUpdated";
841  else
842    return;
843
844  if (!(message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, action_str)))
845    return;
846 
847  dbus_message_iter_init_append(message, &args);
848 
849  if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &daemon->addrbuff) &&
850      dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mac) &&
851      dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &hostname))
852    dbus_connection_send(connection, message, NULL);
853 
854  dbus_message_unref(message);
855}
856#endif
857
858#endif
Note: See TracBrowser for help on using the repository browser.