X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-daemon%2Fdbus-protocol.c;h=517b95413223c42e27d0a3bc3c9ee3c7e9da889e;hb=fd25072a95549aff47d5abafd712fb14de55e172;hp=626e4a066ad2fafa48a11d50a85e889db466e789;hpb=f68a3a04e407e5bae5fffb703de8d4b981e4de53;p=catta diff --git a/avahi-daemon/dbus-protocol.c b/avahi-daemon/dbus-protocol.c index 626e4a0..517b954 100644 --- a/avahi-daemon/dbus-protocol.c +++ b/avahi-daemon/dbus-protocol.c @@ -23,227 +23,96 @@ #include #endif -#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -#define DBUS_API_SUBJECT_TO_CHANGE #include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include + #include #include -#include +#include +#include #include "dbus-protocol.h" +#include "dbus-util.h" +#include "dbus-internal.h" #include "main.h" -/* Include generated introspection data */ -#include "server-introspect-xml.c" - -typedef struct Server Server; -typedef struct Client Client; -typedef struct EntryGroupInfo EntryGroupInfo; -typedef struct HostNameResolverInfo HostNameResolverInfo; -typedef struct AddressResolverInfo AddressResolverInfo; -typedef struct DomainBrowserInfo DomainBrowserInfo; -typedef struct ServiceTypeBrowserInfo ServiceTypeBrowserInfo; -typedef struct ServiceBrowserInfo ServiceBrowserInfo; -typedef struct ServiceResolverInfo ServiceResolverInfo; - -struct EntryGroupInfo { - guint id; - Client *client; - AvahiEntryGroup *entry_group; - gchar *path; - - AVAHI_LLIST_FIELDS(EntryGroupInfo, entry_groups); -}; - -struct HostNameResolverInfo { - Client *client; - AvahiHostNameResolver *host_name_resolver; - DBusMessage *message; - - AVAHI_LLIST_FIELDS(HostNameResolverInfo, host_name_resolvers); -}; - -struct AddressResolverInfo { - Client *client; - AvahiAddressResolver *address_resolver; - DBusMessage *message; - - AVAHI_LLIST_FIELDS(AddressResolverInfo, address_resolvers); -}; - -struct DomainBrowserInfo { - guint id; - Client *client; - AvahiDomainBrowser *domain_browser; - gchar *path; - - AVAHI_LLIST_FIELDS(DomainBrowserInfo, domain_browsers); -}; +/* #define VALGRIND_WORKAROUND 1 */ -struct ServiceTypeBrowserInfo { - guint id; - Client *client; - AvahiServiceTypeBrowser *service_type_browser; - gchar *path; - - AVAHI_LLIST_FIELDS(ServiceTypeBrowserInfo, service_type_browsers); -}; - -struct ServiceBrowserInfo { - guint id; - Client *client; - AvahiServiceBrowser *service_browser; - gchar *path; - - AVAHI_LLIST_FIELDS(ServiceBrowserInfo, service_browsers); -}; - -struct ServiceResolverInfo { - Client *client; - AvahiServiceResolver *service_resolver; - DBusMessage *message; - - AVAHI_LLIST_FIELDS(ServiceResolverInfo, service_resolvers); -}; - -struct Client { - guint id; - gchar *name; - guint current_id; - - AVAHI_LLIST_FIELDS(Client, clients); - AVAHI_LLIST_HEAD(EntryGroupInfo, entry_groups); - AVAHI_LLIST_HEAD(HostNameResolverInfo, host_name_resolvers); - AVAHI_LLIST_HEAD(AddressResolverInfo, address_resolvers); - AVAHI_LLIST_HEAD(DomainBrowserInfo, domain_browsers); - AVAHI_LLIST_HEAD(ServiceTypeBrowserInfo, service_type_browsers); - AVAHI_LLIST_HEAD(ServiceBrowserInfo, service_browsers); - AVAHI_LLIST_HEAD(ServiceResolverInfo, service_resolvers); -}; - -struct Server { - DBusConnection *bus; - AVAHI_LLIST_HEAD(Client, clients); - guint current_id; -}; - -static Server *server = NULL; - -static void entry_group_free(EntryGroupInfo *i) { - g_assert(i); - - if (i->entry_group) - avahi_entry_group_free(i->entry_group); - dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); - AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i); - g_free(i); - } - -static void host_name_resolver_free(HostNameResolverInfo *i) { - g_assert(i); - - if (i->host_name_resolver) - avahi_host_name_resolver_free(i->host_name_resolver); - dbus_message_unref(i->message); - AVAHI_LLIST_REMOVE(HostNameResolverInfo, host_name_resolvers, i->client->host_name_resolvers, i); - g_free(i); -} - -static void address_resolver_free(AddressResolverInfo *i) { - g_assert(i); - - if (i->address_resolver) - avahi_address_resolver_free(i->address_resolver); - dbus_message_unref(i->message); - AVAHI_LLIST_REMOVE(AddressResolverInfo, address_resolvers, i->client->address_resolvers, i); - g_free(i); -} - -static void domain_browser_free(DomainBrowserInfo *i) { - g_assert(i); - - if (i->domain_browser) - avahi_domain_browser_free(i->domain_browser); - dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); - AVAHI_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i); - g_free(i); -} - -static void service_type_browser_free(ServiceTypeBrowserInfo *i) { - g_assert(i); - - if (i->service_type_browser) - avahi_service_type_browser_free(i->service_type_browser); - dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); - AVAHI_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i); - g_free(i); -} - -static void service_browser_free(ServiceBrowserInfo *i) { - g_assert(i); - - if (i->service_browser) - avahi_service_browser_free(i->service_browser); - dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); - AVAHI_LLIST_REMOVE(ServiceBrowserInfo, service_browsers, i->client->service_browsers, i); - g_free(i); -} - -static void service_resolver_free(ServiceResolverInfo *i) { - g_assert(i); - - if (i->service_resolver) - avahi_service_resolver_free(i->service_resolver); - dbus_message_unref(i->message); - AVAHI_LLIST_REMOVE(ServiceResolverInfo, service_resolvers, i->client->service_resolvers, i); - g_free(i); -} +Server *server = NULL; static void client_free(Client *c) { - g_assert(server); - g_assert(c); + assert(server); + assert(c); while (c->entry_groups) - entry_group_free(c->entry_groups); + avahi_dbus_entry_group_free(c->entry_groups); + + while (c->sync_host_name_resolvers) + avahi_dbus_sync_host_name_resolver_free(c->sync_host_name_resolvers); - while (c->host_name_resolvers) - host_name_resolver_free(c->host_name_resolvers); + while (c->async_host_name_resolvers) + avahi_dbus_async_host_name_resolver_free(c->async_host_name_resolvers); + + while (c->sync_address_resolvers) + avahi_dbus_sync_address_resolver_free(c->sync_address_resolvers); - while (c->address_resolvers) - address_resolver_free(c->address_resolvers); + while (c->async_address_resolvers) + avahi_dbus_async_address_resolver_free(c->async_address_resolvers); while (c->domain_browsers) - domain_browser_free(c->domain_browsers); + avahi_dbus_domain_browser_free(c->domain_browsers); while (c->service_type_browsers) - service_type_browser_free(c->service_type_browsers); + avahi_dbus_service_type_browser_free(c->service_type_browsers); while (c->service_browsers) - service_browser_free(c->service_browsers); + avahi_dbus_service_browser_free(c->service_browsers); - while (c->service_resolvers) - service_resolver_free(c->service_resolvers); + while (c->sync_service_resolvers) + avahi_dbus_sync_service_resolver_free(c->sync_service_resolvers); - g_free(c->name); + while (c->async_service_resolvers) + avahi_dbus_async_service_resolver_free(c->async_service_resolvers); + + assert(c->n_objects == 0); + + avahi_free(c->name); AVAHI_LLIST_REMOVE(Client, clients, server->clients, c); - g_free(c); + avahi_free(c); + + server->n_clients --; + assert(server->n_clients >= 0); } -static Client *client_get(const gchar *name, gboolean create) { +static Client *client_get(const char *name, int create) { Client *client; - g_assert(server); - g_assert(name); + assert(server); + assert(name); for (client = server->clients; client; client = client->clients_next) if (!strcmp(name, client->name)) @@ -252,72 +121,42 @@ static Client *client_get(const gchar *name, gboolean create) { if (!create) return NULL; + if (server->n_clients >= CLIENTS_MAX) + return NULL; + /* If not existant yet, create a new entry */ - client = g_new(Client, 1); + client = avahi_new(Client, 1); client->id = server->current_id++; - client->name = g_strdup(name); + client->name = avahi_strdup(name); client->current_id = 0; + client->n_objects = 0; + AVAHI_LLIST_HEAD_INIT(EntryGroupInfo, client->entry_groups); - AVAHI_LLIST_HEAD_INIT(HostNameResolverInfo, client->host_name_resolvers); - AVAHI_LLIST_HEAD_INIT(AddressResolverInfo, client->address_resolvers); + 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(ServiceResolverInfo, client->service_resolvers); + 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); - return client; -} - -static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, const gchar *error, const gchar *text) { - DBusMessage *reply; - - reply = dbus_message_new_error(m, error, text); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); - - return DBUS_HANDLER_RESULT_HANDLED; -} - -static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const gchar *text) { - DBusMessage *reply; - - reply = dbus_message_new_method_return(m); - dbus_message_append_args(reply, DBUS_TYPE_STRING, &text, 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; - - reply = dbus_message_new_method_return(m); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); + server->n_clients++; + assert(server->n_clients > 0); - return DBUS_HANDLER_RESULT_HANDLED; + return client; } -static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const gchar *path) { - DBusMessage *reply; - reply = dbus_message_new_method_return(m); - dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); - - return DBUS_HANDLER_RESULT_HANDLED; -} - -static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - GMainLoop *loop = userdata; +static DBusHandlerResult msg_signal_filter_impl(AVAHI_GCC_UNUSED DBusConnection *c, DBusMessage *m, AVAHI_GCC_UNUSED void *userdata) { DBusError error; 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)); */ @@ -325,23 +164,25 @@ 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..."); - g_main_loop_quit (loop); + avahi_log_warn("Disconnnected from D-BUS, terminating..."); + + raise(SIGQUIT); /* The signal handler will catch this and terminate the process cleanly*/ + return DBUS_HANDLER_RESULT_HANDLED; } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameAcquired")) { - gchar *name; + char *name; if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing NameAcquired message"); 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")) { - gchar *name, *old, *new; + char *name, *old, *new; if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing NameOwnerChanged message"); @@ -352,7 +193,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); } } @@ -365,605 +206,166 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } - -static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) { - EntryGroupInfo *i = userdata; - DBusMessage *m; - gint32 t; - - g_assert(s); - g_assert(g); - g_assert(i); - - m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged"); - t = (gint32) state; - dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID); - dbus_message_set_destination(m, i->client->name); - dbus_connection_send(server->bus, m, NULL); - dbus_message_unref(m); -} - -static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) { +static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, AVAHI_GCC_UNUSED void *userdata) { DBusError error; - EntryGroupInfo *i = userdata; - g_assert(c); - g_assert(m); - g_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)); - /* Access control */ - if (strcmp(dbus_message_get_sender(m), i->client->name)) - return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL); - - if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing EntryGroup::Free message"); - goto fail; - } - - entry_group_free(i); - return respond_ok(c, m); + if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + return avahi_dbus_handle_introspect(c, m, "Server.introspect"); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit")) { + 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 EntryGroup::Commit message"); + avahi_log_warn("Error parsing Server::GetHostName message"); goto fail; } - avahi_entry_group_commit(i->entry_group); - return respond_ok(c, m); + return avahi_dbus_respond_string(c, m, avahi_server_get_host_name(avahi_server)); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) { - DBusMessage *reply; - gint32 t; + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) { if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing EntryGroup::GetState message"); - goto fail; - } - - t = (gint32) avahi_entry_group_get_state(i->entry_group); - reply = dbus_message_new_method_return(m); - dbus_message_append_args(reply, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); - - return DBUS_HANDLER_RESULT_HANDLED; - - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) { - gint32 interface, protocol; - gchar *type, *name, *domain, *host; - guint16 port; - gchar **txt = NULL; - gint txt_len; - AvahiStringList *strlst; - - 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_STRING, &host, - DBUS_TYPE_UINT16, &port, - DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &txt, &txt_len, - DBUS_TYPE_INVALID) || !type || !*type || !name || !*name || !port) { - avahi_log_warn("Error parsing EntryGroup::AddService message"); + avahi_log_warn("Error parsing Server::GetDomainName message"); goto fail; } - strlst = avahi_string_list_new_from_array((const gchar**) txt, txt_len); - dbus_free_string_array(txt); + return avahi_dbus_respond_string(c, m, avahi_server_get_domain_name(avahi_server)); - if (domain && !*domain) - domain = NULL; - - if (host && !*host) - host = NULL; + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) { - if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, host, port, strlst) < 0) { - avahi_log_warn("Failed to add service: %s", name); - return respond_error(c, m, "org.freedesktop.Avahi.InvalidServiceError", NULL); - } /* else */ -/* avahi_log_info("Successfully added service: %s", name); */ - - return respond_ok(c, m); - - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) { - gint32 interface, protocol; - gchar *name, *address; - AvahiAddress a; - - if (!dbus_message_get_args( - m, &error, - DBUS_TYPE_INT32, &interface, - DBUS_TYPE_INT32, &protocol, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_STRING, &address, - DBUS_TYPE_INVALID) || !name || !*name || !address || !*address) { - avahi_log_warn("Error parsing EntryGroup::AddAddress message"); + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetHostNameFqdn message"); goto fail; } - - if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) { - avahi_log_warn("Error parsing address data"); - return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL); - } - - if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, 0, name, &a) < 0) { - avahi_log_warn("Failed to add service: %s", name); - return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL); - }/* else */ -/* avahi_log_info("Successfully added address: %s -> %s", name, address); */ - - 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 host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata) { - HostNameResolverInfo *i = userdata; - DBusMessage *reply; - - g_assert(r); - g_assert(host_name); - g_assert(i); - - if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; - - g_assert(a); - avahi_address_snprint(t, sizeof(t), a); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) a->family; - - reply = dbus_message_new_method_return(i->message); - 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 { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); - reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL); - } - - dbus_connection_send(server->bus, reply, NULL); - dbus_message_unref(reply); - - host_name_resolver_free(i); -} - -static void address_resolver_callback(AvahiAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const gchar *host_name, gpointer userdata) { - AddressResolverInfo *i = userdata; - DBusMessage *reply; - - g_assert(r); - g_assert(address); - g_assert(i); - - if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; - - g_assert(host_name); - avahi_address_snprint(t, sizeof(t), address); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) address->family; + return avahi_dbus_respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server)); - reply = dbus_message_new_method_return(i->message); - 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 { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); - reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL); - } - - dbus_connection_send(server->bus, reply, NULL); - dbus_message_unref(reply); - - address_resolver_free(i); -} - -static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - DBusError error; - DomainBrowserInfo *i = userdata; - - g_assert(c); - g_assert(m); - g_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)); - - /* Access control */ - if (strcmp(dbus_message_get_sender(m), i->client->name)) - return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL); - - if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free")) { + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) { - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing DomainBrowser::Free message"); + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetVersionString message"); goto fail; } - - domain_browser_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 domain_browser_callback(AvahiDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata) { - DomainBrowserInfo *i = userdata; - DBusMessage *m; - gint32 i_interface, i_protocol; - g_assert(b); - g_assert(domain); - g_assert(i); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - - 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); - dbus_message_set_destination(m, i->client->name); - dbus_connection_send(server->bus, m, NULL); - dbus_message_unref(m); -} - -static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - DBusError error; - ServiceTypeBrowserInfo *i = userdata; + return avahi_dbus_respond_string(c, m, PACKAGE_STRING); - g_assert(c); - g_assert(m); - g_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)); - - /* Access control */ - if (strcmp(dbus_message_get_sender(m), i->client->name)) - return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL); - - if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing ServiceTypeBrowser::Free message"); + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetState")) { + AvahiServerState state; + + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetState message"); goto fail; } - - service_type_browser_free(i); - return respond_ok(c, m); - } - - avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + state = avahi_server_get_state(avahi_server); + return avahi_dbus_respond_int32(c, m, (int32_t) state); -fail: - if (dbus_error_is_set(&error)) - dbus_error_free(&error); - - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; -} - -static void service_type_browser_callback(AvahiServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *type, const gchar *domain, gpointer userdata) { - ServiceTypeBrowserInfo *i = userdata; - DBusMessage *m; - gint32 i_interface, i_protocol; - - g_assert(b); - g_assert(type); - g_assert(domain); - g_assert(i); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - - 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); - dbus_message_set_destination(m, i->client->name); - dbus_connection_send(server->bus, m, NULL); - dbus_message_unref(m); -} - -static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - DBusError error; - ServiceBrowserInfo *i = userdata; - - g_assert(c); - g_assert(m); - g_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)); + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie")) { - /* Access control */ - if (strcmp(dbus_message_get_sender(m), i->client->name)) - return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL); - - if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing ServiceBrowser::Free message"); + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetLocalServiceCookie message"); goto fail; } - - service_browser_free(i); - return respond_ok(c, m); - } - - avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + return avahi_dbus_respond_uint32(c, m, avahi_server_get_local_service_cookie(avahi_server)); -fail: - if (dbus_error_is_set(&error)) - dbus_error_free(&error); - - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; -} - -static void service_browser_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata) { - ServiceBrowserInfo *i = userdata; - DBusMessage *m; - gint32 i_interface, i_protocol; - - g_assert(b); - g_assert(name); - g_assert(type); - g_assert(domain); - g_assert(i); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - - 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); - dbus_message_set_destination(m, i->client->name); - dbus_connection_send(server->bus, m, NULL); - dbus_message_unref(m); -} - -static void service_resolver_callback( - AvahiServiceResolver *r, - AvahiIfIndex interface, - AvahiProtocol protocol, - AvahiResolverEvent event, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host_name, - const AvahiAddress *a, - guint16 port, - AvahiStringList *txt, - gpointer userdata) { - - ServiceResolverInfo *i = userdata; - DBusMessage *reply; - - g_assert(r); - g_assert(host_name); - g_assert(i); - - if (event == AVAHI_RESOLVER_FOUND) { - char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; - gchar **array; - guint n, j; - AvahiStringList *p; - - g_assert(a); - avahi_address_snprint(t, sizeof(t), a); - - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) a->family; + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) { + int32_t idx; + int fd; + char name[IF_NAMESIZE]; - array = g_new(gchar*, (n = avahi_string_list_length(txt))); - - /** FIXME: DBUS doesn't support strings that include NUL bytes (?) */ - for (p = txt, j = n-1; p; p = p->next, j--) - array[j] = g_strndup((gchar*) p->text, p->size); - reply = dbus_message_new_method_return(i->message); - 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_ARRAY, DBUS_TYPE_STRING, &array, n, - DBUS_TYPE_INVALID); - - for (j = 0; j < n; j++) - g_free(array[j]); - - } else { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); - reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL); - } - - dbus_connection_send(server->bus, reply, NULL); - dbus_message_unref(reply); - - service_resolver_free(i); -} - -static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - DBusError error; - - 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)); - - if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing Introspect message"); + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &idx, DBUS_TYPE_INVALID))) { + avahi_log_warn("Error parsing Server::GetNetworkInterfaceNameByIndex message"); goto fail; } - return respond_string(c, m, server_introspect_xml); +#ifdef VALGRIND_WORKAROUND + return respond_string(c, m, "blah"); +#else - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) { + 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 avahi_dbus_respond_error(c, m, AVAHI_ERR_OS, txt); + } - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing Server::GetHostName message"); - goto fail; + if ((!if_indextoname(idx, name))) { + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + close(fd); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_OS, txt); } - return respond_string(c, m, avahi_server_get_host_name(avahi_server)); + close(fd); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) { - - if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing Server::GetDomainName message"); - goto fail; - } - - return respond_string(c, m, avahi_server_get_domain_name(avahi_server)); - - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) { - - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { - avahi_log_warn("Error parsing Server::GetHostNameFqdn message"); - goto fail; - } - - return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server)); + return avahi_dbus_respond_string(c, m, name); +#endif - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) { - - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { - avahi_log_warn("Error parsing Server::GetVersionString message"); + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) { + char *n; + int fd; + 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"); goto fail; } - - return respond_string(c, m, PACKAGE_STRING); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetState")) { - DBusMessage *reply; - gint32 s; - - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { - avahi_log_warn("Error parsing Server::GetState message"); - goto fail; +#ifdef VALGRIND_WORKAROUND + return respond_int32(c, m, 1); +#else + 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 avahi_dbus_respond_error(c, m, AVAHI_ERR_OS, txt); + } + + if (!(idx = if_nametoindex(n))) { + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + close(fd); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_OS, txt); } - s = (gint32) avahi_server_get_state(avahi_server); - - reply = dbus_message_new_method_return(m); - dbus_message_append_args(reply, DBUS_TYPE_INT32, &s, DBUS_TYPE_INVALID); - dbus_connection_send(c, reply, NULL); - dbus_message_unref(reply); + close(fd); - return DBUS_HANDLER_RESULT_HANDLED; + return avahi_dbus_respond_int32(c, m, idx); +#endif } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeHostName")) { - gchar *n, * t; + char *n, * t; - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n || !*n) { + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) { avahi_log_warn("Error parsing Server::GetAlternativeHostName message"); goto fail; } t = avahi_alternative_host_name(n); - respond_string(c, m, t); - g_free(t); + avahi_dbus_respond_string(c, m, t); + avahi_free(t); return DBUS_HANDLER_RESULT_HANDLED; } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeServiceName")) { - gchar *n, *t; + char *n, *t; - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n || !*n) { + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) { avahi_log_warn("Error parsing Server::GetAlternativeServiceName message"); goto fail; } t = avahi_alternative_service_name(n); - respond_string(c, m, t); - g_free(t); + avahi_dbus_respond_string(c, m, t); + avahi_free(t); return DBUS_HANDLER_RESULT_HANDLED; @@ -972,7 +374,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void EntryGroupInfo *i; static const DBusObjectPathVTable vtable = { NULL, - msg_entry_group_impl, + avahi_dbus_msg_entry_group_impl, NULL, NULL, NULL, @@ -984,28 +386,38 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void goto fail; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } - i = g_new(EntryGroupInfo, 1); + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } + + i = avahi_new(EntryGroupInfo, 1); i->id = ++client->current_id; i->client = client; - i->path = g_strdup_printf("/Client%u/EntryGroup%u", client->id, i->id); + i->path = avahi_strdup_printf("/Client%u/EntryGroup%u", client->id, i->id); + i->n_entries = 0; AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i); - - if (!(i->entry_group = avahi_entry_group_new(avahi_server, entry_group_callback, i))) { - avahi_log_warn("Failed to create entry group"); - entry_group_free(i); - goto fail; + client->n_objects++; + + if (!(i->entry_group = avahi_s_entry_group_new(avahi_server, avahi_dbus_entry_group_callback, i))) { + avahi_dbus_entry_group_free(i); + return avahi_dbus_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); + return avahi_dbus_respond_path(c, m, i->path); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) { Client *client; - gint32 interface, protocol, aprotocol; - gchar *name; - HostNameResolverInfo *i; + int32_t interface, protocol, aprotocol; + uint32_t flags; + char *name; + SyncHostNameResolverInfo *i; if (!dbus_message_get_args( m, &error, @@ -1013,31 +425,41 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_INT32, &aprotocol, - DBUS_TYPE_INVALID) || !name || !*name) { + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !name) { avahi_log_warn("Error parsing Server::ResolveHostName message"); goto fail; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } - i = g_new(HostNameResolverInfo, 1); + i = avahi_new(SyncHostNameResolverInfo, 1); i->client = client; i->message = dbus_message_ref(m); - AVAHI_LLIST_PREPEND(HostNameResolverInfo, host_name_resolvers, client->host_name_resolvers, i); + AVAHI_LLIST_PREPEND(SyncHostNameResolverInfo, sync_host_name_resolvers, client->sync_host_name_resolvers, i); + client->n_objects++; - if (!(i->host_name_resolver = avahi_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, host_name_resolver_callback, i))) { - host_name_resolver_free(i); - avahi_log_warn("Failed to create host name resolver"); - goto fail; + if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, avahi_dbus_sync_host_name_resolver_callback, i))) { + avahi_dbus_sync_host_name_resolver_free(i); + return avahi_dbus_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, "ResolveAddress")) { Client *client; - gint32 interface, protocol; - gchar *address; - AddressResolverInfo *i; + int32_t interface, protocol; + uint32_t flags; + char *address; + SyncAddressResolverInfo *i; AvahiAddress a; if (!dbus_message_get_args( @@ -1045,28 +467,34 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &address, - DBUS_TYPE_INVALID) || !address || !*address) { + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !address) { avahi_log_warn("Error parsing Server::ResolveAddress message"); goto fail; } - if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)) { - avahi_log_warn("Error parsing address data"); - return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL); + if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)) + return avahi_dbus_respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL); + + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); } - - client = client_get(dbus_message_get_sender(m), TRUE); - i = g_new(AddressResolverInfo, 1); + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } + + i = avahi_new(SyncAddressResolverInfo, 1); i->client = client; i->message = dbus_message_ref(m); + AVAHI_LLIST_PREPEND(SyncAddressResolverInfo, sync_address_resolvers, client->sync_address_resolvers, i); + client->n_objects++; - AVAHI_LLIST_PREPEND(AddressResolverInfo, address_resolvers, client->address_resolvers, i); - - if (!(i->address_resolver = avahi_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i))) { - address_resolver_free(i); - avahi_log_warn("Failed to create address resolver"); - goto fail; + if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, avahi_dbus_sync_address_resolver_callback, i))) { + avahi_dbus_sync_address_resolver_free(i); + return avahi_dbus_respond_error(c, m, avahi_server_errno(avahi_server), NULL); } return DBUS_HANDLER_RESULT_HANDLED; @@ -1076,106 +504,125 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DomainBrowserInfo *i; static const DBusObjectPathVTable vtable = { NULL, - msg_domain_browser_impl, + avahi_dbus_msg_domain_browser_impl, NULL, NULL, NULL, NULL }; - gint32 interface, protocol, type; - gchar *domain; + 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; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } if (!*domain) domain = NULL; - i = g_new(DomainBrowserInfo, 1); + i = avahi_new(DomainBrowserInfo, 1); i->id = ++client->current_id; i->client = client; - i->path = g_strdup_printf("/Client%u/DomainBrowser%u", client->id, i->id); - + i->path = avahi_strdup_printf("/Client%u/DomainBrowser%u", client->id, i->id); AVAHI_LLIST_PREPEND(DomainBrowserInfo, domain_browsers, client->domain_browsers, i); + client->n_objects++; - if (!(i->domain_browser = avahi_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, domain_browser_callback, i))) { - avahi_log_warn("Failed to create domain browser"); - domain_browser_free(i); - goto fail; + if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, (AvahiLookupFlags) flags, avahi_dbus_domain_browser_callback, i))) { + avahi_dbus_domain_browser_free(i); + return avahi_dbus_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); + return avahi_dbus_respond_path(c, m, i->path); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew")) { Client *client; ServiceTypeBrowserInfo *i; static const DBusObjectPathVTable vtable = { NULL, - msg_service_type_browser_impl, + avahi_dbus_msg_service_type_browser_impl, NULL, NULL, NULL, NULL }; - gint32 interface, protocol; - gchar *domain; + int32_t interface, protocol; + 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_UINT32, &flags, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing Server::ServiceTypeBrowserNew message"); goto fail; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } if (!*domain) domain = NULL; - i = g_new(ServiceTypeBrowserInfo, 1); + i = avahi_new(ServiceTypeBrowserInfo, 1); i->id = ++client->current_id; i->client = client; - i->path = g_strdup_printf("/Client%u/ServiceTypeBrowser%u", client->id, i->id); - + i->path = avahi_strdup_printf("/Client%u/ServiceTypeBrowser%u", client->id, i->id); AVAHI_LLIST_PREPEND(ServiceTypeBrowserInfo, service_type_browsers, client->service_type_browsers, i); + client->n_objects++; - if (!(i->service_type_browser = avahi_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, service_type_browser_callback, i))) { - avahi_log_warn("Failed to create service type browser"); - service_type_browser_free(i); - goto fail; + if (!(i->service_type_browser = avahi_s_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiLookupFlags) flags, avahi_dbus_service_type_browser_callback, i))) { + avahi_dbus_service_type_browser_free(i); + return avahi_dbus_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); + return avahi_dbus_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 = { NULL, - msg_service_browser_impl, + avahi_dbus_msg_service_browser_impl, NULL, NULL, NULL, NULL }; - gint32 interface, protocol; - gchar *domain, *type; + int32_t interface, protocol; + uint32_t flags; + char *domain, *type; if (!dbus_message_get_args( m, &error, @@ -1183,37 +630,47 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, - DBUS_TYPE_INVALID) || !type || !*type) { + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !type) { avahi_log_warn("Error parsing Server::ServiceBrowserNew message"); goto fail; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } if (!*domain) domain = NULL; - i = g_new(ServiceBrowserInfo, 1); + i = avahi_new(ServiceBrowserInfo, 1); i->id = ++client->current_id; i->client = client; - i->path = g_strdup_printf("/Client%u/ServiceBrowser%u", client->id, i->id); - + i->path = avahi_strdup_printf("/Client%u/ServiceBrowser%u", client->id, i->id); AVAHI_LLIST_PREPEND(ServiceBrowserInfo, service_browsers, client->service_browsers, i); + client->n_objects++; - if (!(i->service_browser = avahi_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, service_browser_callback, i))) { - avahi_log_warn("Failed to create service browser"); - service_browser_free(i); - goto fail; + if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, (AvahiLookupFlags) flags, avahi_dbus_service_browser_callback, i))) { + avahi_dbus_service_browser_free(i); + return avahi_dbus_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); + return avahi_dbus_respond_path(c, m, i->path); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveService")) { Client *client; - gint32 interface, protocol, aprotocol; - gchar *name, *type, *domain; - ServiceResolverInfo *i; + int32_t interface, protocol, aprotocol; + uint32_t flags; + char *name, *type, *domain; + SyncServiceResolverInfo *i; if (!dbus_message_get_args( m, &error, @@ -1223,32 +680,212 @@ 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 || !*name || !type || !*type) { + DBUS_TYPE_UINT32, &flags, + DBUS_TYPE_INVALID) || !type) { avahi_log_warn("Error parsing Server::ResolveService message"); goto fail; } - client = client_get(dbus_message_get_sender(m), TRUE); + if (!(client = client_get(dbus_message_get_sender(m), TRUE))) { + avahi_log_warn("Too many clients, client request failed."); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn("Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); + } if (!*domain) domain = NULL; + + if (!*name) + name = NULL; - i = g_new(ServiceResolverInfo, 1); + i = avahi_new(SyncServiceResolverInfo, 1); i->client = client; i->message = dbus_message_ref(m); - AVAHI_LLIST_PREPEND(ServiceResolverInfo, service_resolvers, client->service_resolvers, i); + AVAHI_LLIST_PREPEND(SyncServiceResolverInfo, sync_service_resolvers, client->sync_service_resolvers, i); + client->n_objects++; - if (!(i->service_resolver = avahi_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, service_resolver_callback, i))) { - service_resolver_free(i); - avahi_log_warn("Failed to create service resolver"); - goto fail; + if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, avahi_dbus_sync_service_resolver_callback, i))) { + avahi_dbus_sync_service_resolver_free(i); + return avahi_dbus_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, + avahi_dbus_msg_async_service_resolver_impl, + NULL, + NULL, + NULL, + NULL + }; - avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); + 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 avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_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, avahi_dbus_async_service_resolver_callback, i))) { + avahi_dbus_async_service_resolver_free(i); + return avahi_dbus_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 avahi_dbus_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, + avahi_dbus_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 avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_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, avahi_dbus_async_host_name_resolver_callback, i))) { + avahi_dbus_async_host_name_resolver_free(i); + return avahi_dbus_respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + + dbus_connection_register_object_path(c, i->path, &vtable, i); + return avahi_dbus_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, + avahi_dbus_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 avahi_dbus_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 avahi_dbus_respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL); + } + + if (client->n_objects >= OBJECTS_PER_CLIENT_MAX) { + avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name); + return avahi_dbus_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, avahi_dbus_async_address_resolver_callback, i))) { + avahi_dbus_async_address_resolver_free(i); + return avahi_dbus_respond_error(c, m, avahi_server_errno(avahi_server), NULL); + } + + dbus_connection_register_object_path(c, i->path, &vtable, i); + return avahi_dbus_respond_path(c, m, i->path); + } + + avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); fail: if (dbus_error_is_set(&error)) @@ -1259,19 +896,28 @@ fail: void dbus_protocol_server_state_changed(AvahiServerState state) { DBusMessage *m; - gint32 t; + int32_t t; + const char *e; if (!server) return; m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged"); - t = (gint32) state; - dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID); + 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_STRING, &e, DBUS_TYPE_INVALID); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); } -int dbus_protocol_setup(GMainLoop *loop) { +int dbus_protocol_setup(const AvahiPoll *poll_api) { DBusError error; static const DBusObjectPathVTable server_vtable = { @@ -1285,29 +931,48 @@ int dbus_protocol_setup(GMainLoop *loop) { dbus_error_init(&error); - server = g_malloc(sizeof(Server)); - server->clients = NULL; + server = avahi_new(Server, 1); + AVAHI_LLIST_HEAD_INIT(Clients, server->clients); server->current_id = 0; + server->n_clients = 0; - server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error); - if (dbus_error_is_set(&error)) { - avahi_log_warn("dbus_bus_get(): %s", error.message); + if (!(server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) { + assert(dbus_error_is_set(&error)); + avahi_log_error("dbus_bus_get(): %s", error.message); goto fail; } - dbus_connection_setup_with_g_main(server->bus, NULL); - dbus_connection_set_exit_on_disconnect(server->bus, FALSE); + if (avahi_dbus_connection_glue(server->bus, poll_api) < 0) { + avahi_log_error("avahi_dbus_connection_glue() failed"); + goto fail; + } - dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, 0, &error); - if (dbus_error_is_set(&error)) { - avahi_log_warn("dbus_bus_request_name(): %s", error.message); + if (dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT, &error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { + if (dbus_error_is_set(&error)) { + avahi_log_error("dbus_bus_request_name(): %s", error.message); + goto fail; + } + + avahi_log_error("Failed to acquire DBUS name '"AVAHI_DBUS_NAME"'"); goto fail; } + if (!(dbus_connection_add_filter(server->bus, msg_signal_filter_impl, (void*) poll_api, NULL))) { + avahi_log_error("dbus_connection_add_filter() failed"); + goto fail; + } + dbus_bus_add_match(server->bus, "type='signal',""interface='" DBUS_INTERFACE_DBUS "'", &error); - dbus_connection_add_filter(server->bus, msg_signal_filter_impl, loop, NULL); - dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL); + if (dbus_error_is_set(&error)) { + avahi_log_error("dbus_bus_add_match(): %s", error.message); + goto fail; + } + + if (!(dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL))) { + avahi_log_error("dbus_connection_register_object_path() failed"); + goto fail; + } return 0; @@ -1316,9 +981,11 @@ fail: dbus_connection_disconnect(server->bus); dbus_connection_unref(server->bus); } - - dbus_error_free (&error); - g_free(server); + + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + avahi_free(server); server = NULL; return -1; } @@ -1330,12 +997,14 @@ void dbus_protocol_shutdown(void) { while (server->clients) client_free(server->clients); + assert(server->n_clients == 0); + if (server->bus) { dbus_connection_disconnect(server->bus); dbus_connection_unref(server->bus); } - g_free(server); + avahi_free(server); server = NULL; } }