X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-daemon%2Fdbus-protocol.c;h=8a0bd55cf9a449df8119afc45d8e4ecb7b2474a2;hb=3b4fb60db453050f539370d75a73cba89e06e3ad;hp=c2dd5cc5f56a62795df7e5841ea98694328040fb;hpb=d2dd8d0d225fd8e4cfc67c8125a38ed22f17ddd3;p=catta diff --git a/avahi-daemon/dbus-protocol.c b/avahi-daemon/dbus-protocol.c index c2dd5cc..8a0bd55 100644 --- a/avahi-daemon/dbus-protocol.c +++ b/avahi-daemon/dbus-protocol.c @@ -198,9 +198,9 @@ static void entry_group_free(EntryGroupInfo *i) { assert(i->client->n_objects >= 0); avahi_free(i); - } +} -static void host_name_resolver_free(SyncHostNameResolverInfo *i) { +static void sync_host_name_resolver_free(SyncHostNameResolverInfo *i) { assert(i); if (i->host_name_resolver) @@ -214,7 +214,21 @@ static void host_name_resolver_free(SyncHostNameResolverInfo *i) { avahi_free(i); } -static void address_resolver_free(SyncAddressResolverInfo *i) { +static void async_host_name_resolver_free(AsyncHostNameResolverInfo *i) { + assert(i); + + if (i->host_name_resolver) + avahi_s_host_name_resolver_free(i->host_name_resolver); + dbus_connection_unregister_object_path(server->bus, i->path); + AVAHI_LLIST_REMOVE(AsyncHostNameResolverInfo, async_host_name_resolvers, i->client->async_host_name_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + avahi_free(i); +} + +static void sync_address_resolver_free(SyncAddressResolverInfo *i) { assert(i); if (i->address_resolver) @@ -228,6 +242,20 @@ static void address_resolver_free(SyncAddressResolverInfo *i) { avahi_free(i); } +static void async_address_resolver_free(AsyncAddressResolverInfo *i) { + assert(i); + + if (i->address_resolver) + avahi_s_address_resolver_free(i->address_resolver); + dbus_connection_unregister_object_path(server->bus, i->path); + AVAHI_LLIST_REMOVE(AsyncAddressResolverInfo, async_address_resolvers, i->client->async_address_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + avahi_free(i); +} + static void domain_browser_free(DomainBrowserInfo *i) { assert(i); @@ -273,7 +301,7 @@ static void service_browser_free(ServiceBrowserInfo *i) { avahi_free(i); } -static void service_resolver_free(SyncServiceResolverInfo *i) { +static void sync_service_resolver_free(SyncServiceResolverInfo *i) { assert(i); if (i->service_resolver) @@ -287,6 +315,21 @@ static void service_resolver_free(SyncServiceResolverInfo *i) { avahi_free(i); } +static void async_service_resolver_free(AsyncServiceResolverInfo *i) { + assert(i); + + if (i->service_resolver) + avahi_s_service_resolver_free(i->service_resolver); + + dbus_connection_unregister_object_path(server->bus, i->path); + AVAHI_LLIST_REMOVE(AsyncServiceResolverInfo, async_service_resolvers, i->client->async_service_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + avahi_free(i); +} + static void client_free(Client *c) { assert(server); @@ -296,10 +339,16 @@ static void client_free(Client *c) { entry_group_free(c->entry_groups); while (c->sync_host_name_resolvers) - host_name_resolver_free(c->sync_host_name_resolvers); + sync_host_name_resolver_free(c->sync_host_name_resolvers); + while (c->async_host_name_resolvers) + async_host_name_resolver_free(c->async_host_name_resolvers); + while (c->sync_address_resolvers) - address_resolver_free(c->sync_address_resolvers); + sync_address_resolver_free(c->sync_address_resolvers); + + while (c->async_address_resolvers) + async_address_resolver_free(c->async_address_resolvers); while (c->domain_browsers) domain_browser_free(c->domain_browsers); @@ -311,7 +360,10 @@ static void client_free(Client *c) { service_browser_free(c->service_browsers); while (c->sync_service_resolvers) - service_resolver_free(c->sync_service_resolvers); + sync_service_resolver_free(c->sync_service_resolvers); + + while (c->async_service_resolvers) + async_service_resolver_free(c->async_service_resolvers); assert(c->n_objects == 0); @@ -348,11 +400,14 @@ static Client *client_get(const char *name, int create) { AVAHI_LLIST_HEAD_INIT(EntryGroupInfo, client->entry_groups); AVAHI_LLIST_HEAD_INIT(SyncHostNameResolverInfo, client->sync_host_name_resolvers); + AVAHI_LLIST_HEAD_INIT(AsyncHostNameResolverInfo, client->async_host_name_resolvers); AVAHI_LLIST_HEAD_INIT(SyncAddressResolverInfo, client->sync_address_resolvers); + AVAHI_LLIST_HEAD_INIT(AsyncAddressResolverInfo, client->async_address_resolvers); AVAHI_LLIST_HEAD_INIT(DomainBrowserInfo, client->domain_browsers); AVAHI_LLIST_HEAD_INIT(ServiceTypeBrowserInfo, client->service_type_browsers); AVAHI_LLIST_HEAD_INIT(ServiceBrowserInfo, client->service_browsers); AVAHI_LLIST_HEAD_INIT(SyncServiceResolverInfo, client->sync_service_resolvers); + AVAHI_LLIST_HEAD_INIT(AsyncServiceResolverInfo, client->async_service_resolvers); AVAHI_LLIST_PREPEND(Client, clients, server->clients, client); @@ -783,7 +838,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, void* userdata) { SyncHostNameResolverInfo *i = userdata; assert(r); @@ -820,10 +875,10 @@ static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); } - host_name_resolver_free(i); + 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, void* userdata) { SyncAddressResolverInfo *i = userdata; assert(r); @@ -859,7 +914,7 @@ static void address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex int respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); } - address_resolver_free(i); + sync_address_resolver_free(i); } static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) { @@ -1072,7 +1127,28 @@ static void service_browser_callback(AvahiSServiceBrowser *b, AvahiIfIndex inter 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, @@ -1094,11 +1170,8 @@ static void service_resolver_callback( if (event == AVAHI_RESOLVER_FOUND) { char t[256], *pt = t; int32_t i_interface, i_protocol, i_aprotocol; - unsigned n, j; - AvahiStringList *p; DBusMessage *reply; - DBusMessageIter iter, sub; - + assert(host_name); assert(a); @@ -1122,19 +1195,7 @@ 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_connection_send(server->bus, reply, NULL); dbus_message_unref(reply); @@ -1144,7 +1205,274 @@ static void service_resolver_callback( respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); } - service_resolver_free(i); + sync_service_resolver_free(i); +} + +static void async_address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, void* userdata) { + AsyncAddressResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(address); + assert(i); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[256], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + + 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->family; + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Found"); + 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_INVALID); + + } else { + assert(event == AVAHI_RESOLVER_TIMEOUT); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Timeout"); + } + + 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", + 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, "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, void* userdata) { + AsyncHostNameResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(host_name); + assert(i); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[256], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + + assert(a); + avahi_address_snprint(t, sizeof(t), a); + + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) a->family; + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Found"); + 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_INVALID); + } else { + assert(event == AVAHI_RESOLVER_TIMEOUT); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Timeout"); + } + + 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("dbus: 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, + void* userdata) { + + AsyncServiceResolverInfo *i = userdata; + DBusMessage *reply; + + assert(r); + assert(host_name); + assert(i); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[256], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + + assert(host_name); + + assert(a); + avahi_address_snprint(t, sizeof(t), a); + + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) a->family; + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Found"); + 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); + + } else { + assert(event == AVAHI_RESOLVER_TIMEOUT); + + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Timeout"); + } + + 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("dbus: 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) { @@ -1380,8 +1708,8 @@ 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))) { - host_name_resolver_free(i); + if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, sync_host_name_resolver_callback, i))) { + sync_host_name_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1423,8 +1751,8 @@ 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))) { - address_resolver_free(i); + if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, sync_address_resolver_callback, i))) { + sync_address_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1444,7 +1772,6 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void int32_t interface, protocol, type; char *domain; - if (!dbus_message_get_args( m, &error, DBUS_TYPE_INT32, &interface, @@ -1537,7 +1864,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 = { @@ -1629,13 +1956,168 @@ 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))) { - service_resolver_free(i); + if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, 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; + 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_INVALID) || !name || !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); + } + + 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, async_service_resolver_callback, i))) { + async_service_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, "HostNameResolverNew")) { + Client *client; + int32_t interface, protocol, aprotocol; + 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_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, 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; + 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_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, 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));