version 1.1.1.2, 2014/06/15 16:31:38
|
version 1.1.1.5, 2023/09/27 11:02:07
|
Line 1
|
Line 1
|
/* 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 |
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 |
it under the terms of the GNU General Public License as published by |
Line 35 const char* introspection_xml_template =
|
Line 35 const char* introspection_xml_template =
|
" <method name=\"GetVersion\">\n" |
" <method name=\"GetVersion\">\n" |
" <arg name=\"version\" direction=\"out\" type=\"s\"/>\n" |
" <arg name=\"version\" direction=\"out\" type=\"s\"/>\n" |
" </method>\n" |
" </method>\n" |
|
#ifdef HAVE_LOOP |
|
" <method name=\"GetLoopServers\">\n" |
|
" <arg name=\"server\" direction=\"out\" type=\"as\"/>\n" |
|
" </method>\n" |
|
#endif |
" <method name=\"SetServers\">\n" |
" <method name=\"SetServers\">\n" |
" <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n" |
" <arg name=\"servers\" direction=\"in\" type=\"av\"/>\n" |
" </method>\n" |
" </method>\n" |
Line 44 const char* introspection_xml_template =
|
Line 49 const char* introspection_xml_template =
|
" <method name=\"SetServersEx\">\n" |
" <method name=\"SetServersEx\">\n" |
" <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n" |
" <arg name=\"servers\" direction=\"in\" type=\"aas\"/>\n" |
" </method>\n" |
" </method>\n" |
|
" <method name=\"SetFilterWin2KOption\">\n" |
|
" <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n" |
|
" </method>\n" |
|
" <method name=\"SetLocaliseQueriesOption\">\n" |
|
" <arg name=\"localise-queries\" direction=\"in\" type=\"b\"/>\n" |
|
" </method>\n" |
|
" <method name=\"SetBogusPrivOption\">\n" |
|
" <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n" |
|
" </method>\n" |
" <signal name=\"DhcpLeaseAdded\">\n" |
" <signal name=\"DhcpLeaseAdded\">\n" |
" <arg name=\"ipaddr\" type=\"s\"/>\n" |
" <arg name=\"ipaddr\" type=\"s\"/>\n" |
" <arg name=\"hwaddr\" type=\"s\"/>\n" |
" <arg name=\"hwaddr\" type=\"s\"/>\n" |
Line 59 const char* introspection_xml_template =
|
Line 73 const char* introspection_xml_template =
|
" <arg name=\"hwaddr\" type=\"s\"/>\n" |
" <arg name=\"hwaddr\" type=\"s\"/>\n" |
" <arg name=\"hostname\" type=\"s\"/>\n" |
" <arg name=\"hostname\" type=\"s\"/>\n" |
" </signal>\n" |
" </signal>\n" |
|
#ifdef HAVE_DHCP |
|
" <method name=\"AddDhcpLease\">\n" |
|
" <arg name=\"ipaddr\" type=\"s\"/>\n" |
|
" <arg name=\"hwaddr\" type=\"s\"/>\n" |
|
" <arg name=\"hostname\" type=\"ay\"/>\n" |
|
" <arg name=\"clid\" type=\"ay\"/>\n" |
|
" <arg name=\"lease_duration\" type=\"u\"/>\n" |
|
" <arg name=\"ia_id\" type=\"u\"/>\n" |
|
" <arg name=\"is_temporary\" type=\"b\"/>\n" |
|
" </method>\n" |
|
" <method name=\"DeleteDhcpLease\">\n" |
|
" <arg name=\"ipaddr\" type=\"s\"/>\n" |
|
" <arg name=\"success\" type=\"b\" direction=\"out\"/>\n" |
|
" </method>\n" |
|
#endif |
|
" <method name=\"GetMetrics\">\n" |
|
" <arg name=\"metrics\" direction=\"out\" type=\"a{su}\"/>\n" |
|
" </method>\n" |
|
" <method name=\"GetServerMetrics\">\n" |
|
" <arg name=\"metrics\" direction=\"out\" type=\"a{ss}\"/>\n" |
|
" </method>\n" |
|
" <method name=\"ClearMetrics\">\n" |
|
" </method>\n" |
" </interface>\n" |
" </interface>\n" |
"</node>\n"; |
"</node>\n"; |
|
|
Line 85 static dbus_bool_t add_watch(DBusWatch *watch, void *d
|
Line 122 static dbus_bool_t add_watch(DBusWatch *watch, void *d
|
w->next = daemon->watches; |
w->next = daemon->watches; |
daemon->watches = w; |
daemon->watches = w; |
|
|
w = data; /* no warning */ | (void)data; /* no warning */ |
return TRUE; |
return TRUE; |
} |
} |
|
|
Line 105 static void remove_watch(DBusWatch *watch, void *data)
|
Line 142 static void remove_watch(DBusWatch *watch, void *data)
|
up = &(w->next); |
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; |
DBusMessageIter iter; |
union mysockaddr addr, source_addr; |
union mysockaddr addr, source_addr; |
char *domain; |
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); |
mark_servers(SERV_FROM_DBUS); |
|
|
Line 150 static void dbus_read_servers(DBusMessage *message)
|
Line 191 static void dbus_read_servers(DBusMessage *message)
|
dbus_message_iter_get_basic(&iter, &p[i]); |
dbus_message_iter_get_basic(&iter, &p[i]); |
dbus_message_iter_next (&iter); |
dbus_message_iter_next (&iter); |
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE) |
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE) |
break; | { |
| i++; |
| break; |
| } |
} |
} |
|
|
#ifndef HAVE_IPV6 | if (i == sizeof(struct in6_addr)) |
my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support")); | |
#else | |
if (i == sizeof(struct in6_addr)-1) | |
{ |
{ |
memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr)); |
memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr)); |
#ifdef HAVE_SOCKADDR_SA_LEN |
#ifdef HAVE_SOCKADDR_SA_LEN |
Line 170 static void dbus_read_servers(DBusMessage *message)
|
Line 211 static void dbus_read_servers(DBusMessage *message)
|
source_addr.in6.sin6_port = htons(daemon->query_port); |
source_addr.in6.sin6_port = htons(daemon->query_port); |
skip = 0; |
skip = 0; |
} |
} |
#endif |
|
} |
} |
else |
else |
/* At the end */ |
/* At the end */ |
Line 187 static void dbus_read_servers(DBusMessage *message)
|
Line 227 static void dbus_read_servers(DBusMessage *message)
|
domain = NULL; |
domain = NULL; |
|
|
if (!skip) |
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); |
} while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING); |
} |
} |
|
|
/* unlink and free anything still marked. */ |
/* unlink and free anything still marked. */ |
cleanup_servers(); |
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) |
static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings) |
{ |
{ |
DBusMessageIter iter, array_iter, string_iter; |
DBusMessageIter iter, array_iter, string_iter; |
Line 225 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
Line 289 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
{ |
{ |
const char *str = NULL; |
const char *str = NULL; |
union mysockaddr addr, source_addr; |
union mysockaddr addr, source_addr; |
int flags = 0; | u16 flags = 0; |
char interface[IF_NAMESIZE]; |
char interface[IF_NAMESIZE]; |
char *str_addr, *str_domain = NULL; |
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) |
if (strings) |
{ |
{ |
Line 310 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
Line 379 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
strcpy(str_addr, str); |
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) |
if (strings) |
{ |
{ |
char *p; |
char *p; |
Line 341 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
Line 392 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
else |
else |
p = NULL; |
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)); |
} while ((str_domain = p)); |
} |
} |
else |
else |
Line 355 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
Line 430 static DBusMessage* dbus_read_servers_ex(DBusMessage *
|
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING) |
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING) |
dbus_message_iter_get_basic(&string_iter, &str); |
dbus_message_iter_get_basic(&string_iter, &str); |
dbus_message_iter_next (&string_iter); |
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); |
} 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 */ |
/* jump to next element in outer array */ |
dbus_message_iter_next(&array_iter); |
dbus_message_iter_next(&array_iter); |
} |
} |
|
|
cleanup_servers(); |
cleanup_servers(); |
| |
if (dup) |
if (dup) |
free(dup); |
free(dup); |
|
|
return error; |
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, |
DBusHandlerResult message_handler(DBusConnection *connection, |
DBusMessage *message, |
DBusMessage *message, |
void *user_data) |
void *user_data) |
Line 400 DBusHandlerResult message_handler(DBusConnection *conn
|
Line 792 DBusHandlerResult message_handler(DBusConnection *conn
|
|
|
dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID); |
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) |
else if (strcmp(method, "SetServers") == 0) |
{ |
{ |
dbus_read_servers(message); | reply = dbus_read_servers(message); |
new_servers = 1; |
new_servers = 1; |
} |
} |
else if (strcmp(method, "SetServersEx") == 0) |
else if (strcmp(method, "SetServersEx") == 0) |
Line 415 DBusHandlerResult message_handler(DBusConnection *conn
|
Line 813 DBusHandlerResult message_handler(DBusConnection *conn
|
reply = dbus_read_servers_ex(message, 1); |
reply = dbus_read_servers_ex(message, 1); |
new_servers = 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) |
else if (strcmp(method, "ClearCache") == 0) |
clear_cache = 1; |
clear_cache = 1; |
else |
else |
Line 423 DBusHandlerResult message_handler(DBusConnection *conn
|
Line 855 DBusHandlerResult message_handler(DBusConnection *conn
|
if (new_servers) |
if (new_servers) |
{ |
{ |
my_syslog(LOG_INFO, _("setting upstream servers from DBus")); |
my_syslog(LOG_INFO, _("setting upstream servers from DBus")); |
check_servers(); | check_servers(0); |
if (option_bool(OPT_RELOAD)) |
if (option_bool(OPT_RELOAD)) |
clear_cache = 1; |
clear_cache = 1; |
} |
} |
Line 431 DBusHandlerResult message_handler(DBusConnection *conn
|
Line 863 DBusHandlerResult message_handler(DBusConnection *conn
|
if (clear_cache) |
if (clear_cache) |
clear_cache_and_reload(dnsmasq_time()); |
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 no reply or no error, return nothing */ |
if (!reply) |
if (!reply) |
Line 457 char *dbus_init(void)
|
Line 889 char *dbus_init(void)
|
|
|
dbus_error_init (&dbus_error); |
dbus_error_init (&dbus_error); |
if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &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_exit_on_disconnect(connection, FALSE); |
dbus_connection_set_watch_functions(connection, add_watch, remove_watch, |
dbus_connection_set_watch_functions(connection, add_watch, remove_watch, |
NULL, NULL, NULL); |
NULL, NULL, NULL); |
Line 483 char *dbus_init(void)
|
Line 918 char *dbus_init(void)
|
} |
} |
|
|
|
|
void set_dbus_listeners(int *maxfdp, | void set_dbus_listeners(void) |
fd_set *rset, fd_set *wset, fd_set *eset) | |
{ |
{ |
struct watch *w; |
struct watch *w; |
|
|
Line 494 void set_dbus_listeners(int *maxfdp,
|
Line 928 void set_dbus_listeners(int *maxfdp,
|
unsigned int flags = dbus_watch_get_flags(w->watch); |
unsigned int flags = dbus_watch_get_flags(w->watch); |
int fd = dbus_watch_get_unix_fd(w->watch); |
int fd = dbus_watch_get_unix_fd(w->watch); |
|
|
bump_maxfd(fd, maxfdp); |
|
|
|
if (flags & DBUS_WATCH_READABLE) |
if (flags & DBUS_WATCH_READABLE) |
FD_SET(fd, rset); | poll_listen(fd, POLLIN); |
|
|
if (flags & DBUS_WATCH_WRITABLE) |
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; |
DBusConnection *connection = (DBusConnection *)daemon->dbus; |
struct watch *w; |
struct watch *w; |
Line 517 void check_dbus_listeners(fd_set *rset, fd_set *wset,
|
Line 949 void check_dbus_listeners(fd_set *rset, fd_set *wset,
|
unsigned int flags = 0; |
unsigned int flags = 0; |
int fd = dbus_watch_get_unix_fd(w->watch); |
int fd = dbus_watch_get_unix_fd(w->watch); |
|
|
if (FD_ISSET(fd, rset)) | if (poll_check(fd, POLLIN)) |
flags |= DBUS_WATCH_READABLE; |
flags |= DBUS_WATCH_READABLE; |
|
|
if (FD_ISSET(fd, wset)) | if (poll_check(fd, POLLOUT)) |
flags |= DBUS_WATCH_WRITABLE; |
flags |= DBUS_WATCH_WRITABLE; |
|
|
if (FD_ISSET(fd, eset)) | if (poll_check(fd, POLLERR)) |
flags |= DBUS_WATCH_ERROR; |
flags |= DBUS_WATCH_ERROR; |
|
|
if (flags != 0) |
if (flags != 0) |
Line 558 void emit_dbus_signal(int action, struct dhcp_lease *l
|
Line 990 void emit_dbus_signal(int action, struct dhcp_lease *l
|
if (lease->flags & (LEASE_TA | LEASE_NA)) |
if (lease->flags & (LEASE_TA | LEASE_NA)) |
{ |
{ |
print_mac(mac, lease->clid, lease->clid_len); |
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 |
else |
#endif |
#endif |