X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-daemon%2Fdbus-protocol.c;h=9270168a448e4125793a21654bb87dace657e340;hb=c1d9b9cffd6f756339c1d98a2d2914d49195cb41;hp=c30873eb9fca2cddd5b7af7ee4660662301bfec7;hpb=8b5cd6ffd9137b14b7ed678f10a551e3911e4a40;p=catta diff --git a/avahi-daemon/dbus-protocol.c b/avahi-daemon/dbus-protocol.c index c30873e..9270168 100644 --- a/avahi-daemon/dbus-protocol.c +++ b/avahi-daemon/dbus-protocol.c @@ -28,16 +28,27 @@ #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 "dbus-protocol.h" #include "main.h" @@ -45,221 +56,303 @@ typedef struct Server Server; typedef struct Client Client; typedef struct EntryGroupInfo EntryGroupInfo; -typedef struct HostNameResolverInfo HostNameResolverInfo; -typedef struct AddressResolverInfo AddressResolverInfo; +typedef struct SyncHostNameResolverInfo SyncHostNameResolverInfo; +typedef struct AsyncHostNameResolverInfo AsyncHostNameResolverInfo; +typedef struct SyncAddressResolverInfo SyncAddressResolverInfo; +typedef struct AsyncAddressResolverInfo AsyncAddressResolverInfo; typedef struct DomainBrowserInfo DomainBrowserInfo; typedef struct ServiceTypeBrowserInfo ServiceTypeBrowserInfo; typedef struct ServiceBrowserInfo ServiceBrowserInfo; -typedef struct ServiceResolverInfo ServiceResolverInfo; +typedef struct SyncServiceResolverInfo SyncServiceResolverInfo; +typedef struct AsyncServiceResolverInfo AsyncServiceResolverInfo; #define MAX_CLIENTS 20 #define MAX_OBJECTS_PER_CLIENT 50 #define MAX_ENTRIES_PER_ENTRY_GROUP 20 -/* #define VALGRIND_WORKAROUND */ +/* #define VALGRIND_WORKAROUND 1 */ struct EntryGroupInfo { - guint id; + unsigned id; Client *client; AvahiSEntryGroup *entry_group; - gchar *path; + char *path; - gint n_entries; + int n_entries; AVAHI_LLIST_FIELDS(EntryGroupInfo, entry_groups); }; -struct HostNameResolverInfo { +struct SyncHostNameResolverInfo { Client *client; AvahiSHostNameResolver *host_name_resolver; DBusMessage *message; - AVAHI_LLIST_FIELDS(HostNameResolverInfo, host_name_resolvers); + AVAHI_LLIST_FIELDS(SyncHostNameResolverInfo, sync_host_name_resolvers); +}; + +struct AsyncHostNameResolverInfo { + unsigned id; + Client *client; + AvahiSHostNameResolver *host_name_resolver; + char *path; + + AVAHI_LLIST_FIELDS(AsyncHostNameResolverInfo, async_host_name_resolvers); }; -struct AddressResolverInfo { +struct SyncAddressResolverInfo { Client *client; AvahiSAddressResolver *address_resolver; DBusMessage *message; - AVAHI_LLIST_FIELDS(AddressResolverInfo, address_resolvers); + AVAHI_LLIST_FIELDS(SyncAddressResolverInfo, sync_address_resolvers); +}; + +struct AsyncAddressResolverInfo { + unsigned id; + Client *client; + AvahiSAddressResolver *address_resolver; + char *path; + + AVAHI_LLIST_FIELDS(AsyncAddressResolverInfo, async_address_resolvers); }; struct DomainBrowserInfo { - guint id; + unsigned id; Client *client; AvahiSDomainBrowser *domain_browser; - gchar *path; + char *path; AVAHI_LLIST_FIELDS(DomainBrowserInfo, domain_browsers); }; struct ServiceTypeBrowserInfo { - guint id; + unsigned id; Client *client; AvahiSServiceTypeBrowser *service_type_browser; - gchar *path; + char *path; AVAHI_LLIST_FIELDS(ServiceTypeBrowserInfo, service_type_browsers); }; struct ServiceBrowserInfo { - guint id; + unsigned id; Client *client; AvahiSServiceBrowser *service_browser; - gchar *path; + char *path; AVAHI_LLIST_FIELDS(ServiceBrowserInfo, service_browsers); }; -struct ServiceResolverInfo { +struct SyncServiceResolverInfo { Client *client; AvahiSServiceResolver *service_resolver; DBusMessage *message; - AVAHI_LLIST_FIELDS(ServiceResolverInfo, service_resolvers); + AVAHI_LLIST_FIELDS(SyncServiceResolverInfo, sync_service_resolvers); +}; + +struct AsyncServiceResolverInfo { + unsigned id; + Client *client; + AvahiSServiceResolver *service_resolver; + char *path; + + AVAHI_LLIST_FIELDS(AsyncServiceResolverInfo, async_service_resolvers); }; struct Client { - guint id; - gchar *name; - guint current_id; - gint n_objects; + unsigned id; + char *name; + unsigned current_id; + int n_objects; 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(SyncHostNameResolverInfo, sync_host_name_resolvers); + AVAHI_LLIST_HEAD(AsyncHostNameResolverInfo, async_host_name_resolvers); + AVAHI_LLIST_HEAD(SyncAddressResolverInfo, sync_address_resolvers); + AVAHI_LLIST_HEAD(AsyncAddressResolverInfo, async_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); + AVAHI_LLIST_HEAD(SyncServiceResolverInfo, sync_service_resolvers); + AVAHI_LLIST_HEAD(AsyncServiceResolverInfo, async_service_resolvers); }; struct Server { DBusConnection *bus; AVAHI_LLIST_HEAD(Client, clients); - gint n_clients; - guint current_id; + int n_clients; + unsigned current_id; }; static Server *server = NULL; static void entry_group_free(EntryGroupInfo *i) { - g_assert(i); + assert(i); if (i->entry_group) avahi_s_entry_group_free(i->entry_group); dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); + avahi_free(i->path); AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i); i->client->n_objects--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); - } + avahi_free(i); +} -static void host_name_resolver_free(HostNameResolverInfo *i) { - g_assert(i); +static void sync_host_name_resolver_free(SyncHostNameResolverInfo *i) { + assert(i); if (i->host_name_resolver) avahi_s_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); + AVAHI_LLIST_REMOVE(SyncHostNameResolverInfo, sync_host_name_resolvers, i->client->sync_host_name_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + avahi_free(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--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } -static void address_resolver_free(AddressResolverInfo *i) { - g_assert(i); +static void sync_address_resolver_free(SyncAddressResolverInfo *i) { + assert(i); if (i->address_resolver) avahi_s_address_resolver_free(i->address_resolver); dbus_message_unref(i->message); - AVAHI_LLIST_REMOVE(AddressResolverInfo, address_resolvers, i->client->address_resolvers, i); + AVAHI_LLIST_REMOVE(SyncAddressResolverInfo, sync_address_resolvers, i->client->sync_address_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + 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--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } static void domain_browser_free(DomainBrowserInfo *i) { - g_assert(i); + assert(i); if (i->domain_browser) avahi_s_domain_browser_free(i->domain_browser); dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); + avahi_free(i->path); AVAHI_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i); i->client->n_objects--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } static void service_type_browser_free(ServiceTypeBrowserInfo *i) { - g_assert(i); + assert(i); if (i->service_type_browser) avahi_s_service_type_browser_free(i->service_type_browser); dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); + avahi_free(i->path); AVAHI_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i); i->client->n_objects--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } static void service_browser_free(ServiceBrowserInfo *i) { - g_assert(i); + assert(i); if (i->service_browser) avahi_s_service_browser_free(i->service_browser); dbus_connection_unregister_object_path(server->bus, i->path); - g_free(i->path); + avahi_free(i->path); AVAHI_LLIST_REMOVE(ServiceBrowserInfo, service_browsers, i->client->service_browsers, i); i->client->n_objects--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } -static void service_resolver_free(ServiceResolverInfo *i) { - g_assert(i); +static void sync_service_resolver_free(SyncServiceResolverInfo *i) { + assert(i); if (i->service_resolver) avahi_s_service_resolver_free(i->service_resolver); dbus_message_unref(i->message); - AVAHI_LLIST_REMOVE(ServiceResolverInfo, service_resolvers, i->client->service_resolvers, i); + AVAHI_LLIST_REMOVE(SyncServiceResolverInfo, sync_service_resolvers, i->client->sync_service_resolvers, i); + + i->client->n_objects--; + assert(i->client->n_objects >= 0); + + 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--; - g_assert(i->client->n_objects >= 0); + assert(i->client->n_objects >= 0); - g_free(i); + avahi_free(i); } 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); - while (c->host_name_resolvers) - host_name_resolver_free(c->host_name_resolvers); + while (c->sync_host_name_resolvers) + sync_host_name_resolver_free(c->sync_host_name_resolvers); - while (c->address_resolvers) - address_resolver_free(c->address_resolvers); + while (c->async_host_name_resolvers) + async_host_name_resolver_free(c->async_host_name_resolvers); + + while (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); @@ -270,24 +363,27 @@ static void client_free(Client *c) { while (c->service_browsers) service_browser_free(c->service_browsers); - while (c->service_resolvers) - service_resolver_free(c->service_resolvers); + while (c->sync_service_resolvers) + sync_service_resolver_free(c->sync_service_resolvers); - g_assert(c->n_objects == 0); + while (c->async_service_resolvers) + async_service_resolver_free(c->async_service_resolvers); + + assert(c->n_objects == 0); - g_free(c->name); + avahi_free(c->name); AVAHI_LLIST_REMOVE(Client, clients, server->clients, c); - g_free(c); + avahi_free(c); server->n_clients --; - g_assert(server->n_clients >= 0); + 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)) @@ -300,69 +396,50 @@ static Client *client_get(const gchar *name, gboolean create) { 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); server->n_clients++; - g_assert(server->n_clients > 0); + assert(server->n_clients > 0); return client; } -static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, gint error, const gchar *text) { +static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, int error, const char *text) { DBusMessage *reply; - const gchar * const table[- AVAHI_ERR_MAX] = { - NULL, /* OK */ - AVAHI_DBUS_ERR_FAILURE, - AVAHI_DBUS_ERR_BAD_STATE, - AVAHI_DBUS_ERR_INVALID_HOST_NAME, - AVAHI_DBUS_ERR_INVALID_DOMAIN_NAME, - AVAHI_DBUS_ERR_NO_NETWORK, - AVAHI_DBUS_ERR_INVALID_TTL, - AVAHI_DBUS_ERR_IS_PATTERN, - AVAHI_DBUS_ERR_LOCAL_COLLISION, - AVAHI_DBUS_ERR_INVALID_RECORD, - AVAHI_DBUS_ERR_INVALID_SERVICE_NAME, - AVAHI_DBUS_ERR_INVALID_SERVICE_TYPE, - AVAHI_DBUS_ERR_INVALID_PORT, - AVAHI_DBUS_ERR_INVALID_KEY, - AVAHI_DBUS_ERR_INVALID_ADDRESS, - AVAHI_DBUS_ERR_TIMEOUT, - AVAHI_DBUS_ERR_TOO_MANY_CLIENTS, - AVAHI_DBUS_ERR_TOO_MANY_OBJECTS, - AVAHI_DBUS_ERR_TOO_MANY_ENTRIES, - AVAHI_DBUS_ERR_OS, - AVAHI_DBUS_ERR_ACCESS_DENIED, - AVAHI_DBUS_ERR_INVALID_OPERATION, - AVAHI_DBUS_ERR_DBUS_ERROR, - AVAHI_DBUS_ERR_NOT_CONNECTED, - AVAHI_DBUS_ERR_NO_MEMORY - }; + assert(-error > -AVAHI_OK); + assert(-error < -AVAHI_ERR_MAX); - g_assert(-error > -AVAHI_OK); - g_assert(-error < -AVAHI_ERR_MAX); + if (!text) + text = avahi_strerror(error); - reply = dbus_message_new_error(m, table[-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; } -static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const gchar *text) { +static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const char *text) { DBusMessage *reply; reply = dbus_message_new_method_return(m); @@ -373,7 +450,7 @@ static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const return DBUS_HANDLER_RESULT_HANDLED; } -static DBusHandlerResult respond_int32(DBusConnection *c, DBusMessage *m, gint32 i) { +static DBusHandlerResult respond_int32(DBusConnection *c, DBusMessage *m, int32_t i) { DBusMessage *reply; reply = dbus_message_new_method_return(m); @@ -384,6 +461,28 @@ static DBusHandlerResult respond_int32(DBusConnection *c, DBusMessage *m, gint32 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; @@ -394,7 +493,7 @@ static DBusHandlerResult respond_ok(DBusConnection *c, DBusMessage *m) { return DBUS_HANDLER_RESULT_HANDLED; } -static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const gchar *path) { +static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const char *path) { DBusMessage *reply; reply = dbus_message_new_method_return(m); @@ -405,36 +504,119 @@ static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const g return DBUS_HANDLER_RESULT_HANDLED; } -static DBusHandlerResult handle_introspect(DBusConnection *c, DBusMessage *m, const gchar *fname) { - gchar *path = NULL; - gchar *contents; - GError *gerror = NULL; +static char *file_get_contents(char *fname) { + int fd = -1; + struct stat st; + ssize_t size; + char *buf = NULL; + + assert(fname); + + if (!(fd = open(fname, O_RDONLY))) { + avahi_log_error("Failed to open %s: %s", fname, strerror(errno)); + goto fail; + } + + if (fstat(fd, &st) < 0) { + avahi_log_error("stat(%s) failed: %s", fname, strerror(errno)); + goto fail; + } + + if (!(S_ISREG(st.st_mode))) { + avahi_log_error("Invalid file %s", fname); + goto fail; + } + + if (st.st_size > 1024*1024) { /** 1MB */ + avahi_log_error("File too large %s", fname); + goto fail; + } + + buf = avahi_new(char, st.st_size+1); + + if ((size = read(fd, buf, st.st_size)) < 0) { + avahi_log_error("read() failed: %s\n", strerror(errno)); + goto fail; + } + + buf[size] = 0; + + close(fd); + return buf; + +fail: + if (fd >= 0) + close(fd); + + if (buf) + avahi_free(buf); + + return NULL; + +} + +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_NOT_FOUND : return "NotFound"; + 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_TIMEOUT : return "Timeout"; + case AVAHI_RESOLVER_FAILURE : return "Failure"; + case AVAHI_RESOLVER_NOT_FOUND : return "NotFound"; + } + + abort(); +} + +static int map_resolve_error(AvahiResolverEvent e) { + + switch(e) { + case AVAHI_RESOLVER_FOUND : abort(); + case AVAHI_RESOLVER_TIMEOUT : return AVAHI_ERR_TIMEOUT; + case AVAHI_RESOLVER_FAILURE : return AVAHI_ERR_FAILURE; + case AVAHI_RESOLVER_NOT_FOUND : return AVAHI_ERR_NOT_FOUND; + } + + abort(); +} + +static DBusHandlerResult handle_introspect(DBusConnection *c, DBusMessage *m, const char *fname) { + char *path, *contents; DBusError error; - g_assert(c); - g_assert(m); - g_assert(fname); + assert(c); + assert(m); + assert(fname); dbus_error_init(&error); if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { - avahi_log_warn("Error parsing Introspect message: %s", error.message); + avahi_log_error("Error parsing Introspect message: %s", error.message); goto fail; } - path = g_strdup_printf("%s/%s", AVAHI_DBUS_INTROSPECTION_DIR, fname); - - if (!(g_file_get_contents(path, &contents, NULL, &gerror))) { - avahi_log_warn("Failed to load introspection data: %s", gerror->message); - g_error_free(gerror); - g_free(path); + path = avahi_strdup_printf("%s/%s", AVAHI_DBUS_INTROSPECTION_DIR, fname); + contents = file_get_contents(path); + avahi_free(path); + + if (!contents) { + avahi_log_error("Failed to load introspection data."); goto fail; } - - g_free(path); respond_string(c, m, contents); - g_free(contents); + avahi_free(contents); return DBUS_HANDLER_RESULT_HANDLED; @@ -447,12 +629,11 @@ fail: } static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage *m, void *userdata) { - GMainLoop *loop = 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)); */ @@ -460,23 +641,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"); @@ -487,7 +670,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); } } @@ -500,17 +683,17 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) { +static void entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, void* userdata) { EntryGroupInfo *i = userdata; DBusMessage *m; - gint32 t; + int32_t t; - g_assert(s); - g_assert(g); - g_assert(i); + assert(s); + assert(g); + assert(i); m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged"); - t = (gint32) state; + t = (int32_t) 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); @@ -521,13 +704,13 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, DBusError error; EntryGroupInfo *i = userdata; - g_assert(c); - g_assert(m); - g_assert(i); + 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)); @@ -569,11 +752,12 @@ 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; - gboolean b; + int b; if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing EntryGroup::IsEmpty message"); @@ -598,12 +782,13 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, } state = avahi_s_entry_group_get_state(i->entry_group); - return respond_int32(c, m, (gint32) state); + return respond_int32(c, m, (int32_t) state); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) { - gint32 interface, protocol; - gchar *type, *name, *domain, *host; - guint16 port; + int32_t interface, protocol; + uint32_t flags; + char *type, *name, *domain, *host; + uint16_t port; AvahiStringList *strlst; DBusMessageIter iter, sub; int j; @@ -612,6 +797,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, &type, DBUS_TYPE_STRING, &domain, @@ -624,7 +810,7 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, dbus_message_iter_init(m, &iter); - for (j = 0; j < 7; j++) + for (j = 0; j < 8; j++) dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || @@ -639,12 +825,12 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, for (;;) { DBusMessageIter sub2; int at, n; - guint8 *k; + uint8_t *k; if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) break; - g_assert(at == DBUS_TYPE_ARRAY); + assert(at == DBUS_TYPE_ARRAY); if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) { avahi_log_warn("Error parsing EntryGroup::AddService message"); @@ -670,7 +856,7 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, 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) { + 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); } else @@ -681,14 +867,16 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, 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; + int32_t interface, protocol; + uint32_t flags; + char *name, *address; AvahiAddress a; 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, &address, DBUS_TYPE_INVALID) || !name || !address) { @@ -705,7 +893,7 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, 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 i->n_entries ++; @@ -722,24 +910,26 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata) { - HostNameResolverInfo *i = 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; - g_assert(r); - g_assert(host_name); - g_assert(i); + assert(r); + assert(host_name); + assert(i); if (event == AVAHI_RESOLVER_FOUND) { char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; DBusMessage *reply; - g_assert(a); + assert(a); avahi_address_snprint(t, sizeof(t), a); - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) a->family; + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) a->proto; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -749,37 +939,37 @@ 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 { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); - - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); - } + } else + respond_error(server->bus, i->message, map_resolve_error(event), 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 gchar *host_name, gpointer userdata) { - AddressResolverInfo *i = 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; - g_assert(r); - g_assert(address); - g_assert(i); + assert(r); + assert(address); + assert(i); if (event == AVAHI_RESOLVER_FOUND) { char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; DBusMessage *reply; - g_assert(host_name); + assert(host_name); avahi_address_snprint(t, sizeof(t), address); - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) address->family; + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) address->proto; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -789,29 +979,28 @@ 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 { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); - } + } else + respond_error(server->bus, i->message, map_resolve_error(event), NULL); - address_resolver_free(i); + sync_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); + 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)); @@ -845,25 +1034,32 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *domain, gpointer 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; - 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); + int32_t i_interface, i_protocol; + uint32_t u_flags; + + assert(b); + 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, 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); + } + dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); @@ -873,13 +1069,13 @@ static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMe DBusError error; ServiceTypeBrowserInfo *i = userdata; - g_assert(c); - g_assert(m); - g_assert(i); + 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)); @@ -913,27 +1109,34 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void service_type_browser_callback(AvahiSServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *type, const gchar *domain, gpointer 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; - 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); + int32_t i_interface, i_protocol; + uint32_t u_flags; + + assert(b); + 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, 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); + } + dbus_message_set_destination(m, i->client->name); dbus_connection_send(server->bus, m, NULL); dbus_message_unref(m); @@ -943,13 +1146,13 @@ static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage DBusError error; ServiceBrowserInfo *i = userdata; - g_assert(c); - g_assert(m); - g_assert(i); + 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)); @@ -983,69 +1186,101 @@ fail: return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -static void service_browser_callback(AvahiSServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata) { +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; - 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); + int32_t i_interface, i_protocol; + uint32_t u_flags; + + assert(b); + 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, map_browse_signal_name(event)); + + 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); + } + 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, AvahiResolverEvent event, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host_name, + const char *name, + const char *type, + const char *domain, + const char *host_name, const AvahiAddress *a, - guint16 port, + uint16_t port, AvahiStringList *txt, - gpointer userdata) { + AvahiLookupResultFlags flags, + void* userdata) { - ServiceResolverInfo *i = userdata; + SyncServiceResolverInfo *i = userdata; - g_assert(r); - g_assert(i); + assert(r); + assert(i); if (event == AVAHI_RESOLVER_FOUND) { char t[256], *pt = t; - gint32 i_interface, i_protocol, i_aprotocol; - guint n, j; - AvahiStringList *p; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; DBusMessage *reply; - DBusMessageIter iter, sub; + + assert(host_name); - g_assert(host_name); + if (!name) + name = ""; - g_assert(a); + assert(a); avahi_address_snprint(t, sizeof(t), a); - i_interface = (gint32) interface; - i_protocol = (gint32) protocol; - i_aprotocol = (gint32) a->family; + i_interface = (int32_t) interface; + i_protocol = (int32_t) protocol; + i_aprotocol = (int32_t) a->proto; + u_flags = (uint32_t) flags; reply = dbus_message_new_method_return(i->message); dbus_message_append_args( @@ -1061,93 +1296,392 @@ 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 guint8 *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 { - g_assert(event == AVAHI_RESOLVER_TIMEOUT); + } else + respond_error(server->bus, i->message, map_resolve_error(event), NULL); + + 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, 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_browse_signal_name(event)); + + if (event == AVAHI_RESOLVER_FOUND) { + char t[256], *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); - respond_error(server->bus, i->message, AVAHI_ERR_TIMEOUT, NULL); } - service_resolver_free(i); + dbus_message_set_destination(reply, i->client->name); + dbus_connection_send(server->bus, reply, NULL); + dbus_message_unref(reply); } -static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) { +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")) { + 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 Server::GetHostName message"); + avahi_log_warn("Error parsing AddressResolver::Free message"); goto fail; } - return respond_string(c, m, avahi_server_get_host_name(avahi_server)); + async_address_resolver_free(i); + return respond_ok(c, m); - } 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)); + } + + avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) { +fail: + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { - avahi_log_warn("Error parsing Server::GetHostNameFqdn message"); - goto fail; - } +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; - return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server)); - - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) { + assert(r); + assert(i); - if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { - avahi_log_warn("Error parsing Server::GetVersionString message"); - goto fail; - } + reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, map_resolve_signal_name(event)); - return respond_string(c, m, PACKAGE_STRING); + if (event == AVAHI_RESOLVER_FOUND) { + char t[256], *pt = t; + int32_t i_interface, i_protocol, i_aprotocol; + uint32_t u_flags; - } 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; - } - - state = avahi_server_get_state(avahi_server); - return respond_int32(c, m, (gint32) state); + assert(a); + assert(host_name); + avahi_address_snprint(t, sizeof(t), a); - } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) { - gint32 idx; + 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); + } + + 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[256], *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); */ + + assert(a); + avahi_address_snprint(t, sizeof(t), a); + + if (!name) + name = ""; + + 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, &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); + } + + 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; + } + + return respond_string(c, m, avahi_server_get_host_name(avahi_server)); + + } 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)); + + } 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"); + goto fail; + } + + return respond_string(c, m, PACKAGE_STRING); + + } 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; + } + + 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, "IsServiceLocal")) { + int32_t interface, protocol; + char *name, *type, *domain; + int b; + + 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_INVALID) || !name || !type || !domain) { + avahi_log_warn("Error parsing Server::IsServiceLocal message"); + goto fail; + } + + if ((b = avahi_server_is_service_local(avahi_server, interface, protocol, name, type, domain)) < 0) + return respond_error(c, m, avahi_server_errno(avahi_server), NULL); + + return respond_boolean(c, m, b); + + } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) { + int32_t idx; int fd; struct ifreq ifr; @@ -1160,18 +1694,19 @@ 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) { - gchar txt[256]; - g_snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); - return respond_error(c, m, AVAHI_ERR_OS, txt); - } + 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); + } memset(&ifr, 0, sizeof(ifr)); ifr.ifr_ifindex = idx; if (ioctl(fd, SIOCGIFNAME, &ifr) < 0) { - gchar txt[256]; - g_snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); close(fd); return respond_error(c, m, AVAHI_ERR_OS, txt); } @@ -1182,7 +1717,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void #endif } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) { - gchar *n; + char *n; int fd; struct ifreq ifr; @@ -1194,18 +1729,19 @@ 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) { - gchar txt[256]; - g_snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); - return respond_error(c, m, AVAHI_ERR_OS, txt); - } + 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); + } memset(&ifr, 0, sizeof(ifr)); - g_snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", n); + snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", n); if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) { - gchar txt[256]; - g_snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); + char txt[256]; + snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno)); close(fd); return respond_error(c, m, AVAHI_ERR_OS, txt); } @@ -1216,7 +1752,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void #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) { avahi_log_warn("Error parsing Server::GetAlternativeHostName message"); @@ -1225,12 +1761,12 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void t = avahi_alternative_host_name(n); respond_string(c, m, t); - g_free(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) { avahi_log_warn("Error parsing Server::GetAlternativeServiceName message"); @@ -1239,7 +1775,7 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void t = avahi_alternative_service_name(n); respond_string(c, m, t); - g_free(t); + avahi_free(t); return DBUS_HANDLER_RESULT_HANDLED; @@ -1270,10 +1806,10 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); } - i = g_new(EntryGroupInfo, 1); + 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); client->n_objects++; @@ -1288,9 +1824,10 @@ 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; - 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, @@ -1298,6 +1835,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; @@ -1313,14 +1851,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void return 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_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, (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); } @@ -1328,9 +1866,10 @@ 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; - 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( @@ -1338,6 +1877,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; @@ -1356,14 +1896,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL); } - i = g_new(AddressResolverInfo, 1); + i = avahi_new(SyncAddressResolverInfo, 1); i->client = client; i->message = dbus_message_ref(m); - AVAHI_LLIST_PREPEND(AddressResolverInfo, address_resolvers, client->address_resolvers, i); + 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, (AvahiLookupFlags) flags, sync_address_resolver_callback, i))) { + sync_address_resolver_free(i); return respond_error(c, m, avahi_server_errno(avahi_server), NULL); } @@ -1380,16 +1920,17 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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; @@ -1408,14 +1949,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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_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); } @@ -1434,14 +1975,16 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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; @@ -1461,14 +2004,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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_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); } @@ -1476,7 +2019,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 = { @@ -1487,8 +2030,9 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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, @@ -1496,6 +2040,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; @@ -1515,14 +2060,14 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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_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); } @@ -1532,9 +2077,10 @@ 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; - 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, @@ -1544,7 +2090,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; } @@ -1561,20 +2108,192 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void 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_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, (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)); @@ -1587,19 +2306,19 @@ fail: void dbus_protocol_server_state_changed(AvahiServerState state) { DBusMessage *m; - gint32 t; + int32_t t; if (!server) return; m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged"); - t = (gint32) state; + t = (int32_t) state; dbus_message_append_args(m, DBUS_TYPE_INT32, &t, 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 = { @@ -1613,30 +2332,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, TRUE); + 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; @@ -1645,9 +2382,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; } @@ -1659,14 +2398,14 @@ void dbus_protocol_shutdown(void) { while (server->clients) client_free(server->clients); - g_assert(server->n_clients == 0); + 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; } }