Annotation of embedaddon/dnsmasq/src/dbus.c, revision 1.1.1.1
1.1 misho 1: /* dnsmasq is Copyright (c) 2000-2013 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: " <method name=\"SetServers\">\n"
39: " <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n"
40: " </method>\n"
41: " <method name=\"SetDomainServers\">\n"
42: " <arg name=\"servers\" direction=\"in\" type=\"as\"/>\n"
43: " </method>\n"
44: " <method name=\"SetServersEx\">\n"
45: " <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n"
46: " </method>\n"
47: " <signal name=\"DhcpLeaseAdded\">\n"
48: " <arg name=\"ipaddr\" type=\"s\"/>\n"
49: " <arg name=\"hwaddr\" type=\"s\"/>\n"
50: " <arg name=\"hostname\" type=\"s\"/>\n"
51: " </signal>\n"
52: " <signal name=\"DhcpLeaseDeleted\">\n"
53: " <arg name=\"ipaddr\" type=\"s\"/>\n"
54: " <arg name=\"hwaddr\" type=\"s\"/>\n"
55: " <arg name=\"hostname\" type=\"s\"/>\n"
56: " </signal>\n"
57: " <signal name=\"DhcpLeaseUpdated\">\n"
58: " <arg name=\"ipaddr\" type=\"s\"/>\n"
59: " <arg name=\"hwaddr\" type=\"s\"/>\n"
60: " <arg name=\"hostname\" type=\"s\"/>\n"
61: " </signal>\n"
62: " </interface>\n"
63: "</node>\n";
64:
65: static char *introspection_xml = NULL;
66:
67: struct watch {
68: DBusWatch *watch;
69: struct watch *next;
70: };
71:
72:
73: static dbus_bool_t add_watch(DBusWatch *watch, void *data)
74: {
75: struct watch *w;
76:
77: for (w = daemon->watches; w; w = w->next)
78: if (w->watch == watch)
79: return TRUE;
80:
81: if (!(w = whine_malloc(sizeof(struct watch))))
82: return FALSE;
83:
84: w->watch = watch;
85: w->next = daemon->watches;
86: daemon->watches = w;
87:
88: w = data; /* no warning */
89: return TRUE;
90: }
91:
92: static void remove_watch(DBusWatch *watch, void *data)
93: {
94: struct watch **up, *w, *tmp;
95:
96: for (up = &(daemon->watches), w = daemon->watches; w; w = tmp)
97: {
98: tmp = w->next;
99: if (w->watch == watch)
100: {
101: *up = tmp;
102: free(w);
103: }
104: else
105: up = &(w->next);
106: }
107:
108: w = data; /* no warning */
109: }
110:
111: static void add_update_server(union mysockaddr *addr,
112: union mysockaddr *source_addr,
113: const char *interface,
114: const char *domain)
115: {
116: struct server *serv;
117:
118: /* See if there is a suitable candidate, and unmark */
119: for (serv = daemon->servers; serv; serv = serv->next)
120: if ((serv->flags & SERV_FROM_DBUS) &&
121: (serv->flags & SERV_MARK))
122: {
123: if (domain)
124: {
125: if (!(serv->flags & SERV_HAS_DOMAIN) || !hostname_isequal(domain, serv->domain))
126: continue;
127: }
128: else
129: {
130: if (serv->flags & SERV_HAS_DOMAIN)
131: continue;
132: }
133:
134: serv->flags &= ~SERV_MARK;
135:
136: break;
137: }
138:
139: if (!serv && (serv = whine_malloc(sizeof (struct server))))
140: {
141: /* Not found, create a new one. */
142: memset(serv, 0, sizeof(struct server));
143:
144: if (domain && !(serv->domain = whine_malloc(strlen(domain)+1)))
145: {
146: free(serv);
147: serv = NULL;
148: }
149: else
150: {
151: serv->next = daemon->servers;
152: daemon->servers = serv;
153: serv->flags = SERV_FROM_DBUS;
154: if (domain)
155: {
156: strcpy(serv->domain, domain);
157: serv->flags |= SERV_HAS_DOMAIN;
158: }
159: }
160: }
161:
162: if (serv)
163: {
164: if (interface)
165: strcpy(serv->interface, interface);
166: else
167: serv->interface[0] = 0;
168:
169: if (source_addr->in.sin_family == AF_INET &&
170: addr->in.sin_addr.s_addr == 0 &&
171: serv->domain)
172: serv->flags |= SERV_NO_ADDR;
173: else
174: {
175: serv->flags &= ~SERV_NO_ADDR;
176: serv->addr = *addr;
177: serv->source_addr = *source_addr;
178: }
179: }
180: }
181:
182: static void mark_dbus(void)
183: {
184: struct server *serv;
185:
186: /* mark everything from DBUS */
187: for (serv = daemon->servers; serv; serv = serv->next)
188: if (serv->flags & SERV_FROM_DBUS)
189: serv->flags |= SERV_MARK;
190: }
191:
192: static void cleanup_dbus()
193: {
194: struct server *serv, *tmp, **up;
195:
196: /* unlink and free anything still marked. */
197: for (serv = daemon->servers, up = &daemon->servers; serv; serv = tmp)
198: {
199: tmp = serv->next;
200: if (serv->flags & SERV_MARK)
201: {
202: server_gone(serv);
203: *up = serv->next;
204: if (serv->domain)
205: free(serv->domain);
206: free(serv);
207: }
208: else
209: up = &serv->next;
210: }
211: }
212:
213: static void dbus_read_servers(DBusMessage *message)
214: {
215: DBusMessageIter iter;
216: union mysockaddr addr, source_addr;
217: char *domain;
218:
219: dbus_message_iter_init(message, &iter);
220:
221: mark_dbus();
222:
223: while (1)
224: {
225: int skip = 0;
226:
227: if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
228: {
229: u32 a;
230:
231: dbus_message_iter_get_basic(&iter, &a);
232: dbus_message_iter_next (&iter);
233:
234: #ifdef HAVE_SOCKADDR_SA_LEN
235: source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
236: #endif
237: addr.in.sin_addr.s_addr = ntohl(a);
238: source_addr.in.sin_family = addr.in.sin_family = AF_INET;
239: addr.in.sin_port = htons(NAMESERVER_PORT);
240: source_addr.in.sin_addr.s_addr = INADDR_ANY;
241: source_addr.in.sin_port = htons(daemon->query_port);
242: }
243: else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
244: {
245: unsigned char p[sizeof(struct in6_addr)];
246: unsigned int i;
247:
248: skip = 1;
249:
250: for(i = 0; i < sizeof(struct in6_addr); i++)
251: {
252: dbus_message_iter_get_basic(&iter, &p[i]);
253: dbus_message_iter_next (&iter);
254: if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
255: break;
256: }
257:
258: #ifndef HAVE_IPV6
259: my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
260: #else
261: if (i == sizeof(struct in6_addr)-1)
262: {
263: memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
264: #ifdef HAVE_SOCKADDR_SA_LEN
265: source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
266: #endif
267: source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
268: addr.in6.sin6_port = htons(NAMESERVER_PORT);
269: source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
270: source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
271: source_addr.in6.sin6_addr = in6addr_any;
272: source_addr.in6.sin6_port = htons(daemon->query_port);
273: skip = 0;
274: }
275: #endif
276: }
277: else
278: /* At the end */
279: break;
280:
281: /* process each domain */
282: do {
283: if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
284: {
285: dbus_message_iter_get_basic(&iter, &domain);
286: dbus_message_iter_next (&iter);
287: }
288: else
289: domain = NULL;
290:
291: if (!skip)
292: add_update_server(&addr, &source_addr, NULL, domain);
293:
294: } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
295: }
296:
297: /* unlink and free anything still marked. */
298: cleanup_dbus();
299: }
300:
301: static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
302: {
303: DBusMessageIter iter, array_iter, string_iter;
304: DBusMessage *error = NULL;
305: const char *addr_err;
306: char *dup = NULL;
307:
308: my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
309:
310: if (!dbus_message_iter_init(message, &iter))
311: {
312: return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
313: "Failed to initialize dbus message iter");
314: }
315:
316: /* check that the message contains an array of arrays */
317: if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
318: (dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
319: {
320: return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
321: strings ? "Expected array of string" : "Expected array of string arrays");
322: }
323:
324: mark_dbus();
325:
326: /* array_iter points to each "as" element in the outer array */
327: dbus_message_iter_recurse(&iter, &array_iter);
328: while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
329: {
330: const char *str = NULL;
331: union mysockaddr addr, source_addr;
332: char interface[IF_NAMESIZE];
333: char *str_addr, *str_domain = NULL;
334:
335: if (strings)
336: {
337: dbus_message_iter_get_basic(&array_iter, &str);
338: if (!str || !strlen (str))
339: {
340: error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
341: "Empty string");
342: break;
343: }
344:
345: /* dup the string because it gets modified during parsing */
346: if (dup)
347: free(dup);
348: if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
349: break;
350:
351: strcpy(str_domain, str);
352:
353: /* point to address part of old string for error message */
354: if ((str_addr = strrchr(str, '/')))
355: str = str_addr+1;
356:
357: if ((str_addr = strrchr(str_domain, '/')))
358: {
359: if (*str_domain != '/' || str_addr == str_domain)
360: {
361: error = dbus_message_new_error_printf(message,
362: DBUS_ERROR_INVALID_ARGS,
363: "No domain terminator '%s'",
364: str);
365: break;
366: }
367: *str_addr++ = 0;
368: str_domain++;
369: }
370: else
371: {
372: str_addr = str_domain;
373: str_domain = NULL;
374: }
375:
376:
377: }
378: else
379: {
380: /* check the types of the struct and its elements */
381: if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
382: (dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
383: {
384: error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
385: "Expected inner array of strings");
386: break;
387: }
388:
389: /* string_iter points to each "s" element in the inner array */
390: dbus_message_iter_recurse(&array_iter, &string_iter);
391: if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
392: {
393: /* no IP address given */
394: error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
395: "Expected IP address");
396: break;
397: }
398:
399: dbus_message_iter_get_basic(&string_iter, &str);
400: if (!str || !strlen (str))
401: {
402: error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
403: "Empty IP address");
404: break;
405: }
406:
407: /* dup the string because it gets modified during parsing */
408: if (dup)
409: free(dup);
410: if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
411: break;
412:
413: strcpy(str_addr, str);
414: }
415:
416: memset(&addr, 0, sizeof(addr));
417: memset(&source_addr, 0, sizeof(source_addr));
418: memset(&interface, 0, sizeof(interface));
419:
420: /* parse the IP address */
421: addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, NULL);
422:
423: if (addr_err)
424: {
425: error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
426: "Invalid IP address '%s': %s",
427: str, addr_err);
428: break;
429: }
430:
431: if (strings)
432: {
433: char *p;
434:
435: do {
436: if (str_domain)
437: {
438: if ((p = strchr(str_domain, '/')))
439: *p++ = 0;
440: }
441: else
442: p = NULL;
443:
444: add_update_server(&addr, &source_addr, interface, str_domain);
445: } while ((str_domain = p));
446: }
447: else
448: {
449: /* jump past the address to the domain list (if any) */
450: dbus_message_iter_next (&string_iter);
451:
452: /* parse domains and add each server/domain pair to the list */
453: do {
454: str = NULL;
455: if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
456: dbus_message_iter_get_basic(&string_iter, &str);
457: dbus_message_iter_next (&string_iter);
458:
459: add_update_server(&addr, &source_addr, interface, str);
460: } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
461: }
462:
463: /* jump to next element in outer array */
464: dbus_message_iter_next(&array_iter);
465: }
466:
467: cleanup_dbus();
468:
469: if (dup)
470: free(dup);
471:
472: return error;
473: }
474:
475: DBusHandlerResult message_handler(DBusConnection *connection,
476: DBusMessage *message,
477: void *user_data)
478: {
479: char *method = (char *)dbus_message_get_member(message);
480: DBusMessage *reply = NULL;
481:
482: if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
483: {
484: /* string length: "%s" provides space for termination zero */
485: if (!introspection_xml &&
486: (introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name))))
487: sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name);
488:
489: if (introspection_xml)
490: {
491: reply = dbus_message_new_method_return(message);
492: dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
493: }
494: }
495: else if (strcmp(method, "GetVersion") == 0)
496: {
497: char *v = VERSION;
498: reply = dbus_message_new_method_return(message);
499:
500: dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID);
501: }
502: else if (strcmp(method, "SetServers") == 0)
503: {
504: my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
505: dbus_read_servers(message);
506: check_servers();
507: }
508: else if (strcmp(method, "SetServersEx") == 0)
509: {
510: reply = dbus_read_servers_ex(message, 0);
511: check_servers();
512: }
513: else if (strcmp(method, "SetDomainServers") == 0)
514: {
515: reply = dbus_read_servers_ex(message, 1);
516: check_servers();
517: }
518: else if (strcmp(method, "ClearCache") == 0)
519: clear_cache_and_reload(dnsmasq_time());
520: else
521: return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
522:
523: method = user_data; /* no warning */
524:
525: /* If no reply or no error, return nothing */
526: if (!reply)
527: reply = dbus_message_new_method_return(message);
528:
529: if (reply)
530: {
531: dbus_connection_send (connection, reply, NULL);
532: dbus_message_unref (reply);
533: }
534:
535: return (DBUS_HANDLER_RESULT_HANDLED);
536: }
537:
538:
539: /* returns NULL or error message, may fail silently if dbus daemon not yet up. */
540: char *dbus_init(void)
541: {
542: DBusConnection *connection = NULL;
543: DBusObjectPathVTable dnsmasq_vtable = {NULL, &message_handler, NULL, NULL, NULL, NULL };
544: DBusError dbus_error;
545: DBusMessage *message;
546:
547: dbus_error_init (&dbus_error);
548: if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
549: return NULL;
550:
551: dbus_connection_set_exit_on_disconnect(connection, FALSE);
552: dbus_connection_set_watch_functions(connection, add_watch, remove_watch,
553: NULL, NULL, NULL);
554: dbus_error_init (&dbus_error);
555: dbus_bus_request_name (connection, daemon->dbus_name, 0, &dbus_error);
556: if (dbus_error_is_set (&dbus_error))
557: return (char *)dbus_error.message;
558:
559: if (!dbus_connection_register_object_path(connection, DNSMASQ_PATH,
560: &dnsmasq_vtable, NULL))
561: return _("could not register a DBus message handler");
562:
563: daemon->dbus = connection;
564:
565: if ((message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, "Up")))
566: {
567: dbus_connection_send(connection, message, NULL);
568: dbus_message_unref(message);
569: }
570:
571: return NULL;
572: }
573:
574:
575: void set_dbus_listeners(int *maxfdp,
576: fd_set *rset, fd_set *wset, fd_set *eset)
577: {
578: struct watch *w;
579:
580: for (w = daemon->watches; w; w = w->next)
581: if (dbus_watch_get_enabled(w->watch))
582: {
583: unsigned int flags = dbus_watch_get_flags(w->watch);
584: int fd = dbus_watch_get_unix_fd(w->watch);
585:
586: bump_maxfd(fd, maxfdp);
587:
588: if (flags & DBUS_WATCH_READABLE)
589: FD_SET(fd, rset);
590:
591: if (flags & DBUS_WATCH_WRITABLE)
592: FD_SET(fd, wset);
593:
594: FD_SET(fd, eset);
595: }
596: }
597:
598: void check_dbus_listeners(fd_set *rset, fd_set *wset, fd_set *eset)
599: {
600: DBusConnection *connection = (DBusConnection *)daemon->dbus;
601: struct watch *w;
602:
603: for (w = daemon->watches; w; w = w->next)
604: if (dbus_watch_get_enabled(w->watch))
605: {
606: unsigned int flags = 0;
607: int fd = dbus_watch_get_unix_fd(w->watch);
608:
609: if (FD_ISSET(fd, rset))
610: flags |= DBUS_WATCH_READABLE;
611:
612: if (FD_ISSET(fd, wset))
613: flags |= DBUS_WATCH_WRITABLE;
614:
615: if (FD_ISSET(fd, eset))
616: flags |= DBUS_WATCH_ERROR;
617:
618: if (flags != 0)
619: dbus_watch_handle(w->watch, flags);
620: }
621:
622: if (connection)
623: {
624: dbus_connection_ref (connection);
625: while (dbus_connection_dispatch (connection) == DBUS_DISPATCH_DATA_REMAINS);
626: dbus_connection_unref (connection);
627: }
628: }
629:
630: #ifdef HAVE_DHCP
631: void emit_dbus_signal(int action, struct dhcp_lease *lease, char *hostname)
632: {
633: DBusConnection *connection = (DBusConnection *)daemon->dbus;
634: DBusMessage* message = NULL;
635: DBusMessageIter args;
636: char *action_str, *mac = daemon->namebuff;
637: unsigned char *p;
638: int i;
639:
640: if (!connection)
641: return;
642:
643: if (!hostname)
644: hostname = "";
645:
646: #ifdef HAVE_DHCP6
647: if (lease->flags & (LEASE_TA | LEASE_NA))
648: {
649: print_mac(mac, lease->clid, lease->clid_len);
650: inet_ntop(AF_INET6, lease->hwaddr, daemon->addrbuff, ADDRSTRLEN);
651: }
652: else
653: #endif
654: {
655: p = extended_hwaddr(lease->hwaddr_type, lease->hwaddr_len,
656: lease->hwaddr, lease->clid_len, lease->clid, &i);
657: print_mac(mac, p, i);
658: inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
659: }
660:
661: if (action == ACTION_DEL)
662: action_str = "DhcpLeaseDeleted";
663: else if (action == ACTION_ADD)
664: action_str = "DhcpLeaseAdded";
665: else if (action == ACTION_OLD)
666: action_str = "DhcpLeaseUpdated";
667: else
668: return;
669:
670: if (!(message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, action_str)))
671: return;
672:
673: dbus_message_iter_init_append(message, &args);
674:
675: if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &daemon->addrbuff) &&
676: dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mac) &&
677: dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &hostname))
678: dbus_connection_send(connection, message, NULL);
679:
680: dbus_message_unref(message);
681: }
682: #endif
683:
684: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dbus.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src