#define MAX_OBJECTS_PER_CLIENT 50
#define MAX_ENTRIES_PER_ENTRY_GROUP 20
+/* #define VALGRIND_WORKAROUND */
+
struct EntryGroupInfo {
guint id;
Client *client;
- AvahiEntryGroup *entry_group;
+ AvahiSEntryGroup *entry_group;
gchar *path;
gint n_entries;
struct HostNameResolverInfo {
Client *client;
- AvahiHostNameResolver *host_name_resolver;
+ AvahiSHostNameResolver *host_name_resolver;
DBusMessage *message;
AVAHI_LLIST_FIELDS(HostNameResolverInfo, host_name_resolvers);
struct AddressResolverInfo {
Client *client;
- AvahiAddressResolver *address_resolver;
+ AvahiSAddressResolver *address_resolver;
DBusMessage *message;
AVAHI_LLIST_FIELDS(AddressResolverInfo, address_resolvers);
struct DomainBrowserInfo {
guint id;
Client *client;
- AvahiDomainBrowser *domain_browser;
+ AvahiSDomainBrowser *domain_browser;
gchar *path;
AVAHI_LLIST_FIELDS(DomainBrowserInfo, domain_browsers);
struct ServiceTypeBrowserInfo {
guint id;
Client *client;
- AvahiServiceTypeBrowser *service_type_browser;
+ AvahiSServiceTypeBrowser *service_type_browser;
gchar *path;
AVAHI_LLIST_FIELDS(ServiceTypeBrowserInfo, service_type_browsers);
struct ServiceBrowserInfo {
guint id;
Client *client;
- AvahiServiceBrowser *service_browser;
+ AvahiSServiceBrowser *service_browser;
gchar *path;
AVAHI_LLIST_FIELDS(ServiceBrowserInfo, service_browsers);
struct ServiceResolverInfo {
Client *client;
- AvahiServiceResolver *service_resolver;
+ AvahiSServiceResolver *service_resolver;
DBusMessage *message;
AVAHI_LLIST_FIELDS(ServiceResolverInfo, service_resolvers);
g_assert(i);
if (i->entry_group)
- avahi_entry_group_free(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_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i);
g_assert(i);
if (i->host_name_resolver)
- avahi_host_name_resolver_free(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);
g_assert(i);
if (i->address_resolver)
- avahi_address_resolver_free(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);
g_assert(i);
if (i->domain_browser)
- avahi_domain_browser_free(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_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i);
g_assert(i);
if (i->service_type_browser)
- avahi_service_type_browser_free(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_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i);
g_assert(i);
if (i->service_browser)
- avahi_service_browser_free(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_LLIST_REMOVE(ServiceBrowserInfo, service_browsers, i->client->service_browsers, i);
g_assert(i);
if (i->service_resolver)
- avahi_service_resolver_free(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_DBUS_ERR_TOO_MANY_ENTRIES,
AVAHI_DBUS_ERR_OS,
AVAHI_DBUS_ERR_ACCESS_DENIED,
- AVAHI_DBUS_ERR_INVALID_OPERATION
+ AVAHI_DBUS_ERR_INVALID_OPERATION,
+ AVAHI_DBUS_ERR_DBUS_ERROR,
+ AVAHI_DBUS_ERR_NOT_CONNECTED,
+ AVAHI_DBUS_ERR_NO_MEMORY
};
g_assert(-error > -AVAHI_OK);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
-static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) {
+static void entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) {
EntryGroupInfo *i = userdata;
DBusMessage *m;
gint32 t;
goto fail;
}
- avahi_entry_group_commit(i->entry_group);
+ avahi_s_entry_group_commit(i->entry_group);
return respond_ok(c, m);
goto fail;
}
- avahi_entry_group_reset(i->entry_group);
+ avahi_s_entry_group_reset(i->entry_group);
return respond_ok(c, m);
} else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty")) {
goto fail;
}
- b = !!avahi_entry_group_is_empty(i->entry_group);
+ b = !!avahi_s_entry_group_is_empty(i->entry_group);
reply = dbus_message_new_method_return(m);
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) {
-
+ AvahiEntryGroupState state;
+
if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
avahi_log_warn("Error parsing EntryGroup::GetState message");
goto fail;
}
- return respond_int32(c, m, (gint32) avahi_entry_group_get_state(i->entry_group));
+ state = avahi_s_entry_group_get_state(i->entry_group);
+ return respond_int32(c, m, (gint32) 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;
- gchar **txt = NULL;
- gint txt_len;
AvahiStringList *strlst;
+ DBusMessageIter iter, sub;
+ int j;
if (!dbus_message_get_args(
m, &error,
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 || !name) {
avahi_log_warn("Error parsing EntryGroup::AddService message");
goto fail;
}
+ dbus_message_iter_init(m, &iter);
+
+ for (j = 0; j < 7; j++)
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
+ dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY) {
+ avahi_log_warn("Error parsing EntryGroup::AddService message 2");
+ goto fail;
+ }
+
+ strlst = NULL;
+ dbus_message_iter_recurse(&iter, &sub);
+
+ for (;;) {
+ DBusMessageIter sub2;
+ int at, n;
+ guint8 *k;
+
+ if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID)
+ break;
+
+ g_assert(at == DBUS_TYPE_ARRAY);
+
+ if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) {
+ avahi_log_warn("Error parsing EntryGroup::AddService message");
+ goto fail;
+ }
+
+ dbus_message_iter_recurse(&sub, &sub2);
+ dbus_message_iter_get_fixed_array(&sub2, &k, &n);
+ strlst = avahi_string_list_add_arbitrary(strlst, k, n);
+
+ dbus_message_iter_next(&sub);
+ }
+
if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) {
+ avahi_string_list_free(strlst);
avahi_log_warn("Too many entries per entry group, client request failed.");
- dbus_free_string_array(txt);
return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
}
- strlst = avahi_string_list_new_from_array((const gchar**) txt, txt_len);
- dbus_free_string_array(txt);
-
if (domain && !*domain)
domain = NULL;
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) {
+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;
g_assert(r);
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) {
+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;
g_assert(r);
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) {
+static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata) {
DomainBrowserInfo *i = userdata;
DBusMessage *m;
gint32 i_interface, i_protocol;
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) {
+static void service_type_browser_callback(AvahiSServiceTypeBrowser *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;
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) {
+static void service_browser_callback(AvahiSServiceBrowser *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;
}
static void service_resolver_callback(
- AvahiServiceResolver *r,
+ AvahiSServiceResolver *r,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiResolverEvent event,
if (event == AVAHI_RESOLVER_FOUND) {
char t[256], *pt = t;
gint32 i_interface, i_protocol, i_aprotocol;
- gchar **array;
guint n, j;
AvahiStringList *p;
DBusMessage *reply;
+ DBusMessageIter iter, sub;
g_assert(host_name);
i_protocol = (gint32) protocol;
i_aprotocol = (gint32) a->family;
- 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_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]);
+ 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);
+
dbus_connection_send(server->bus, reply, NULL);
dbus_message_unref(reply);
} else {
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;
}
-
- return respond_int32(c, m, (gint32) avahi_server_get_state(avahi_server));
+
+ state = avahi_server_get_state(avahi_server);
+ return respond_int32(c, m, (gint32) state);
} else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) {
gint32 idx;
goto fail;
}
+#ifdef VALGRIND_WORKAROUND
+ 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));
close(fd);
return respond_string(c, m, ifr.ifr_name);
-
+#endif
+
} else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) {
gchar *n;
int fd;
goto fail;
}
+#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));
close(fd);
return respond_int32(c, m, ifr.ifr_ifindex);
+#endif
} else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeHostName")) {
gchar *n, * t;
AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i);
client->n_objects++;
- if (!(i->entry_group = avahi_entry_group_new(avahi_server, entry_group_callback, i))) {
+ if (!(i->entry_group = avahi_s_entry_group_new(avahi_server, entry_group_callback, i))) {
entry_group_free(i);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
AVAHI_LLIST_PREPEND(HostNameResolverInfo, host_name_resolvers, client->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))) {
+ 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);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
AVAHI_LLIST_PREPEND(AddressResolverInfo, address_resolvers, client->address_resolvers, i);
client->n_objects++;
- if (!(i->address_resolver = avahi_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i))) {
+ if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i))) {
address_resolver_free(i);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
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))) {
+ if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, domain_browser_callback, i))) {
domain_browser_free(i);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
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))) {
+ if (!(i->service_type_browser = avahi_s_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, service_type_browser_callback, i))) {
service_type_browser_free(i);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
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))) {
+ if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, service_browser_callback, i))) {
service_browser_free(i);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
AVAHI_LLIST_PREPEND(ServiceResolverInfo, service_resolvers, client->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))) {
+ 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);
return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
}
}
dbus_connection_setup_with_g_main(server->bus, NULL);
- dbus_connection_set_exit_on_disconnect(server->bus, FALSE);
+ dbus_connection_set_exit_on_disconnect(server->bus, TRUE);
dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, 0, &error);
if (dbus_error_is_set(&error)) {
projects / catta / blobdiff