static char* avahi_client_get_string_reply_and_block (AvahiClient *client, const char *method, const char *param) { DBusMessage *message = NULL, *reply = NULL; DBusError error; char *ret, *n; assert(client); assert(method); dbus_error_init (&error); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, method))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (param) { if (!dbus_message_append_args (message, DBUS_TYPE_STRING, ¶m, DBUS_TYPE_INVALID)) { avahi_client_set_errno (client, AVAHI_ERR_NO_MEMORY); goto fail; } } reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error); if (!reply || dbus_error_is_set (&error)) goto fail; if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &ret, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) goto fail; if (!(n = avahi_strdup(ret))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return n; fail: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } return NULL; }
int avahi_client_set_host_name(AvahiClient* client, const char *name) { DBusMessage *message = NULL, *reply = NULL; DBusError error; assert(client); if (!avahi_client_is_connected(client)) return avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); dbus_error_init (&error); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "SetHostName"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) { avahi_client_set_errno (client, AVAHI_ERR_NO_MEMORY); goto fail; } reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error); if (!reply || dbus_error_is_set (&error)) goto fail; if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) goto fail; dbus_message_unref(message); dbus_message_unref(reply); avahi_free(client->host_name); client->host_name = NULL; avahi_free(client->host_name_fqdn); client->host_name_fqdn = NULL; return 0; fail: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } return client->error; }
int avahi_entry_group_is_empty (AvahiEntryGroup *group) { DBusMessage *message = NULL, *reply = NULL; DBusError error; int r = AVAHI_OK; int b; AvahiClient *client; assert(group); client = group->client; if (!group->path || !avahi_client_is_connected(group->client)) return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); dbus_error_init(&error); if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty"))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return !!b; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
uint32_t avahi_client_get_local_service_cookie(AvahiClient *client) { DBusMessage *message = NULL, *reply = NULL; DBusError error; assert(client); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); return AVAHI_SERVICE_COOKIE_INVALID; } if (client->local_service_cookie_valid) return client->local_service_cookie; dbus_error_init (&error); if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error); if (!reply || dbus_error_is_set (&error)) goto fail; if (!dbus_message_get_args (reply, &error, DBUS_TYPE_UINT32, &client->local_service_cookie, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) goto fail; dbus_message_unref(message); dbus_message_unref(reply); client->local_service_cookie_valid = 1; return client->local_service_cookie; fail: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } return AVAHI_SERVICE_COOKIE_INVALID; }
/* Just for internal use */ int avahi_client_simple_method_call(AvahiClient *client, const char *path, const char *interface, const char *method) { DBusMessage *message = NULL, *reply = NULL; DBusError error; int r = AVAHI_OK; dbus_error_init(&error); assert(client); assert(path); assert(interface); assert(method); if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, path, interface, method))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return AVAHI_OK; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
static int retrieve_state(AvahiEntryGroup *group) { DBusMessage *message = NULL, *reply = NULL; DBusError error; int r = AVAHI_OK; int32_t state; AvahiClient *client; dbus_error_init(&error); assert(group); client = group->client; if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState"))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return state; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
const char* avahi_client_get_domain_name(AvahiClient *client) { assert(client); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); return NULL; } if (!client->domain_name) client->domain_name = avahi_client_get_string_reply_and_block(client, "GetDomainName", NULL); return client->domain_name; }
const char* avahi_client_get_version_string(AvahiClient *client) { assert(client); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); return NULL; } if (!client->version_string) client->version_string = avahi_client_get_string_reply_and_block(client, "GetVersionString", NULL); return client->version_string; }
int avahi_entry_group_reset(AvahiEntryGroup *group) { int ret; assert(group); if (!group->path || !avahi_client_is_connected(group->client)) return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); if ((ret = entry_group_simple_method_call(group, "Reset")) < 0) return ret; group->state_valid = 0; return ret; }
const char* avahi_client_get_host_name_fqdn (AvahiClient *client) { assert(client); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); return NULL; } if (!client->host_name_fqdn) client->host_name_fqdn = avahi_client_get_string_reply_and_block(client, "GetHostNameFqdn", NULL); return client->host_name_fqdn; }
DBusHandlerResult avahi_service_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { AvahiServiceBrowser *b = NULL; DBusError error; const char *path; char *name = NULL, *type, *domain; int32_t interface, protocol; uint32_t flags = 0; dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (b = client->service_browsers; b; b = b->service_browsers_next) if (strcmp (b->path, path) == 0) break; if (!b) goto fail; type = b->type; domain = b->domain; interface = b->interface; protocol = b->protocol; switch (event) { case AVAHI_BROWSER_NEW: case AVAHI_BROWSER_REMOVE: if (!dbus_message_get_args ( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } break; case AVAHI_BROWSER_CACHE_EXHAUSTED: case AVAHI_BROWSER_ALL_FOR_NOW: break; case AVAHI_BROWSER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); break; } } b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, type, domain, (AvahiLookupResultFlags) flags, b->userdata); return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
int avahi_client_set_dbus_error(AvahiClient *client, DBusError *error) { assert(client); assert(error); return avahi_client_set_errno(client, avahi_error_dbus_to_number(error->name)); }
static DBusHandlerResult filter_func(DBusConnection *bus, DBusMessage *message, void *userdata) { AvahiClient *client = (AvahiClient *)userdata; DBusError error; assert(bus); assert(message); dbus_error_init(&error); /* fprintf(stderr, "dbus: interface=%s, path=%s, member=%s\n", */ /* dbus_message_get_interface (message), */ /* dbus_message_get_path (message), */ /* dbus_message_get_member (message)); */ if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { /* The DBUS server died or kicked us */ avahi_client_set_errno(client, AVAHI_ERR_DISCONNECTED); goto fail; } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameAcquired")) { /* Ignore this message */ } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) { char *name, *old, *newname; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &newname, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) { fprintf(stderr, "WARNING: Failed to parse NameOwnerChanged signal: %s\n", error.message); avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (strcmp(name, AVAHI_DBUS_NAME) == 0) { if (old[0] && avahi_client_is_connected(client)) { /* Regardless if the server lost its name or * if the name was transfered: our services are no longer * available, so we disconnect ourselves */ avahi_client_set_errno(client, AVAHI_ERR_DISCONNECTED); goto fail; } else if (client->state == AVAHI_CLIENT_CONNECTING && (!old || *old == 0)) { int ret; /* Server appeared */ if ((ret = init_server(client, NULL)) < 0) { avahi_client_set_errno(client, ret); goto fail; } } } } else if (!avahi_client_is_connected(client)) { /* Ignore messages we get in unconnected state */ } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged")) { int32_t state; char *e = NULL; int c; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_STRING, &e, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "WARNING: Failed to parse Server.StateChanged signal: %s\n", error.message); avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if ((c = avahi_error_dbus_to_number(e)) != AVAHI_OK) avahi_client_set_errno(client, c); client_set_state(client, (AvahiClientState) state); } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged")) { const char *path; AvahiEntryGroup *g; path = dbus_message_get_path(message); for (g = client->groups; g; g = g->groups_next){ if (strcmp(g->path, path) == 0) break; } if (g) { int32_t state; char *e; int c; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_STRING, &e, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) { fprintf(stderr, "WARNING: Failed to parse EntryGroup.StateChanged signal: %s\n", error.message); avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if ((c = avahi_error_dbus_to_number(e)) != AVAHI_OK) avahi_client_set_errno(client, c); avahi_entry_group_set_state(g, (AvahiEntryGroupState)state); } return avahi_domain_browser_event(client, AVAHI_BROWSER_NEW, message); } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "ItemRemove")) return avahi_domain_browser_event(client, AVAHI_BROWSER_REMOVE, message); else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "CacheExhausted")) return avahi_domain_browser_event(client, AVAHI_BROWSER_CACHE_EXHAUSTED, message); else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "AllForNow")) return avahi_domain_browser_event(client, AVAHI_BROWSER_ALL_FOR_NOW, message); else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Failure")) return avahi_domain_browser_event(client, AVAHI_BROWSER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "ItemNew")) return avahi_service_type_browser_event (client, AVAHI_BROWSER_NEW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "ItemRemove")) return avahi_service_type_browser_event (client, AVAHI_BROWSER_REMOVE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "CacheExhausted")) return avahi_service_type_browser_event (client, AVAHI_BROWSER_CACHE_EXHAUSTED, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "AllForNow")) return avahi_service_type_browser_event (client, AVAHI_BROWSER_ALL_FOR_NOW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Failure")) return avahi_service_type_browser_event (client, AVAHI_BROWSER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "ItemNew")) return avahi_service_browser_event (client, AVAHI_BROWSER_NEW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "ItemRemove")) return avahi_service_browser_event (client, AVAHI_BROWSER_REMOVE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "CacheExhausted")) return avahi_service_browser_event (client, AVAHI_BROWSER_CACHE_EXHAUSTED, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "AllForNow")) return avahi_service_browser_event (client, AVAHI_BROWSER_ALL_FOR_NOW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Failure")) return avahi_service_browser_event (client, AVAHI_BROWSER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Found")) return avahi_service_resolver_event (client, AVAHI_RESOLVER_FOUND, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Failure")) return avahi_service_resolver_event (client, AVAHI_RESOLVER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Found")) return avahi_host_name_resolver_event (client, AVAHI_RESOLVER_FOUND, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Failure")) return avahi_host_name_resolver_event (client, AVAHI_RESOLVER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Found")) return avahi_address_resolver_event (client, AVAHI_RESOLVER_FOUND, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Failure")) return avahi_address_resolver_event (client, AVAHI_RESOLVER_FAILURE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "ItemNew")) return avahi_record_browser_event (client, AVAHI_BROWSER_NEW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "ItemRemove")) return avahi_record_browser_event (client, AVAHI_BROWSER_REMOVE, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "CacheExhausted")) return avahi_record_browser_event (client, AVAHI_BROWSER_CACHE_EXHAUSTED, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "AllForNow")) return avahi_record_browser_event (client, AVAHI_BROWSER_ALL_FOR_NOW, message); else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Failure")) return avahi_record_browser_event (client, AVAHI_BROWSER_FAILURE, message); else { fprintf(stderr, "WARNING: Unhandled message: interface=%s, path=%s, member=%s\n", dbus_message_get_interface(message), dbus_message_get_path(message), dbus_message_get_member(message)); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } return DBUS_HANDLER_RESULT_HANDLED; fail: if (dbus_error_is_set(&error)) { avahi_client_set_errno(client, avahi_error_dbus_to_number(error.name)); dbus_error_free(&error); } client_set_state(client, AVAHI_CLIENT_FAILURE); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
AvahiEntryGroup* avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *userdata) { AvahiEntryGroup *group = NULL; DBusMessage *message = NULL, *reply = NULL; DBusError error; char *path; int state; assert(client); dbus_error_init (&error); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); goto fail; } if (!(group = avahi_new(AvahiEntryGroup, 1))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } group->client = client; group->callback = callback; group->userdata = userdata; group->state_valid = 0; group->path = NULL; AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, group); if (!(message = dbus_message_new_method_call( AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!(group->path = avahi_strdup (path))) { /* FIXME: We don't remove the object on the server side */ avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if ((state = retrieve_state(group)) < 0) { avahi_client_set_errno(client, state); goto fail; } avahi_entry_group_set_state(group, (AvahiEntryGroupState) state); dbus_message_unref(message); dbus_message_unref(reply); return group; fail: if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (group) avahi_entry_group_free(group); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return NULL; }
DBusHandlerResult avahi_service_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) { AvahiServiceResolver *r = NULL; DBusError error; const char *path; AvahiStringList *strlst = NULL; assert(client); assert(message); dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (r = client->service_resolvers; r; r = r->service_resolvers_next) if (strcmp (r->path, path) == 0) break; if (!r) goto fail; switch (event) { case AVAHI_RESOLVER_FOUND: { int j; int32_t interface, protocol, aprotocol; uint32_t flags; char *name, *type, *domain, *host, *address; uint16_t port; DBusMessageIter iter, sub; AvahiAddress a; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_STRING, &host, DBUS_TYPE_INT32, &aprotocol, DBUS_TYPE_STRING, &address, DBUS_TYPE_UINT16, &port, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_init(message, &iter); for (j = 0; j < 9; 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) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } strlst = NULL; dbus_message_iter_recurse(&iter, &sub); for (;;) { DBusMessageIter sub2; int at; const uint8_t *k; int n; if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) break; assert(at == DBUS_TYPE_ARRAY); if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } dbus_message_iter_recurse(&sub, &sub2); k = NULL; n = 0; dbus_message_iter_get_fixed_array(&sub2, &k, &n); if (k && n > 0) strlst = avahi_string_list_add_arbitrary(strlst, k, n); dbus_message_iter_next(&sub); } dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_get_basic(&iter, &flags); assert(address); if (address[0] == 0) address = NULL; else avahi_address_parse(address, (AvahiProtocol) aprotocol, &a); r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, type, domain, host, address ? &a : NULL, port, strlst, (AvahiLookupResultFlags) flags, r->userdata); avahi_string_list_free(strlst); break; } case AVAHI_RESOLVER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt)); r->callback(r, r->interface, r->protocol, event, r->name, r->type, r->domain, NULL, NULL, 0, NULL, 0, r->userdata); break; } } return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); avahi_string_list_free(strlst); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
/** Add a host/address pair */ int avahi_entry_group_add_address( AvahiEntryGroup *group, AvahiIfIndex interface, AvahiProtocol protocol, AvahiPublishFlags flags, const char *name, const AvahiAddress *a) { DBusMessage *message = NULL, *reply = NULL; int r = AVAHI_OK; DBusError error; AvahiClient *client; int32_t i_interface, i_protocol; uint32_t u_flags; char s_address[AVAHI_ADDRESS_STR_MAX]; char *p_address = s_address; assert(name); client = group->client; if (!group->path || !avahi_client_is_connected(group->client)) return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); dbus_error_init(&error); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress"))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; if (!avahi_address_snprint (s_address, sizeof (s_address), a)) { r = avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS); goto fail; } if (!dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &p_address, DBUS_TYPE_INVALID)) { r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return AVAHI_OK; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { AvahiDomainBrowser *db = NULL; DBusError error; const char *path; char *domain = NULL; int32_t interface, protocol; uint32_t flags = 0; AvahiStringList *l; assert(client); assert(message); dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (db = client->domain_browsers; db; db = db->domain_browsers_next) if (strcmp (db->path, path) == 0) break; if (!db) goto fail; interface = db->interface; protocol = db->protocol; switch (event) { case AVAHI_BROWSER_NEW: case AVAHI_BROWSER_REMOVE: if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } break; case AVAHI_BROWSER_CACHE_EXHAUSTED: case AVAHI_BROWSER_ALL_FOR_NOW: break; case AVAHI_BROWSER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt)); break; } } if (domain) for (l = db->static_browse_domains; l; l = l->next) if (avahi_domain_equal((char*) l->text, domain)) { /* We had this entry already in the static entries */ return DBUS_HANDLER_RESULT_HANDLED; } db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata); return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
AvahiRecordBrowser* avahi_record_browser_new( AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, uint16_t clazz, uint16_t type, AvahiLookupFlags flags, AvahiRecordBrowserCallback callback, void *userdata) { AvahiRecordBrowser *b = NULL; DBusMessage *message = NULL, *reply = NULL; DBusError error; char *path; int32_t i_protocol, i_interface; uint32_t u_flags; assert(client); assert(name); assert(callback); dbus_error_init(&error); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); goto fail; } if (!(b = avahi_new(AvahiRecordBrowser, 1))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } b->client = client; b->callback = callback; b->userdata = userdata; b->path = NULL; b->name = NULL; b->clazz = clazz; b->type = type; b->interface = interface; b->protocol = protocol; AVAHI_LLIST_PREPEND(AvahiRecordBrowser, record_browsers, client->record_browsers, b); if (!(b->name = avahi_strdup(name))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "RecordBrowserNew"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; if (!dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT16, &clazz, DBUS_TYPE_UINT16, &type, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID)) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || dbus_error_is_set(&error)) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || dbus_error_is_set(&error) || !path) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!(b->path = avahi_strdup(path))) { /* FIXME: We don't remove the object on the server side */ avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return b; fail: if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (b) avahi_record_browser_free(b); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return NULL; }
DBusHandlerResult avahi_record_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { AvahiRecordBrowser *b = NULL; DBusError error; const char *path; char *name; int32_t interface, protocol; uint32_t flags = 0; uint16_t clazz, type; void *rdata = NULL; int rdata_size = 0; dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (b = client->record_browsers; b; b = b->record_browsers_next) if (strcmp (b->path, path) == 0) break; if (!b) goto fail; interface = b->interface; protocol = b->protocol; clazz = b->clazz; type = b->type; name = b->name; switch (event) { case AVAHI_BROWSER_NEW: case AVAHI_BROWSER_REMOVE: { DBusMessageIter iter, sub; int j; if (!dbus_message_get_args ( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT16, &clazz, DBUS_TYPE_UINT16, &type, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } dbus_message_iter_init(message, &iter); for (j = 0; j < 5; 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_BYTE) goto fail; dbus_message_iter_recurse(&iter, &sub); dbus_message_iter_get_fixed_array(&sub, &rdata, &rdata_size); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) goto fail; dbus_message_iter_get_basic(&iter, &flags); break; } case AVAHI_BROWSER_CACHE_EXHAUSTED: case AVAHI_BROWSER_ALL_FOR_NOW: break; case AVAHI_BROWSER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); break; } } b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, clazz, type, rdata, (size_t) rdata_size, (AvahiLookupResultFlags) flags, b->userdata); return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
AvahiAddressResolver * avahi_address_resolver_new( AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, const AvahiAddress *a, AvahiLookupFlags flags, AvahiAddressResolverCallback callback, void *userdata) { DBusError error; AvahiAddressResolver *r = NULL; DBusMessage *message = NULL, *reply = NULL; int32_t i_interface, i_protocol; uint32_t u_flags; char *path; char addr[AVAHI_ADDRESS_STR_MAX], *address = addr; assert(client); assert(a); dbus_error_init (&error); if (!avahi_address_snprint (addr, sizeof(addr), a)) { avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS); return NULL; } if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); goto fail; } if (!(r = avahi_new(AvahiAddressResolver, 1))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } r->client = client; r->callback = callback; r->userdata = userdata; r->path = NULL; r->interface = interface; r->protocol = protocol; r->address = *a; AVAHI_LLIST_PREPEND(AvahiAddressResolver, address_resolvers, client->address_resolvers, r); if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "AddressResolverNew"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; if (!(dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_STRING, &address, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set(&error)) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || dbus_error_is_set(&error) || !path) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!(r->path = avahi_strdup(path))) { /* FIXME: We don't remove the object on the server side */ avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return r; fail: if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (r) avahi_address_resolver_free(r); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return NULL; }
DBusHandlerResult avahi_address_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) { AvahiAddressResolver *r = NULL; DBusError error; const char *path; assert(client); assert(message); dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (r = client->address_resolvers; r; r = r->address_resolvers_next) if (strcmp (r->path, path) == 0) break; if (!r) goto fail; switch (event) { case AVAHI_RESOLVER_FOUND: { int32_t interface, protocol, aprotocol; uint32_t flags; char *name, *address; AvahiAddress a; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_INT32, &aprotocol, DBUS_TYPE_STRING, &address, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } assert(address); if (!avahi_address_parse(address, (AvahiProtocol) aprotocol, &a)) { fprintf(stderr, "Failed to parse address\n"); goto fail; } r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, &a, name, (AvahiLookupResultFlags) flags, r->userdata); break; } case AVAHI_RESOLVER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt)); r->callback(r, r->interface, r->protocol, event, &r->address, NULL, 0, r->userdata); break; } } return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
/** Add an arbitrary record */ int avahi_entry_group_add_record( AvahiEntryGroup *group, AvahiIfIndex interface, AvahiProtocol protocol, AvahiPublishFlags flags, const char *name, uint16_t clazz, uint16_t type, uint32_t ttl, const void *rdata, size_t size) { DBusMessage *message = NULL, *reply = NULL; int r = AVAHI_OK; DBusError error; AvahiClient *client; int32_t i_interface, i_protocol; uint32_t u_flags; assert(name); client = group->client; if (!group->path || !avahi_client_is_connected(group->client)) return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); dbus_error_init(&error); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddRecord"))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; if (!dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT16, &clazz, DBUS_TYPE_UINT16, &type, DBUS_TYPE_UINT32, &ttl, DBUS_TYPE_INVALID) || append_rdata(message, rdata, size) < 0) { r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return AVAHI_OK; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
AvahiServiceResolver * avahi_service_resolver_new( AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain, AvahiProtocol aprotocol, AvahiLookupFlags flags, AvahiServiceResolverCallback callback, void *userdata) { DBusError error; AvahiServiceResolver *r = NULL; DBusMessage *message = NULL, *reply = NULL; int32_t i_interface, i_protocol, i_aprotocol; uint32_t u_flags; char *path; assert(client); assert(type); if (!domain) domain = ""; if (!name) name = ""; dbus_error_init (&error); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); goto fail; } if (!(r = avahi_new(AvahiServiceResolver, 1))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } r->client = client; r->callback = callback; r->userdata = userdata; r->path = NULL; r->name = r->type = r->domain = NULL; r->interface = interface; r->protocol = protocol; AVAHI_LLIST_PREPEND(AvahiServiceResolver, service_resolvers, client->service_resolvers, r); if (name && name[0]) if (!(r->name = avahi_strdup(name))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(r->type = avahi_strdup(type))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (domain && domain[0]) if (!(r->domain = avahi_strdup(domain))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceResolverNew"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; i_aprotocol = (int32_t) aprotocol; u_flags = (uint32_t) flags; if (!(dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &i_aprotocol, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set(&error)) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || dbus_error_is_set(&error) || !path) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!(r->path = avahi_strdup(path))) { /* FIXME: We don't remove the object on the server side */ avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return r; fail: if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (r) avahi_service_resolver_free(r); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return NULL; }
int avahi_entry_group_update_service_txt_strlst( AvahiEntryGroup *group, AvahiIfIndex interface, AvahiProtocol protocol, AvahiPublishFlags flags, const char *name, const char *type, const char *domain, AvahiStringList *txt) { DBusMessage *message = NULL, *reply = NULL; int r = AVAHI_OK; DBusError error; AvahiClient *client; int32_t i_interface, i_protocol; uint32_t u_flags; assert(group); assert(name); assert(type); client = group->client; if (!group->path || !avahi_client_is_connected(group->client)) return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); if (!domain) domain = ""; dbus_error_init(&error); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt"))) { r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; if (!dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID) || append_string_list(message, txt) < 0) { r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } dbus_message_unref(message); dbus_message_unref(reply); return AVAHI_OK; fail: if (dbus_error_is_set(&error)) { r = avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return r; }
AvahiDomainBrowser* avahi_domain_browser_new( AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, const char *domain, AvahiDomainBrowserType btype, AvahiLookupFlags flags, AvahiDomainBrowserCallback callback, void *userdata) { AvahiDomainBrowser *db = NULL; DBusMessage *message = NULL, *reply = NULL; DBusError error; char *path; int32_t i_interface, i_protocol, bt; uint32_t u_flags; assert(client); assert(callback); dbus_error_init (&error); if (!avahi_client_is_connected(client)) { avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); goto fail; } if (!domain) domain = ""; if (!(db = avahi_new (AvahiDomainBrowser, 1))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } db->ref = 1; db->client = client; db->callback = callback; db->userdata = userdata; db->path = NULL; db->interface = interface; db->protocol = protocol; db->static_browse_domains = NULL; db->defer_timeout = NULL; AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, db); if (!(client->flags & AVAHI_CLIENT_IGNORE_USER_CONFIG)) { parse_environment(db); parse_domain_file(db); } db->static_browse_domains = avahi_string_list_reverse(db->static_browse_domains); if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew"))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } i_interface = (int32_t) interface; i_protocol = (int32_t) protocol; u_flags = (uint32_t) flags; bt = btype; if (!(dbus_message_append_args( message, DBUS_TYPE_INT32, &i_interface, DBUS_TYPE_INT32, &i_protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &bt, DBUS_TYPE_UINT32, &u_flags, DBUS_TYPE_INVALID))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || dbus_error_is_set(&error)) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || dbus_error_is_set(&error) || !path) { avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); goto fail; } if (!(db->path = avahi_strdup(path))) { /* FIXME: We don't remove the object on the server side */ avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } if (db->static_browse_domains && btype == AVAHI_DOMAIN_BROWSER_BROWSE) { struct timeval tv = { 0, 0 }; if (!(db->defer_timeout = client->poll_api->timeout_new(client->poll_api, &tv, defer_timeout_callback, db))) { avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); goto fail; } } dbus_message_unref(message); dbus_message_unref(reply); return db; fail: if (dbus_error_is_set(&error)) { avahi_client_set_dbus_error(client, &error); dbus_error_free(&error); } if (db) avahi_domain_browser_free(db); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return NULL; }