X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-daemon%2Fdbus-protocol.c;h=b6a4e5d22473b00df66a2a723084d631037ec9af;hb=f17d2832301b0f2fcd50fdcc6fec77666178158f;hp=36ad6909d868149db1734cc90e9f15dee06870e1;hpb=f8cc6a9085484ca90baa3967cc9ac440b8b309b6;p=catta diff --git a/avahi-daemon/dbus-protocol.c b/avahi-daemon/dbus-protocol.c index 36ad690..b6a4e5d 100644 --- a/avahi-daemon/dbus-protocol.c +++ b/avahi-daemon/dbus-protocol.c @@ -25,6 +25,8 @@ #include #include +#include +#include #include #include #include @@ -33,6 +35,7 @@ #include #include #include +#include #include @@ -43,8 +46,11 @@ #include #include #include + #include #include +#include +#include #include "dbus-protocol.h" #include "main.h" @@ -62,11 +68,11 @@ typedef struct ServiceBrowserInfo ServiceBrowserInfo; typedef struct SyncServiceResolverInfo SyncServiceResolverInfo; typedef struct AsyncServiceResolverInfo AsyncServiceResolverInfo; -#define MAX_CLIENTS 20 +#define MAX_CLIENTS 256 #define MAX_OBJECTS_PER_CLIENT 50 #define MAX_ENTRIES_PER_ENTRY_GROUP 20 -/* #define VALGRIND_WORKAROUND */ +/* #define VALGRIND_WORKAROUND 1 */ struct EntryGroupInfo { unsigned id; @@ -198,7 +204,7 @@ static void entry_group_free(EntryGroupInfo *i) { assert(i->client->n_objects >= 0); avahi_free(i); - } +} static void sync_host_name_resolver_free(SyncHostNameResolverInfo *i) { assert(i); @@ -422,10 +428,15 @@ static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, int er assert(-error > -AVAHI_OK); assert(-error < -AVAHI_ERR_MAX); + + if (!text) + text = avahi_strerror(error); - reply = dbus_message_new_error(m, avahi_error_number_to_dbus (error), text ? text : avahi_strerror(error)); + reply = dbus_message_new_error(m, avahi_error_number_to_dbus(error), text); dbus_connection_send(c, reply, NULL); dbus_message_unref(reply); + + avahi_log_debug(__FILE__": Responding error '%s' (%i)", text, error); return DBUS_HANDLER_RESULT_HANDLED; } @@ -452,6 +463,28 @@ static DBusHandlerResult respond_int32(DBusConnection *c, DBusMessage *m, int32_ return DBUS_HANDLER_RESULT_HANDLED; } +static DBusHandlerResult respond_uint32(DBusConnection *c, DBusMessage *m, uint32_t u) { + DBusMessage *reply; + + reply = dbus_message_new_method_return(m); + dbus_message_append_args(reply, DBUS_TYPE_UINT32, &u, DBUS_TYPE_INVALID); + dbus_connection_send(c, reply, NULL); + dbus_message_unref(reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult respond_boolean(DBusConnection *c, DBusMessage *m, int b) { + DBusMessage *reply; + + reply = dbus_message_new_method_return(m); + dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID); + dbus_connection_send(c, reply, NULL); + dbus_message_unref(reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + static DBusHandlerResult respond_ok(DBusConnection *c, DBusMessage *m) { DBusMessage *reply; @@ -473,6 +506,17 @@ static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const c return DBUS_HANDLER_RESULT_HANDLED; } +static void append_server_error(DBusMessage *reply) { + const char *t; + + t = avahi_error_number_to_dbus(avahi_server_errno(avahi_server)); + + dbus_message_append_args( + reply, + DBUS_TYPE_STRING, &t, + DBUS_TYPE_INVALID); +} + static char *file_get_contents(char *fname) { int fd = -1; struct stat st; @@ -524,6 +568,28 @@ fail: } +static const char *map_browse_signal_name(AvahiBrowserEvent e) { + switch (e) { + case AVAHI_BROWSER_NEW : return "ItemNew"; + case AVAHI_BROWSER_REMOVE : return "ItemRemove"; + case AVAHI_BROWSER_FAILURE : return "Failure"; + case AVAHI_BROWSER_CACHE_EXHAUSTED : return "CacheExhausted"; + case AVAHI_BROWSER_ALL_FOR_NOW : return "AllForNow"; + } + + abort(); +} + +static const char *map_resolve_signal_name(AvahiResolverEvent e) { + switch (e) { + case AVAHI_RESOLVER_FOUND : return "Found"; + case AVAHI_RESOLVER_FAILURE : return "Failure"; + } + + abort(); +} + + static DBusHandlerResult handle_introspect(DBusConnection *c, DBusMessage *m, const char *fname) { char *path, *contents; DBusError error; @@ -566,7 +632,7 @@ static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage * dbus_error_init(&error); -/* avahi_log_debug("dbus: interface=%s, path=%s, member=%s", */ +/* avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", */ /* dbus_message_get_interface(m), */ /* dbus_message_get_path(m), */ /* dbus_message_get_member(m)); */ @@ -574,7 +640,7 @@ static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage * if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected")) { /* No, we shouldn't quit, but until we get somewhere * usefull such that we can restore our state, we will */ - avahi_log_warn("Disconnnected from d-bus, terminating..."); + avahi_log_warn("Disconnnected from D-BUS, terminating..."); raise(SIGQUIT); /* The signal handler will catch this and terminate the process cleanly*/ @@ -588,7 +654,7 @@ static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage * goto fail; } -/* avahi_log_info("dbus: name acquired (%s)", name); */ +/* avahi_log_info(__FILE__": name acquired (%s)", name); */ return DBUS_HANDLER_RESULT_HANDLED; } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) { @@ -603,7 +669,7 @@ static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage * Client *client; if ((client = client_get(name, FALSE))) { -/* avahi_log_info("dbus: client %s vanished", name); */ + avahi_log_debug(__FILE__": client %s vanished.", name); client_free(client); } } @@ -620,19 +686,84 @@ static void entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntry EntryGroupInfo *i = userdata; DBusMessage *m; int32_t t; + const char *e; assert(s); assert(g); assert(i); m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged"); + t = (int32_t) state; - dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID); + if (state == AVAHI_ENTRY_GROUP_FAILURE) + e = avahi_error_number_to_dbus(avahi_server_errno(s)); + else if (state == AVAHI_ENTRY_GROUP_COLLISION) + e = AVAHI_DBUS_ERR_COLLISION; + else + e = AVAHI_DBUS_ERR_OK; + + dbus_message_append_args( + m, + DBUS_TYPE_INT32, &t, + DBUS_TYPE_STRING, &e, + DBUS_TYPE_INVALID); dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); } +static int read_strlst(DBusMessage *m, int idx, AvahiStringList **l) { + DBusMessageIter iter, sub; + int j; + AvahiStringList *strlst = NULL; + + assert(m); + assert(l); + + dbus_message_iter_init(m, &iter); + + for (j = 0; j < idx; j++) + 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_ARRAY) + goto fail; + + dbus_message_iter_recurse(&iter, &sub); + + for (;;) { + DBusMessageIter sub2; + int at, n; + uint8_t *k; + + if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) + break; + + assert(at == DBUS_TYPE_ARRAY); + + if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) + goto fail; + + dbus_message_iter_recurse(&sub, &sub2); + dbus_message_iter_get_fixed_array(&sub2, &k, &n); + strlst = avahi_string_list_add_arbitrary(strlst, k, n); + + dbus_message_iter_next(&sub); + } + + *l = strlst; + + return 0; + +fail: + avahi_log_warn("Error parsing TXT data"); + + avahi_string_list_free(strlst); + *l = NULL; + return -1; +} + + static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) { DBusError error; EntryGroupInfo *i = userdata; @@ -643,7 +774,7 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, dbus_error_init(&error); - avahi_log_debug("dbus: interface=%s, path=%s, member=%s", + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); @@ -685,25 +816,17 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, } avahi_s_entry_group_reset(i->entry_group); + i->n_entries = 0; return respond_ok(c, m); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty")) { - DBusMessage *reply; - int b; - + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing EntryGroup::IsEmpty message"); goto fail; } - b = !!avahi_s_entry_group_is_empty(i->entry_group); - - reply = dbus_message_new_method_return(m); - dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); - - return DBUS_HANDLER_RESULT_HANDLED; + return respond_boolean(c, m, !!avahi_s_entry_group_is_empty(i->entry_group)); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) { AvahiEntryGroupState state; @@ -718,86 +841,121 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) { int32_t interface, protocol; + uint32_t flags; char *type, *name, *domain, *host; uint16_t port; - AvahiStringList *strlst; - DBusMessageIter iter, sub; - int j; + AvahiStringList *strlst = NULL; if (!dbus_message_get_args( m, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_STRING, &host, DBUS_TYPE_UINT16, &port, - DBUS_TYPE_INVALID) || !type || !name) { + DBUS_TYPE_INVALID) || + !type || !name || + read_strlst(m, 8, &strlst) < 0) { avahi_log_warn("Error parsing EntryGroup::AddService message"); goto fail; } - dbus_message_iter_init(m, &iter); - - for (j = 0; j < 7; j++) - 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_ARRAY) { - avahi_log_warn("Error parsing EntryGroup::AddService message 2"); - goto fail; + if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) { + avahi_string_list_free(strlst); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL); } - strlst = NULL; - dbus_message_iter_recurse(&iter, &sub); - - for (;;) { - DBusMessageIter sub2; - int at, n; - uint8_t *k; + if (domain && !*domain) + domain = NULL; - if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) - break; + if (host && !*host) + host = NULL; - assert(at == DBUS_TYPE_ARRAY); - - if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) { - avahi_log_warn("Error parsing EntryGroup::AddService message"); - goto fail; - } + if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, host, port, strlst) < 0) { + avahi_string_list_free(strlst); + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } - dbus_message_iter_recurse(&sub, &sub2); - dbus_message_iter_get_fixed_array(&sub2, &k, &n); - strlst = avahi_string_list_add_arbitrary(strlst, k, n); + if (!(flags & AVAHI_PUBLISH_UPDATE)) + i->n_entries ++; - dbus_message_iter_next(&sub); + avahi_string_list_free(strlst); + + return respond_ok(c, m); + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype")) { + + int32_t interface, protocol; + uint32_t flags; + char *type, *name, *domain, *subtype; + + if (!dbus_message_get_args( + m, &error, + DBUS_TYPE_INT32, &interface, + DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_STRING, &subtype, + DBUS_TYPE_INVALID) || !type || !name || !subtype) { + avahi_log_warn("Error parsing EntryGroup::AddServiceSubtype message"); + goto fail; } - if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) { - avahi_string_list_free(strlst); - avahi_log_warn("Too many entries per entry group, client request failed."); + if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL); - } if (domain && !*domain) domain = NULL; - if (host && !*host) - host = NULL; - - if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, host, port, strlst) < 0) { - avahi_string_list_free(strlst); + if (avahi_server_add_service_subtype(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, subtype) < 0) return respond_error(c, m, avahi_server_errno(avahi_server), NULL); - } else + + if (!(flags & AVAHI_PUBLISH_UPDATE)) i->n_entries ++; + return respond_ok(c, m); + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt")) { + int32_t interface, protocol; + uint32_t flags; + char *type, *name, *domain; + AvahiStringList *strlst; + + if (!dbus_message_get_args( + m, &error, + DBUS_TYPE_INT32, &interface, + DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_INVALID) || + !type || !name || + read_strlst(m, 6, &strlst)) { + avahi_log_warn("Error parsing EntryGroup::UpdateServiceTxt message"); + goto fail; + } + + if (domain && !*domain) + domain = NULL; + + if (avahi_server_update_service_txt_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, strlst) < 0) { + avahi_string_list_free(strlst); + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + avahi_string_list_free(strlst); return respond_ok(c, m); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) { int32_t interface, protocol; + uint32_t flags; char *name, *address; AvahiAddress a; @@ -805,6 +963,7 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, m, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID) || !name || !address) { @@ -812,22 +971,20 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, goto fail; } - if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) { - avahi_log_warn("Too many entries per entry group, client request failed."); + if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL); - } - if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) { + if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL); - } - if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, 0, name, &a) < 0) + if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, &a) < 0) return respond_error(c, m, avahi_server_errno(avahi_server), NULL); - else + + if (!(flags & AVAHI_PUBLISH_UPDATE)) i->n_entries ++; return respond_ok(c, m); - } + } avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); @@ -838,7 +995,7 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, void* userdata) { +static void sync_host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, AvahiLookupResultFlags flags, void* userdata) { SyncHostNameResolverInfo *i = userdata; assert(r); @@ -846,8 +1003,9 @@ static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex assert(i); if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; DBusMessage *reply; assert(a); @@ -855,7 +1013,8 @@ static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; - i_aprotocol = (int32_t) a->family; + i_aprotocol = (int32_t) a->proto; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -865,20 +1024,20 @@ static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex DBUS_TYPE_STRING, &host_name, DBUS_TYPE_INT32, &i_aprotocol, DBUS_TYPE_STRING, &pt, + DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID); dbus_connection_send(server->bus, reply, NULL); dbus_message_unref(reply); } else { - assert(event == AVAHI_RESOLVER_TIMEOUT); - - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); + assert(event == AVAHI_RESOLVER_FAILURE); + respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL); } sync_host_name_resolver_free(i); } -static void address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, void* userdata) { +static void sync_address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, AvahiLookupResultFlags flags, void* userdata) { SyncAddressResolverInfo *i = userdata; assert(r); @@ -886,8 +1045,9 @@ static void address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex int assert(i); if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; DBusMessage *reply; assert(host_name); @@ -895,7 +1055,8 @@ static void address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex int i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; - i_aprotocol = (int32_t) address->family; + i_aprotocol = (int32_t) address->proto; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -905,13 +1066,14 @@ static void address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex int DBUS_TYPE_INT32, &i_aprotocol, DBUS_TYPE_STRING, &pt, DBUS_TYPE_STRING, &host_name, + DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID); dbus_connection_send(server->bus, reply, NULL); dbus_message_unref(reply); } else { - assert(event == AVAHI_RESOLVER_TIMEOUT); - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); + assert(event == AVAHI_RESOLVER_FAILURE); + respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL); } sync_address_resolver_free(i); @@ -927,7 +1089,7 @@ static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage dbus_error_init(&error); - avahi_log_debug("dbus: interface=%s, path=%s, member=%s", + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); @@ -961,25 +1123,33 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *domain, void* userdata) { +static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *domain, AvahiLookupResultFlags flags, void* userdata) { DomainBrowserInfo *i = userdata; DBusMessage *m; int32_t i_interface, i_protocol; + uint32_t u_flags; assert(b); - assert(domain); assert(i); i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; + u_flags = (uint32_t) flags; - m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove"); - dbus_message_append_args( - m, - DBUS_TYPE_INT32, &i_interface, - DBUS_TYPE_INT32, &i_protocol, - DBUS_TYPE_STRING, &domain, - DBUS_TYPE_INVALID); + m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, map_browse_signal_name(event)); + + if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) { + assert(domain); + dbus_message_append_args( + m, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + } else if (event == AVAHI_BROWSER_FAILURE) + append_server_error(m); + dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); @@ -995,7 +1165,7 @@ static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMe dbus_error_init(&error); - avahi_log_debug("dbus: interface=%s, path=%s, member=%s", + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); @@ -1029,27 +1199,35 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void service_type_browser_callback(AvahiSServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *type, const char *domain, void* userdata) { +static void service_type_browser_callback(AvahiSServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) { ServiceTypeBrowserInfo *i = userdata; DBusMessage *m; int32_t i_interface, i_protocol; + uint32_t u_flags; assert(b); - assert(type); - assert(domain); assert(i); i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; + u_flags = (uint32_t) flags; - m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove"); - dbus_message_append_args( - m, - DBUS_TYPE_INT32, &i_interface, - DBUS_TYPE_INT32, &i_protocol, - DBUS_TYPE_STRING, &type, - DBUS_TYPE_STRING, &domain, - DBUS_TYPE_INVALID); + m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, map_browse_signal_name(event)); + + if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) { + assert(type); + assert(domain); + dbus_message_append_args( + m, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + } else if (event == AVAHI_BROWSER_FAILURE) + append_server_error(m); + dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); @@ -1065,7 +1243,7 @@ static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage dbus_error_init(&error); - avahi_log_debug("dbus: interface=%s, path=%s, member=%s", + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); @@ -1099,35 +1277,87 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void service_browser_callback(AvahiSServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, void* userdata) { +static int is_our_own_service(Client *c, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain) { + AvahiSEntryGroup *g; + + + if (avahi_server_get_group_of_service(avahi_server, interface, protocol, name, type, domain, &g) == AVAHI_OK) { + EntryGroupInfo *egi; + + for (egi = c->entry_groups; egi; egi = egi->entry_groups_next) + if (egi->entry_group == g) + return 1; + } + + return 0; +} + +static void service_browser_callback(AvahiSServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) { ServiceBrowserInfo *i = userdata; DBusMessage *m; int32_t i_interface, i_protocol; + uint32_t u_flags; assert(b); - assert(name); - assert(type); - assert(domain); assert(i); i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; + u_flags = (uint32_t) flags; - m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove"); - dbus_message_append_args( - m, - DBUS_TYPE_INT32, &i_interface, - DBUS_TYPE_INT32, &i_protocol, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_STRING, &type, - DBUS_TYPE_STRING, &domain, - DBUS_TYPE_INVALID); + m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, map_browse_signal_name(event)); + + if (event == AVAHI_BROWSER_NEW) { + /* Patch in AVAHI_LOOKUP_RESULT_OUR_OWN */ + + if (is_our_own_service(i->client, interface, protocol, name, type, domain) > 0) + flags |= AVAHI_LOOKUP_RESULT_OUR_OWN; + } + + if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) { + assert(name); + assert(type); + assert(domain); + + dbus_message_append_args( + m, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + } else if (event == AVAHI_BROWSER_FAILURE) + append_server_error(m); + dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); } -static void service_resolver_callback( +static void append_string_list(DBusMessage *reply, AvahiStringList *txt) { + AvahiStringList *p; + DBusMessageIter iter, sub; + + assert(reply); + + dbus_message_iter_init_append(reply, &iter); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub); + + for (p = txt; p; p = p->next) { + DBusMessageIter sub2; + const uint8_t *data = p->text; + + dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2); + dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size); + dbus_message_iter_close_container(&sub, &sub2); + + } + dbus_message_iter_close_container(&iter, &sub); +} + +static void sync_service_resolver_callback( AvahiSServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, @@ -1139,6 +1369,7 @@ static void service_resolver_callback( const AvahiAddress *a, uint16_t port, AvahiStringList *txt, + AvahiLookupResultFlags flags, void* userdata) { SyncServiceResolverInfo *i = userdata; @@ -1147,21 +1378,33 @@ static void service_resolver_callback( assert(i); if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; int32_t i_interface, i_protocol, i_aprotocol; - unsigned n, j; - AvahiStringList *p; + uint32_t u_flags; DBusMessage *reply; - DBusMessageIter iter, sub; - + assert(host_name); - - assert(a); - avahi_address_snprint(t, sizeof(t), a); + if (!name) + name = ""; + + if (a) + avahi_address_snprint(t, sizeof(t), a); + else + t[0] = 0; + + /* Patch in AVAHI_LOOKUP_RESULT_OUR_OWN */ + + if (is_our_own_service(i->client, interface, protocol, name, type, domain) > 0) + flags |= AVAHI_LOOKUP_RESULT_OUR_OWN; + i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; - i_aprotocol = (int32_t) a->family; + if (a) + i_aprotocol = (int32_t) a->proto; + else + i_aprotocol = AVAHI_PROTO_UNSPEC; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -1177,47 +1420,335 @@ static void service_resolver_callback( DBUS_TYPE_UINT16, &port, DBUS_TYPE_INVALID); - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub); - - for (p = txt, j = n-1; p; p = p->next, j--) { - DBusMessageIter sub2; - const uint8_t *data = p->text; - - dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2); - dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size); - dbus_message_iter_close_container(&sub, &sub2); - - } - dbus_message_iter_close_container(&iter, &sub); + append_string_list(reply, txt); + dbus_message_append_args( + reply, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + dbus_connection_send(server->bus, reply, NULL); dbus_message_unref(reply); } else { - assert(event == AVAHI_RESOLVER_TIMEOUT); - - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); + assert(event == AVAHI_RESOLVER_FAILURE); + + respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL); } sync_service_resolver_free(i); } -static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) { +static void async_address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, AvahiLookupResultFlags flags, void* userdata) { + AsyncAddressResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(i); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, map_resolve_signal_name(event)); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; + + assert(address); + assert(host_name); + avahi_address_snprint(t, sizeof(t), address); + + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) address->proto; + u_flags = (uint32_t) flags; + + dbus_message_append_args( + reply, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_INT32, &i_aprotocol, + DBUS_TYPE_STRING, &pt, + DBUS_TYPE_STRING, &host_name, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + + } else { + assert(event == AVAHI_RESOLVER_FAILURE); + append_server_error(reply); + } + + dbus_message_set_destination(reply, i->client->name); + dbus_connection_send(server->bus, reply, NULL); + dbus_message_unref(reply); +} + +static DBusHandlerResult msg_async_address_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) { DBusError error; + AsyncAddressResolverInfo *i = userdata; + assert(c); + assert(m); + assert(i); + dbus_error_init(&error); - avahi_log_debug("dbus: interface=%s, path=%s, member=%s", + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); + /* Introspection */ if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) - return handle_introspect(c, m, "Server.introspect"); - - else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { + return handle_introspect(c, m, "AddressResolver.Introspect"); + + /* Access control */ + if (strcmp(dbus_message_get_sender(m), i->client->name)) + return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL); + + if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Free")) { + + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { + avahi_log_warn("Error parsing AddressResolver::Free message"); + goto fail; + } + + async_address_resolver_free(i); + return respond_ok(c, m); + + } + + avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + +fail: + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static void async_host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, AvahiLookupResultFlags flags, void* userdata) { + AsyncHostNameResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(i); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, map_resolve_signal_name(event)); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; + + assert(a); + assert(host_name); + avahi_address_snprint(t, sizeof(t), a); + + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) a->proto; + u_flags = (uint32_t) flags; + + dbus_message_append_args( + reply, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_STRING, &host_name, + DBUS_TYPE_INT32, &i_aprotocol, + DBUS_TYPE_STRING, &pt, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + } else { + assert(event == AVAHI_RESOLVER_FAILURE); + append_server_error(reply); + } + + dbus_message_set_destination(reply, i->client->name); + dbus_connection_send(server->bus, reply, NULL); + dbus_message_unref(reply); +} + +static DBusHandlerResult msg_async_host_name_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) { + DBusError error; + AsyncHostNameResolverInfo *i = userdata; + + assert(c); + assert(m); + assert(i); + + dbus_error_init(&error); + + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", + dbus_message_get_interface(m), + dbus_message_get_path(m), + dbus_message_get_member(m)); + + /* Introspection */ + if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + return handle_introspect(c, m, "HostNameResolver.Introspect"); + + /* Access control */ + if (strcmp(dbus_message_get_sender(m), i->client->name)) + return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL); + + if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Free")) { + + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { + avahi_log_warn("Error parsing HostNameResolver::Free message"); + goto fail; + } + + async_host_name_resolver_free(i); + return respond_ok(c, m); + } + + avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + +fail: + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static void async_service_resolver_callback( + AvahiSServiceResolver *r, + AvahiIfIndex interface, + AvahiProtocol protocol, + AvahiResolverEvent event, + const char *name, + const char *type, + const char *domain, + const char *host_name, + const AvahiAddress *a, + uint16_t port, + AvahiStringList *txt, + AvahiLookupResultFlags flags, + void* userdata) { + + AsyncServiceResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(i); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, map_resolve_signal_name(event)); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[AVAHI_ADDRESS_STR_MAX], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; + + assert(host_name); + +/* avahi_log_debug(__FILE__": [%s] Successfully resolved service <%s.%s.%s>", i->path, name, type, domain); */ + + if (a) + avahi_address_snprint(t, sizeof(t), a); + else + t[0] = 0; + + if (!name) + name = ""; + + if (is_our_own_service(i->client, interface, protocol, name, type, domain) > 0) + flags |= AVAHI_LOOKUP_RESULT_OUR_OWN; + + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + if (a) + i_aprotocol = (int32_t) a->proto; + else + i_aprotocol = AVAHI_PROTO_UNSPEC; + u_flags = (uint32_t) flags; + + dbus_message_append_args( + reply, + DBUS_TYPE_INT32, &i_interface, + DBUS_TYPE_INT32, &i_protocol, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_STRING, &host_name, + DBUS_TYPE_INT32, &i_aprotocol, + DBUS_TYPE_STRING, &pt, + DBUS_TYPE_UINT16, &port, + DBUS_TYPE_INVALID); + + append_string_list(reply, txt); + + dbus_message_append_args( + reply, + DBUS_TYPE_UINT32, &u_flags, + DBUS_TYPE_INVALID); + } else { + assert(event == AVAHI_RESOLVER_FAILURE); + append_server_error(reply); + } + + dbus_message_set_destination(reply, i->client->name); + dbus_connection_send(server->bus, reply, NULL); + dbus_message_unref(reply); +} + +static DBusHandlerResult msg_async_service_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) { + DBusError error; + AsyncServiceResolverInfo *i = userdata; + + assert(c); + assert(m); + assert(i); + + dbus_error_init(&error); + + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", + dbus_message_get_interface(m), + dbus_message_get_path(m), + dbus_message_get_member(m)); + + /* Introspection */ + if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + return handle_introspect(c, m, "ServiceResolver.Introspect"); + + /* Access control */ + if (strcmp(dbus_message_get_sender(m), i->client->name)) + return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL); + + if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Free")) { + + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { + avahi_log_warn("Error parsing ServiceResolver::Free message"); + goto fail; + } + + async_service_resolver_free(i); + return respond_ok(c, m); + } + + avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + +fail: + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) { + DBusError error; + + dbus_error_init(&error); + + avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", + dbus_message_get_interface(m), + dbus_message_get_path(m), + dbus_message_get_member(m)); + + if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + return handle_introspect(c, m, "Server.introspect"); + + else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) { + + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing Server::GetHostName message"); goto fail; } @@ -1262,10 +1793,20 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void state = avahi_server_get_state(avahi_server); return respond_int32(c, m, (int32_t) state); + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie")) { + + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetLocalServiceCookie message"); + goto fail; + } + + return respond_uint32(c, m, avahi_server_get_local_service_cookie(avahi_server)); + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) { int32_t idx; int fd; - struct ifreq ifr; + char name[IF_NAMESIZE]; + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &idx, DBUS_TYPE_INVALID))) { avahi_log_warn("Error parsing Server::GetNetworkInterfaceNameByIndex message"); @@ -1276,16 +1817,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void return respond_string(c, m, "blah"); #else - if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { - char txt[256]; - snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); - return respond_error(c, m, AVAHI_ERR_OS, txt); - } - - memset(&ifr, 0, sizeof(ifr)); - ifr.ifr_ifindex = idx; + if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) + if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) { + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + return respond_error(c, m, AVAHI_ERR_OS, txt); + } - if (ioctl(fd, SIOCGIFNAME, &ifr) < 0) { + if ((!if_indextoname(idx, name))) { char txt[256]; snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); close(fd); @@ -1294,13 +1833,13 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void close(fd); - return respond_string(c, m, ifr.ifr_name); + return respond_string(c, m, name); #endif } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) { char *n; int fd; - struct ifreq ifr; + int32_t idx; if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) { avahi_log_warn("Error parsing Server::GetNetworkInterfaceIndexByName message"); @@ -1310,16 +1849,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void #ifdef VALGRIND_WORKAROUND return respond_int32(c, m, 1); #else - if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { - char txt[256]; - snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); - return respond_error(c, m, AVAHI_ERR_OS, txt); - } - - memset(&ifr, 0, sizeof(ifr)); - snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", n); + if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) + if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) { + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + return respond_error(c, m, AVAHI_ERR_OS, txt); + } - if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) { + if (!(idx = if_nametoindex(n))) { char txt[256]; snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); close(fd); @@ -1328,7 +1865,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void close(fd); - return respond_int32(c, m, ifr.ifr_ifindex); + return respond_int32(c, m, idx); #endif } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeHostName")) { @@ -1405,6 +1942,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) { Client *client; int32_t interface, protocol, aprotocol; + uint32_t flags; char *name; SyncHostNameResolverInfo *i; @@ -1414,6 +1952,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_INT32, &aprotocol, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || !name) { avahi_log_warn("Error parsing Server::ResolveHostName message"); goto fail; @@ -1435,7 +1974,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(SyncHostNameResolverInfo, sync_host_name_resolvers, client->sync_host_name_resolvers, i); client->n_objects++; - if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, host_name_resolver_callback, i))) { + if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, sync_host_name_resolver_callback, i))) { sync_host_name_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1445,6 +1984,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveAddress")) { Client *client; int32_t interface, protocol; + uint32_t flags; char *address; SyncAddressResolverInfo *i; AvahiAddress a; @@ -1454,6 +1994,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &address, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || !address) { avahi_log_warn("Error parsing Server::ResolveAddress message"); goto fail; @@ -1478,7 +2019,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(SyncAddressResolverInfo, sync_address_resolvers, client->sync_address_resolvers, i); client->n_objects++; - if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i))) { + if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, sync_address_resolver_callback, i))) { sync_address_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1497,15 +2038,16 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void NULL }; int32_t interface, protocol, type; + uint32_t flags; char *domain; - if (!dbus_message_get_args( m, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &type, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || type < 0 || type >= AVAHI_DOMAIN_BROWSER_MAX) { avahi_log_warn("Error parsing Server::DomainBrowserNew message"); goto fail; @@ -1531,7 +2073,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(DomainBrowserInfo, domain_browsers, client->domain_browsers, i); client->n_objects++; - if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, domain_browser_callback, i))) { + if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, (AvahiLookupFlags) flags, domain_browser_callback, i))) { domain_browser_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1551,6 +2093,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void NULL }; int32_t interface, protocol; + uint32_t flags; char *domain; if (!dbus_message_get_args( @@ -1558,6 +2101,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing Server::ServiceTypeBrowserNew message"); goto fail; @@ -1584,7 +2128,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(ServiceTypeBrowserInfo, service_type_browsers, client->service_type_browsers, i); client->n_objects++; - if (!(i->service_type_browser = avahi_s_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, service_type_browser_callback, i))) { + if (!(i->service_type_browser = avahi_s_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiLookupFlags) flags, service_type_browser_callback, i))) { service_type_browser_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1592,7 +2136,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void dbus_connection_register_object_path(c, i->path, &vtable, i); return respond_path(c, m, i->path); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew")) { + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew")) { Client *client; ServiceBrowserInfo *i; static const DBusObjectPathVTable vtable = { @@ -1604,6 +2148,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void NULL }; int32_t interface, protocol; + uint32_t flags; char *domain, *type; if (!dbus_message_get_args( @@ -1612,6 +2157,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, + DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || !type) { avahi_log_warn("Error parsing Server::ServiceBrowserNew message"); goto fail; @@ -1638,7 +2184,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(ServiceBrowserInfo, service_browsers, client->service_browsers, i); client->n_objects++; - if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, service_browser_callback, i))) { + if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, (AvahiLookupFlags) flags, service_browser_callback, i))) { service_browser_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1649,6 +2195,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveService")) { Client *client; int32_t interface, protocol, aprotocol; + uint32_t flags; char *name, *type, *domain; SyncServiceResolverInfo *i; @@ -1660,7 +2207,8 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &aprotocol, - DBUS_TYPE_INVALID) || !name || !type) { + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !type) { avahi_log_warn("Error parsing Server::ResolveService message"); goto fail; } @@ -1677,6 +2225,9 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void if (!*domain) domain = NULL; + + if (!*name) + name = NULL; i = avahi_new(SyncServiceResolverInfo, 1); i->client = client; @@ -1684,13 +2235,182 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void AVAHI_LLIST_PREPEND(SyncServiceResolverInfo, sync_service_resolvers, client->sync_service_resolvers, i); client->n_objects++; - if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, service_resolver_callback, i))) { + if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, sync_service_resolver_callback, i))) { sync_service_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } return DBUS_HANDLER_RESULT_HANDLED; - } + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceResolverNew")) { + Client *client; + int32_t interface, protocol, aprotocol; + uint32_t flags; + char *name, *type, *domain; + AsyncServiceResolverInfo *i; + static const DBusObjectPathVTable vtable = { + NULL, + msg_async_service_resolver_impl, + NULL, + NULL, + NULL, + NULL + }; + + if (!dbus_message_get_args( + m, &error, + DBUS_TYPE_INT32, &interface, + DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_INT32, &aprotocol, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !type) { + avahi_log_warn("Error parsing Server::ServiceResolverNew message"); + goto fail; + } + + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn(__FILE__": Too many clients, client request failed."); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } + + if (!*domain) + domain = NULL; + + if (!*name) + name = NULL; + + i = avahi_new(AsyncServiceResolverInfo, 1); + i->id = ++client->current_id; + i->client = client; + i->path = avahi_strdup_printf("/Client%u/ServiceResolver%u", client->id, i->id); + AVAHI_LLIST_PREPEND(AsyncServiceResolverInfo, async_service_resolvers, client->async_service_resolvers, i); + client->n_objects++; + + if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, async_service_resolver_callback, i))) { + async_service_resolver_free(i); + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + +/* avahi_log_debug(__FILE__": [%s], new service resolver for <%s.%s.%s>", i->path, name, type, domain); */ + + dbus_connection_register_object_path(c, i->path, &vtable, i); + return respond_path(c, m, i->path); + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "HostNameResolverNew")) { + Client *client; + int32_t interface, protocol, aprotocol; + uint32_t flags; + char *name; + AsyncHostNameResolverInfo *i; + static const DBusObjectPathVTable vtable = { + NULL, + msg_async_host_name_resolver_impl, + NULL, + NULL, + NULL, + NULL + }; + + if (!dbus_message_get_args( + m, &error, + DBUS_TYPE_INT32, &interface, + DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INT32, &aprotocol, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !name) { + avahi_log_warn("Error parsing Server::HostNameResolverNew message"); + goto fail; + } + + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn(__FILE__": Too many clients, client request failed."); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } + + i = avahi_new(AsyncHostNameResolverInfo, 1); + i->id = ++client->current_id; + i->client = client; + i->path = avahi_strdup_printf("/Client%u/HostNameResolver%u", client->id, i->id); + AVAHI_LLIST_PREPEND(AsyncHostNameResolverInfo, async_host_name_resolvers, client->async_host_name_resolvers, i); + client->n_objects++; + + if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, aprotocol, (AvahiLookupFlags) flags, async_host_name_resolver_callback, i))) { + async_host_name_resolver_free(i); + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + + dbus_connection_register_object_path(c, i->path, &vtable, i); + return respond_path(c, m, i->path); + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "AddressResolverNew")) { + Client *client; + int32_t interface, protocol; + uint32_t flags; + char *address; + AsyncAddressResolverInfo *i; + AvahiAddress a; + static const DBusObjectPathVTable vtable = { + NULL, + msg_async_address_resolver_impl, + NULL, + NULL, + NULL, + NULL + }; + + if (!dbus_message_get_args( + m, &error, + DBUS_TYPE_INT32, &interface, + DBUS_TYPE_INT32, &protocol, + DBUS_TYPE_STRING, &address, + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !address) { + avahi_log_warn("Error parsing Server::AddressResolverNew message"); + goto fail; + } + + if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)) + return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL); + + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn(__FILE__": Too many clients, client request failed."); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } + + i = avahi_new(AsyncAddressResolverInfo, 1); + i->id = ++client->current_id; + i->client = client; + i->path = avahi_strdup_printf("/Client%u/AddressResolver%u", client->id, i->id); + AVAHI_LLIST_PREPEND(AsyncAddressResolverInfo, async_address_resolvers, client->async_address_resolvers, i); + client->n_objects++; + + if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, async_address_resolver_callback, i))) { + async_address_resolver_free(i); + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + + dbus_connection_register_object_path(c, i->path, &vtable, i); + return respond_path(c, m, i->path); + } avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); @@ -1704,12 +2424,21 @@ fail: void dbus_protocol_server_state_changed(AvahiServerState state) { DBusMessage *m; int32_t t; + const char *e; if (!server) return; m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged"); t = (int32_t) state; + + if (state == AVAHI_SERVER_COLLISION) + e = AVAHI_DBUS_ERR_COLLISION; + else if (state == AVAHI_SERVER_FAILURE) + e = avahi_error_number_to_dbus(avahi_server_errno(avahi_server)); + else + e = AVAHI_DBUS_ERR_OK; + dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m);