--- embedaddon/dnsmasq/src/dbus.c 2014/06/15 16:31:38 1.1.1.2 +++ embedaddon/dnsmasq/src/dbus.c 2023/09/27 11:02:07 1.1.1.5 @@ -1,4 +1,4 @@ -/* dnsmasq is Copyright (c) 2000-2014 Simon Kelley +/* dnsmasq is Copyright (c) 2000-2022 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 @@ -35,6 +35,11 @@ const char* introspection_xml_template = " \n" " \n" " \n" +#ifdef HAVE_LOOP +" \n" +" \n" +" \n" +#endif " \n" " \n" " \n" @@ -44,6 +49,15 @@ const char* introspection_xml_template = " \n" " \n" " \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" " \n" " \n" " \n" @@ -59,6 +73,29 @@ const char* introspection_xml_template = " \n" " \n" " \n" +#ifdef HAVE_DHCP +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +#endif +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" +" \n" " \n" "\n"; @@ -85,7 +122,7 @@ static dbus_bool_t add_watch(DBusWatch *watch, void *d w->next = daemon->watches; daemon->watches = w; - w = data; /* no warning */ + (void)data; /* no warning */ return TRUE; } @@ -105,16 +142,20 @@ static void remove_watch(DBusWatch *watch, void *data) up = &(w->next); } - w = data; /* no warning */ + (void)data; /* no warning */ } -static void dbus_read_servers(DBusMessage *message) +static DBusMessage* dbus_read_servers(DBusMessage *message) { DBusMessageIter iter; union mysockaddr addr, source_addr; char *domain; - dbus_message_iter_init(message, &iter); + if (!dbus_message_iter_init(message, &iter)) + { + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Failed to initialize dbus message iter"); + } mark_servers(SERV_FROM_DBUS); @@ -150,13 +191,13 @@ static void dbus_read_servers(DBusMessage *message) 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; + { + i++; + 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) + if (i == sizeof(struct in6_addr)) { memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr)); #ifdef HAVE_SOCKADDR_SA_LEN @@ -170,7 +211,6 @@ static void dbus_read_servers(DBusMessage *message) source_addr.in6.sin6_port = htons(daemon->query_port); skip = 0; } -#endif } else /* At the end */ @@ -187,15 +227,39 @@ static void dbus_read_servers(DBusMessage *message) domain = NULL; if (!skip) - add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain); + add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain, NULL); } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING); } /* unlink and free anything still marked. */ cleanup_servers(); + return NULL; } +#ifdef HAVE_LOOP +static DBusMessage *dbus_reply_server_loop(DBusMessage *message) +{ + DBusMessageIter args, args_iter; + struct server *serv; + DBusMessage *reply = dbus_message_new_method_return(message); + + dbus_message_iter_init_append (reply, &args); + dbus_message_iter_open_container (&args, DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING, &args_iter); + + for (serv = daemon->servers; serv; serv = serv->next) + if (serv->flags & SERV_LOOP) + { + (void)prettyprint_addr(&serv->addr, daemon->addrbuff); + dbus_message_iter_append_basic (&args_iter, DBUS_TYPE_STRING, &daemon->addrbuff); + } + + dbus_message_iter_close_container (&args, &args_iter); + + return reply; +} +#endif + static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings) { DBusMessageIter iter, array_iter, string_iter; @@ -225,9 +289,14 @@ static DBusMessage* dbus_read_servers_ex(DBusMessage * { const char *str = NULL; union mysockaddr addr, source_addr; - int flags = 0; + u16 flags = 0; char interface[IF_NAMESIZE]; char *str_addr, *str_domain = NULL; + struct server_details sdetails = { 0 }; + sdetails.addr = &addr; + sdetails.source_addr = &source_addr; + sdetails.interface = interface; + sdetails.flags = &flags; if (strings) { @@ -310,24 +379,6 @@ static DBusMessage* dbus_read_servers_ex(DBusMessage * 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; @@ -341,7 +392,31 @@ static DBusMessage* dbus_read_servers_ex(DBusMessage * else p = NULL; - add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain); + if (strings && strlen(str_addr) == 0) + add_update_server(SERV_LITERAL_ADDRESS | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain, NULL); + else + { + if ((addr_err = parse_server(str_addr, &sdetails))) + { + error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid IP address '%s': %s", + str, addr_err); + break; + } + + while (parse_server_next(&sdetails)) + { + if ((addr_err = parse_server_addr(&sdetails))) + { + error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid IP address '%s': %s", + str, addr_err); + break; + } + + add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain, NULL); + } + } } while ((str_domain = p)); } else @@ -355,23 +430,340 @@ static DBusMessage* dbus_read_servers_ex(DBusMessage * 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); + + if ((addr_err = parse_server(str_addr, &sdetails))) + { + error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid IP address '%s': %s", + str, addr_err); + break; + } - add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str); + while (parse_server_next(&sdetails)) + { + if ((addr_err = parse_server_addr(&sdetails))) + { + 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_LITERAL_ADDRESS; + else + flags &= ~SERV_LITERAL_ADDRESS; + + add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str, NULL); + } } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING); } - + + if (sdetails.orig_hostinfo) + freeaddrinfo(sdetails.orig_hostinfo); + /* 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; +} + +#ifdef HAVE_DHCP +static DBusMessage *dbus_add_lease(DBusMessage* message) +{ + struct dhcp_lease *lease; + const char *ipaddr, *hwaddr, *hostname, *tmp; + const unsigned char* clid; + int clid_len, hostname_len, hw_len, hw_type; + dbus_uint32_t expires, ia_id; + dbus_bool_t is_temporary; + union all_addr addr; + time_t now = dnsmasq_time(); + unsigned char dhcp_chaddr[DHCP_CHADDR_MAX]; + + DBusMessageIter iter, array_iter; + if (!dbus_message_iter_init(message, &iter)) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Failed to initialize dbus message iter"); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected string as first argument"); + + dbus_message_iter_get_basic(&iter, &ipaddr); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected string as second argument"); + + dbus_message_iter_get_basic(&iter, &hwaddr); + dbus_message_iter_next(&iter); + + if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) || + (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE)) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected byte array as third argument"); + + dbus_message_iter_recurse(&iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &hostname, &hostname_len); + tmp = memchr(hostname, '\0', hostname_len); + if (tmp) + { + if (tmp == &hostname[hostname_len - 1]) + hostname_len--; + else + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Hostname contains an embedded NUL character"); + } + dbus_message_iter_next(&iter); + + if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) || + (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE)) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected byte array as fourth argument"); + + dbus_message_iter_recurse(&iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &clid, &clid_len); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected uint32 as fifth argument"); + + dbus_message_iter_get_basic(&iter, &expires); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected uint32 as sixth argument"); + + dbus_message_iter_get_basic(&iter, &ia_id); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected uint32 as sixth argument"); + + dbus_message_iter_get_basic(&iter, &is_temporary); + + if (inet_pton(AF_INET, ipaddr, &addr.addr4)) + { + if (ia_id != 0 || is_temporary) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "ia_id and is_temporary must be zero for IPv4 lease"); + + if (!(lease = lease_find_by_addr(addr.addr4))) + lease = lease4_allocate(addr.addr4); + } +#ifdef HAVE_DHCP6 + else if (inet_pton(AF_INET6, ipaddr, &addr.addr6)) + { + if (!(lease = lease6_find_by_addr(&addr.addr6, 128, 0))) + lease = lease6_allocate(&addr.addr6, + is_temporary ? LEASE_TA : LEASE_NA); + lease_set_iaid(lease, ia_id); + } +#endif + else + return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid IP address '%s'", ipaddr); + + hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL, &hw_type); + if (hw_len < 0) + return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid HW address '%s'", hwaddr); + + if (hw_type == 0 && hw_len != 0) + hw_type = ARPHRD_ETHER; + + lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type, + clid_len, now, 0); + lease_set_expires(lease, expires, now); + if (hostname_len != 0) + lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL); + + lease_update_file(now); + lease_update_dns(0); + + return NULL; +} + +static DBusMessage *dbus_del_lease(DBusMessage* message) +{ + struct dhcp_lease *lease; + DBusMessageIter iter; + const char *ipaddr; + DBusMessage *reply; + union all_addr addr; + dbus_bool_t ret = 1; + time_t now = dnsmasq_time(); + + if (!dbus_message_iter_init(message, &iter)) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Failed to initialize dbus message iter"); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) + return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, + "Expected string as first argument"); + + dbus_message_iter_get_basic(&iter, &ipaddr); + + if (inet_pton(AF_INET, ipaddr, &addr.addr4)) + lease = lease_find_by_addr(addr.addr4); +#ifdef HAVE_DHCP6 + else if (inet_pton(AF_INET6, ipaddr, &addr.addr6)) + lease = lease6_find_by_addr(&addr.addr6, 128, 0); +#endif + else + return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, + "Invalid IP address '%s'", ipaddr); + + if (lease) + { + lease_prune(lease, now); + lease_update_file(now); + lease_update_dns(0); + } + else + ret = 0; + + if ((reply = dbus_message_new_method_return(message))) + dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret, + DBUS_TYPE_INVALID); + + + return reply; +} +#endif + +static DBusMessage *dbus_get_metrics(DBusMessage* message) +{ + DBusMessage *reply = dbus_message_new_method_return(message); + DBusMessageIter array, dict, iter; + int i; + + dbus_message_iter_init_append(reply, &iter); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{su}", &array); + + for (i = 0; i < __METRIC_MAX; i++) { + const char *key = get_metric_name(i); + dbus_uint32_t value = daemon->metrics[i]; + + dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &dict); + dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key); + dbus_message_iter_append_basic(&dict, DBUS_TYPE_UINT32, &value); + dbus_message_iter_close_container(&array, &dict); + } + + dbus_message_iter_close_container(&iter, &array); + + return reply; +} + +static void add_dict_entry(DBusMessageIter *container, const char *key, const char *val) +{ + DBusMessageIter dict; + + dbus_message_iter_open_container(container, DBUS_TYPE_DICT_ENTRY, NULL, &dict); + dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key); + dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &val); + dbus_message_iter_close_container(container, &dict); +} + +static void add_dict_int(DBusMessageIter *container, const char *key, const unsigned int val) +{ + snprintf(daemon->namebuff, MAXDNAME, "%u", val); + + add_dict_entry(container, key, daemon->namebuff); +} + +static DBusMessage *dbus_get_server_metrics(DBusMessage* message) +{ + DBusMessage *reply = dbus_message_new_method_return(message); + DBusMessageIter server_array, dict_array, server_iter; + struct server *serv; + + dbus_message_iter_init_append(reply, &server_iter); + dbus_message_iter_open_container(&server_iter, DBUS_TYPE_ARRAY, "a{ss}", &server_array); + + /* sum counts from different records for same server */ + for (serv = daemon->servers; serv; serv = serv->next) + serv->flags &= ~SERV_MARK; + + for (serv = daemon->servers; serv; serv = serv->next) + if (!(serv->flags & SERV_MARK)) + { + unsigned int port; + unsigned int queries = 0, failed_queries = 0, nxdomain_replies = 0, retrys = 0; + unsigned int sigma_latency = 0, count_latency = 0; + + struct server *serv1; + + for (serv1 = serv; serv1; serv1 = serv1->next) + if (!(serv1->flags & SERV_MARK) && sockaddr_isequal(&serv->addr, &serv1->addr)) + { + serv1->flags |= SERV_MARK; + queries += serv1->queries; + failed_queries += serv1->failed_queries; + nxdomain_replies += serv1->nxdomain_replies; + retrys += serv1->retrys; + sigma_latency += serv1->query_latency; + count_latency++; + } + + dbus_message_iter_open_container(&server_array, DBUS_TYPE_ARRAY, "{ss}", &dict_array); + + port = prettyprint_addr(&serv->addr, daemon->namebuff); + add_dict_entry(&dict_array, "address", daemon->namebuff); + + add_dict_int(&dict_array, "port", port); + add_dict_int(&dict_array, "queries", serv->queries); + add_dict_int(&dict_array, "failed_queries", serv->failed_queries); + add_dict_int(&dict_array, "nxdomain", serv->nxdomain_replies); + add_dict_int(&dict_array, "retries", serv->retrys); + add_dict_int(&dict_array, "latency", sigma_latency/count_latency); + + dbus_message_iter_close_container(&server_array, &dict_array); + } + + dbus_message_iter_close_container(&server_iter, &server_array); + + return reply; +} + DBusHandlerResult message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) @@ -400,9 +792,15 @@ DBusHandlerResult message_handler(DBusConnection *conn dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID); } +#ifdef HAVE_LOOP + else if (strcmp(method, "GetLoopServers") == 0) + { + reply = dbus_reply_server_loop(message); + } +#endif else if (strcmp(method, "SetServers") == 0) { - dbus_read_servers(message); + reply = dbus_read_servers(message); new_servers = 1; } else if (strcmp(method, "SetServersEx") == 0) @@ -415,6 +813,40 @@ DBusHandlerResult message_handler(DBusConnection *conn 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, "SetLocaliseQueriesOption") == 0) + { + reply = dbus_set_bool(message, OPT_LOCALISE, "localise-queries"); + } + else if (strcmp(method, "SetBogusPrivOption") == 0) + { + reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv"); + } +#ifdef HAVE_DHCP + else if (strcmp(method, "AddDhcpLease") == 0) + { + reply = dbus_add_lease(message); + } + else if (strcmp(method, "DeleteDhcpLease") == 0) + { + reply = dbus_del_lease(message); + } +#endif + else if (strcmp(method, "GetMetrics") == 0) + { + reply = dbus_get_metrics(message); + } + else if (strcmp(method, "GetServerMetrics") == 0) + { + reply = dbus_get_server_metrics(message); + } + else if (strcmp(method, "ClearMetrics") == 0) + { + clear_metrics(); + } else if (strcmp(method, "ClearCache") == 0) clear_cache = 1; else @@ -423,7 +855,7 @@ DBusHandlerResult message_handler(DBusConnection *conn if (new_servers) { my_syslog(LOG_INFO, _("setting upstream servers from DBus")); - check_servers(); + check_servers(0); if (option_bool(OPT_RELOAD)) clear_cache = 1; } @@ -431,7 +863,7 @@ DBusHandlerResult message_handler(DBusConnection *conn if (clear_cache) clear_cache_and_reload(dnsmasq_time()); - method = user_data; /* no warning */ + (void)user_data; /* no warning */ /* If no reply or no error, return nothing */ if (!reply) @@ -457,8 +889,11 @@ char *dbus_init(void) dbus_error_init (&dbus_error); if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error))) - return NULL; - + { + dbus_error_free(&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); @@ -483,8 +918,7 @@ char *dbus_init(void) } -void set_dbus_listeners(int *maxfdp, - fd_set *rset, fd_set *wset, fd_set *eset) +void set_dbus_listeners(void) { struct watch *w; @@ -494,19 +928,17 @@ void set_dbus_listeners(int *maxfdp, 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); + poll_listen(fd, POLLIN); if (flags & DBUS_WATCH_WRITABLE) - FD_SET(fd, wset); + poll_listen(fd, POLLOUT); - FD_SET(fd, eset); + poll_listen(fd, POLLERR); } } -void check_dbus_listeners(fd_set *rset, fd_set *wset, fd_set *eset) +void check_dbus_listeners() { DBusConnection *connection = (DBusConnection *)daemon->dbus; struct watch *w; @@ -517,13 +949,13 @@ void check_dbus_listeners(fd_set *rset, fd_set *wset, unsigned int flags = 0; int fd = dbus_watch_get_unix_fd(w->watch); - if (FD_ISSET(fd, rset)) + if (poll_check(fd, POLLIN)) flags |= DBUS_WATCH_READABLE; - if (FD_ISSET(fd, wset)) + if (poll_check(fd, POLLOUT)) flags |= DBUS_WATCH_WRITABLE; - if (FD_ISSET(fd, eset)) + if (poll_check(fd, POLLERR)) flags |= DBUS_WATCH_ERROR; if (flags != 0) @@ -558,7 +990,7 @@ void emit_dbus_signal(int action, struct dhcp_lease *l if (lease->flags & (LEASE_TA | LEASE_NA)) { print_mac(mac, lease->clid, lease->clid_len); - inet_ntop(AF_INET6, lease->hwaddr, daemon->addrbuff, ADDRSTRLEN); + inet_ntop(AF_INET6, &lease->addr6, daemon->addrbuff, ADDRSTRLEN); } else #endif