X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/b1578e27b62e7332111bb706f79858b0866029e3..eca082a93f2619cfa10733947a81fa779cb49573:/src/pulsecore/protocol-dbus.c diff --git a/src/pulsecore/protocol-dbus.c b/src/pulsecore/protocol-dbus.c index 8fc08032..cf4b9fc5 100644 --- a/src/pulsecore/protocol-dbus.c +++ b/src/pulsecore/protocol-dbus.c @@ -28,6 +28,7 @@ #include #include +#include #include #include #include @@ -56,21 +57,28 @@ struct connection_entry { DBusConnection *connection; pa_client *client; - pa_bool_t listening_for_all_signals; + bool listening_for_all_signals; /* Contains object paths. If this is empty, then signals from all objects - * are accepted. Only used when listening_for_all_signals == TRUE. */ + * are accepted. Only used when listening_for_all_signals == true. */ pa_idxset *all_signals_objects; - /* Signal name -> idxset. The idxsets contain object paths. If an idxset is - * empty, then that signal is accepted from all objects. Only used when - * listening_for_all_signals == FALSE. */ + /* Signal name -> signal paths entry. The entries contain object paths. If + * a path set is empty, then that signal is accepted from all objects. This + * variable is only used when listening_for_all_signals == false. */ pa_hashmap *listening_signals; }; +/* Only used in connection entries' listening_signals hashmap. */ +struct signal_paths_entry { + char *signal; + pa_idxset *paths; +}; + struct interface_entry { char *name; pa_hashmap *method_handlers; + pa_hashmap *method_signatures; /* Derived from method_handlers. Contains only "in" arguments. */ pa_hashmap *property_handlers; pa_dbus_receive_cb_t get_all_properties_cb; pa_dbus_signal_info *signals; @@ -104,7 +112,7 @@ char *pa_get_dbus_address_from_server_type(pa_server_type_t server_type) { } pa_xfree(runtime_path); - pa_xfree(escaped_path); + dbus_free(escaped_path); return address; } @@ -117,7 +125,7 @@ static pa_dbus_protocol *dbus_protocol_new(pa_core *c) { p = pa_xnew(pa_dbus_protocol, 1); PA_REFCNT_INIT(p); - p->core = pa_core_ref(c); + p->core = c; p->objects = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); p->connections = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); p->extensions = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); @@ -161,17 +169,15 @@ void pa_dbus_protocol_unref(pa_dbus_protocol *p) { pa_assert(pa_hashmap_isempty(p->connections)); pa_assert(pa_idxset_isempty(p->extensions)); - pa_hashmap_free(p->objects, NULL, NULL); - pa_hashmap_free(p->connections, NULL, NULL); - pa_idxset_free(p->extensions, NULL, NULL); + pa_hashmap_free(p->objects); + pa_hashmap_free(p->connections); + pa_idxset_free(p->extensions, NULL); for (i = 0; i < PA_DBUS_PROTOCOL_HOOK_MAX; ++i) pa_hook_done(&p->hooks[i]); pa_assert_se(pa_shared_remove(p->core, "dbus-protocol") >= 0); - pa_core_unref(p->core); - pa_xfree(p); } @@ -186,7 +192,7 @@ static void update_introspection(struct object_entry *oe) { pa_strbuf_puts(buf, DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE); pa_strbuf_puts(buf, "\n"); - while ((iface_entry = pa_hashmap_iterate(oe->interfaces, &interfaces_state, NULL))) { + PA_HASHMAP_FOREACH(iface_entry, oe->interfaces, interfaces_state) { pa_dbus_method_handler *method_handler; pa_dbus_property_handler *property_handler; void *handlers_state = NULL; @@ -195,23 +201,25 @@ static void update_introspection(struct object_entry *oe) { pa_strbuf_printf(buf, " \n", iface_entry->name); - while ((method_handler = pa_hashmap_iterate(iface_entry->method_handlers, &handlers_state, NULL))) { + PA_HASHMAP_FOREACH(method_handler, iface_entry->method_handlers, handlers_state) { pa_strbuf_printf(buf, " \n", method_handler->method_name); for (i = 0; i < method_handler->n_arguments; ++i) - pa_strbuf_printf(buf, " \n", method_handler->arguments[i].name, - method_handler->arguments[i].type, - method_handler->arguments[i].direction); + pa_strbuf_printf(buf, " \n", + method_handler->arguments[i].name, + method_handler->arguments[i].type, + method_handler->arguments[i].direction); pa_strbuf_puts(buf, " \n"); } handlers_state = NULL; - while ((property_handler = pa_hashmap_iterate(iface_entry->property_handlers, &handlers_state, NULL))) - pa_strbuf_printf(buf, " \n", property_handler->property_name, - property_handler->type, - property_handler->get_cb ? (property_handler->set_cb ? "readwrite" : "read") : "write"); + PA_HASHMAP_FOREACH(property_handler, iface_entry->property_handlers, handlers_state) + pa_strbuf_printf(buf, " \n", + property_handler->property_name, + property_handler->type, + property_handler->get_cb ? (property_handler->set_cb ? "readwrite" : "read") : "write"); for (i = 0; i < iface_entry->n_signals; ++i) { pa_strbuf_printf(buf, " \n", iface_entry->signals[i].name); @@ -254,37 +262,90 @@ static void update_introspection(struct object_entry *oe) { oe->introspection = pa_strbuf_tostring_free(buf); } +/* Return value of find_handler() and its subfunctions. */ enum find_result_t { - FOUND_METHOD, + /* The received message is a valid .Get call. */ FOUND_GET_PROPERTY, + + /* The received message is a valid .Set call. */ FOUND_SET_PROPERTY, + + /* The received message is a valid .GetAll call. */ FOUND_GET_ALL, + + /* The received message is a valid method call. */ + FOUND_METHOD, + + /* The interface of the received message hasn't been registered for the + * destination object. */ + NO_SUCH_INTERFACE, + + /* No property handler was found for the received .Get or .Set call. */ + NO_SUCH_PROPERTY, + + /* The interface argument of a property call didn't match any registered + * interface. */ + NO_SUCH_PROPERTY_INTERFACE, + + /* The received message called .Get or .Set for a property whose access + * mode doesn't match the call. */ PROPERTY_ACCESS_DENIED, + + /* The new value signature of a .Set call didn't match the expected + * signature. */ + INVALID_PROPERTY_SIG, + + /* No method handler was found for the received message. */ NO_SUCH_METHOD, - NO_SUCH_PROPERTY, - INVALID_MESSAGE_ARGUMENTS + + /* The signature of the received message didn't match the expected + * signature. Despite the name, this can also be returned for a property + * call if its message signature is invalid. */ + INVALID_METHOD_SIG +}; + +/* Data for resolving the correct reaction to a received message. */ +struct call_info { + DBusMessage *message; /* The received message. */ + struct object_entry *obj_entry; + const char *interface; /* Destination interface name (extracted from the message). */ + struct interface_entry *iface_entry; + + const char *property; /* Property name (extracted from the message). */ + const char *property_interface; /* The interface argument of a property call is stored here. */ + pa_dbus_property_handler *property_handler; + const char *expected_property_sig; /* Property signature from the introspection data. */ + const char *property_sig; /* The signature of the new value in the received .Set message. */ + DBusMessageIter variant_iter; /* Iterator pointing to the beginning of the new value variant of a .Set call. */ + + const char *method; /* Method name (extracted from the message). */ + pa_dbus_method_handler *method_handler; + const char *expected_method_sig; /* Method signature from the introspection data. */ + const char *method_sig; /* The signature of the received message. */ }; -static enum find_result_t find_handler_by_property(struct object_entry *obj_entry, - DBusMessage *msg, - const char *property, - struct interface_entry **iface_entry, - pa_dbus_property_handler **property_handler) { +/* Called when call_info->property has been set and the property interface has + * not been given. In case of a Set call, call_info->property_sig is also set, + * which is checked against the expected value in this function. */ +static enum find_result_t find_handler_by_property(struct call_info *call_info) { void *state = NULL; - pa_assert(obj_entry); - pa_assert(msg); - pa_assert(property); - pa_assert(iface_entry); - pa_assert(property_handler); - - while ((*iface_entry = pa_hashmap_iterate(obj_entry->interfaces, &state, NULL))) { - if ((*property_handler = pa_hashmap_get((*iface_entry)->property_handlers, property))) { - if (dbus_message_has_member(msg, "Get")) - return (*property_handler)->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED; - else if (dbus_message_has_member(msg, "Set")) - return (*property_handler)->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED; - else + pa_assert(call_info); + + PA_HASHMAP_FOREACH(call_info->iface_entry, call_info->obj_entry->interfaces, state) { + if ((call_info->property_handler = pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property))) { + if (pa_streq(call_info->method, "Get")) + return call_info->property_handler->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED; + + else if (pa_streq(call_info->method, "Set")) { + call_info->expected_property_sig = call_info->property_handler->type; + + if (pa_streq(call_info->property_sig, call_info->expected_property_sig)) + return call_info->property_handler->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED; + else + return INVALID_PROPERTY_SIG; + + } else pa_assert_not_reached(); } } @@ -292,123 +353,149 @@ static enum find_result_t find_handler_by_property(struct object_entry *obj_entr return NO_SUCH_PROPERTY; } -static enum find_result_t find_handler_by_method(struct object_entry *obj_entry, - const char *method, - struct interface_entry **iface_entry, - pa_dbus_method_handler **method_handler) { +static enum find_result_t find_handler_by_method(struct call_info *call_info) { void *state = NULL; - pa_assert(obj_entry); - pa_assert(method); - pa_assert(iface_entry); - pa_assert(method_handler); + pa_assert(call_info); - while ((*iface_entry = pa_hashmap_iterate(obj_entry->interfaces, &state, NULL))) { - if ((*method_handler = pa_hashmap_get((*iface_entry)->method_handlers, method))) - return FOUND_METHOD; + PA_HASHMAP_FOREACH(call_info->iface_entry, call_info->obj_entry->interfaces, state) { + if ((call_info->method_handler = pa_hashmap_get(call_info->iface_entry->method_handlers, call_info->method))) { + pa_assert_se(call_info->expected_method_sig = pa_hashmap_get(call_info->iface_entry->method_signatures, call_info->method)); + + if (pa_streq(call_info->method_sig, call_info->expected_method_sig)) + return FOUND_METHOD; + else + return INVALID_METHOD_SIG; + } } - pa_log("find_handler_by_method() failed."); return NO_SUCH_METHOD; } -static enum find_result_t find_handler_from_properties_call(struct object_entry *obj_entry, - DBusMessage *msg, - struct interface_entry **iface_entry, - pa_dbus_property_handler **property_handler, - const char **attempted_property) { - const char *interface; +static enum find_result_t find_handler_from_properties_call(struct call_info *call_info) { + pa_assert(call_info); - pa_assert(obj_entry); - pa_assert(msg); - pa_assert(iface_entry); + if (pa_streq(call_info->method, "GetAll")) { + call_info->expected_method_sig = "s"; + if (!pa_streq(call_info->method_sig, call_info->expected_method_sig)) + return INVALID_METHOD_SIG; - if (dbus_message_has_member(msg, "GetAll")) { - if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID)) - return INVALID_MESSAGE_ARGUMENTS; + pa_assert_se(dbus_message_get_args(call_info->message, NULL, + DBUS_TYPE_STRING, &call_info->property_interface, + DBUS_TYPE_INVALID)); - if (*interface) { - if ((*iface_entry = pa_hashmap_get(obj_entry->interfaces, interface))) + if (*call_info->property_interface) { + if ((call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface))) return FOUND_GET_ALL; - else { - pa_log("GetAll message has unknown interface: %s", interface); - return NO_SUCH_METHOD; /* XXX: NO_SUCH_INTERFACE or something like that might be more accurate. */ - } + else + return NO_SUCH_PROPERTY_INTERFACE; + } else { - pa_assert_se((*iface_entry = pa_hashmap_first(obj_entry->interfaces))); + pa_assert_se(call_info->iface_entry = pa_hashmap_first(call_info->obj_entry->interfaces)); return FOUND_GET_ALL; } - } else { - if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, attempted_property, DBUS_TYPE_INVALID)) - return INVALID_MESSAGE_ARGUMENTS; - - if (*interface) { - if ((*iface_entry = pa_hashmap_get(obj_entry->interfaces, interface)) && - (*property_handler = pa_hashmap_get((*iface_entry)->property_handlers, *attempted_property))) { - if (dbus_message_has_member(msg, "Get")) - return (*property_handler)->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED; - else if (dbus_message_has_member(msg, "Set")) - return (*property_handler)->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED; + + } else if (pa_streq(call_info->method, "Get")) { + call_info->expected_method_sig = "ss"; + if (!pa_streq(call_info->method_sig, call_info->expected_method_sig)) + return INVALID_METHOD_SIG; + + pa_assert_se(dbus_message_get_args(call_info->message, NULL, + DBUS_TYPE_STRING, &call_info->property_interface, + DBUS_TYPE_STRING, &call_info->property, + DBUS_TYPE_INVALID)); + + if (*call_info->property_interface) { + if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface))) + return NO_SUCH_PROPERTY_INTERFACE; + else if ((call_info->property_handler = + pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property))) + return call_info->property_handler->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED; + else + return NO_SUCH_PROPERTY; + + } else + return find_handler_by_property(call_info); + + } else if (pa_streq(call_info->method, "Set")) { + DBusMessageIter msg_iter; + + call_info->expected_method_sig = "ssv"; + if (!pa_streq(call_info->method_sig, call_info->expected_method_sig)) + return INVALID_METHOD_SIG; + + pa_assert_se(dbus_message_iter_init(call_info->message, &msg_iter)); + + dbus_message_iter_get_basic(&msg_iter, &call_info->property_interface); + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &call_info->property); + pa_assert_se(dbus_message_iter_next(&msg_iter)); + + dbus_message_iter_recurse(&msg_iter, &call_info->variant_iter); + + call_info->property_sig = dbus_message_iter_get_signature(&call_info->variant_iter); + + if (*call_info->property_interface) { + if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface))) + return NO_SUCH_PROPERTY_INTERFACE; + + else if ((call_info->property_handler = + pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property))) { + call_info->expected_property_sig = call_info->property_handler->type; + + if (pa_streq(call_info->property_sig, call_info->expected_property_sig)) + return call_info->property_handler->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED; else - pa_assert_not_reached(); + return INVALID_PROPERTY_SIG; + } else return NO_SUCH_PROPERTY; + } else - return find_handler_by_property(obj_entry, msg, *attempted_property, iface_entry, property_handler); - } + return find_handler_by_property(call_info); + + } else + pa_assert_not_reached(); } -static enum find_result_t find_handler(struct object_entry *obj_entry, - DBusMessage *msg, - struct interface_entry **iface_entry, - pa_dbus_method_handler **method_handler, - pa_dbus_property_handler **property_handler, - const char **attempted_property) { - const char *interface; +static enum find_result_t find_handler(struct call_info *call_info) { + pa_assert(call_info); - pa_assert(obj_entry); - pa_assert(msg); - pa_assert(iface_entry); - pa_assert(method_handler); - pa_assert(property_handler); - pa_assert(attempted_property); + if (call_info->interface) { + if (pa_streq(call_info->interface, DBUS_INTERFACE_PROPERTIES)) + return find_handler_from_properties_call(call_info); + + else if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->interface))) + return NO_SUCH_INTERFACE; - *iface_entry = NULL; - *method_handler = NULL; + else if ((call_info->method_handler = pa_hashmap_get(call_info->iface_entry->method_handlers, call_info->method))) { + pa_assert_se(call_info->expected_method_sig = pa_hashmap_get(call_info->iface_entry->method_signatures, call_info->method)); - if (dbus_message_has_interface(msg, DBUS_INTERFACE_PROPERTIES)) - return find_handler_from_properties_call(obj_entry, msg, iface_entry, property_handler, attempted_property); + if (!pa_streq(call_info->method_sig, call_info->expected_method_sig)) + return INVALID_METHOD_SIG; - else if ((interface = dbus_message_get_interface(msg))) { - if ((*iface_entry = pa_hashmap_get(obj_entry->interfaces, interface)) && - (*method_handler = pa_hashmap_get((*iface_entry)->method_handlers, dbus_message_get_member(msg)))) return FOUND_METHOD; - else { - pa_log("Message has unknown interface or there's no method handler."); + + } else return NO_SUCH_METHOD; - } } else { /* The method call doesn't contain an interface. */ - if (dbus_message_has_member(msg, "Get") || dbus_message_has_member(msg, "Set") || dbus_message_has_member(msg, "GetAll")) { - if (find_handler_by_method(obj_entry, dbus_message_get_member(msg), iface_entry, method_handler) == FOUND_METHOD) - return FOUND_METHOD; /* The object has a method named Get, Set or GetAll in some other interface than .Properties. */ + if (pa_streq(call_info->method, "Get") || pa_streq(call_info->method, "Set") || pa_streq(call_info->method, "GetAll")) { + if (find_handler_by_method(call_info) == FOUND_METHOD) + /* The object has a method named Get, Set or GetAll in some other interface than .Properties. */ + return FOUND_METHOD; else /* Assume this is a .Properties call. */ - return find_handler_from_properties_call(obj_entry, msg, iface_entry, property_handler, attempted_property); + return find_handler_from_properties_call(call_info); } else /* This is not a .Properties call. */ - return find_handler_by_method(obj_entry, dbus_message_get_member(msg), iface_entry, method_handler); + return find_handler_by_method(call_info); } } static DBusHandlerResult handle_message_cb(DBusConnection *connection, DBusMessage *message, void *user_data) { pa_dbus_protocol *p = user_data; - struct object_entry *obj_entry = NULL; - struct interface_entry *iface_entry = NULL; - pa_dbus_method_handler *method_handler = NULL; - pa_dbus_property_handler *property_handler = NULL; - const char *attempted_property = NULL; - DBusMessage *reply = NULL; + struct call_info call_info; pa_assert(connection); pa_assert(message); @@ -418,57 +505,84 @@ static DBusHandlerResult handle_message_cb(DBusConnection *connection, DBusMessa if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - pa_log("Received method call: destination = %s, name = %s, iface = %s", dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_interface(message)); + pa_log_debug("Received message: destination = %s, interface = %s, member = %s", + dbus_message_get_path(message), + dbus_message_get_interface(message), + dbus_message_get_member(message)); - pa_assert_se((obj_entry = pa_hashmap_get(p->objects, dbus_message_get_path(message)))); + call_info.message = message; + pa_assert_se(call_info.obj_entry = pa_hashmap_get(p->objects, dbus_message_get_path(message))); + call_info.interface = dbus_message_get_interface(message); + pa_assert_se(call_info.method = dbus_message_get_member(message)); + pa_assert_se(call_info.method_sig = dbus_message_get_signature(message)); if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect") || (!dbus_message_get_interface(message) && dbus_message_has_member(message, "Introspect"))) { - pa_assert_se((reply = dbus_message_new_method_return(message))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &obj_entry->introspection, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(connection, reply, NULL)); - - pa_log_debug("%s.Introspect handled.", obj_entry->path); - + pa_dbus_send_basic_value_reply(connection, message, DBUS_TYPE_STRING, &call_info.obj_entry->introspection); goto finish; } - switch (find_handler(obj_entry, message, &iface_entry, &method_handler, &property_handler, &attempted_property)) { - case FOUND_METHOD: - method_handler->receive_cb(connection, message, iface_entry->userdata); - break; - + switch (find_handler(&call_info)) { case FOUND_GET_PROPERTY: - property_handler->get_cb(connection, message, iface_entry->userdata); + call_info.property_handler->get_cb(connection, message, call_info.iface_entry->userdata); break; case FOUND_SET_PROPERTY: - property_handler->set_cb(connection, message, iface_entry->userdata); + call_info.property_handler->set_cb(connection, message, &call_info.variant_iter, call_info.iface_entry->userdata); + break; + + case FOUND_METHOD: + call_info.method_handler->receive_cb(connection, message, call_info.iface_entry->userdata); break; case FOUND_GET_ALL: - if (iface_entry->get_all_properties_cb) - iface_entry->get_all_properties_cb(connection, message, iface_entry->userdata); + if (call_info.iface_entry->get_all_properties_cb) + call_info.iface_entry->get_all_properties_cb(connection, message, call_info.iface_entry->userdata); + else { + DBusMessage *dummy_reply = NULL; + DBusMessageIter msg_iter; + DBusMessageIter dict_iter; + + pa_assert_se(dummy_reply = dbus_message_new_method_return(message)); + dbus_message_iter_init_append(dummy_reply, &msg_iter); + pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter)); + pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter)); + pa_assert_se(dbus_connection_send(connection, dummy_reply, NULL)); + dbus_message_unref(dummy_reply); + } break; case PROPERTY_ACCESS_DENIED: - pa_assert_se((reply = dbus_message_new_error_printf(message, DBUS_ERROR_ACCESS_DENIED, "%s access denied for property %s", dbus_message_get_member(message), attempted_property))); - pa_assert_se(dbus_connection_send(connection, reply, NULL)); + pa_dbus_send_error(connection, message, DBUS_ERROR_ACCESS_DENIED, + "%s access denied for property %s", call_info.method, call_info.property); break; case NO_SUCH_METHOD: - pa_assert_se((reply = dbus_message_new_error_printf(message, DBUS_ERROR_UNKNOWN_METHOD, "%s: No such method", dbus_message_get_member(message)))); - pa_assert_se(dbus_connection_send(connection, reply, NULL)); + pa_dbus_send_error(connection, message, DBUS_ERROR_UNKNOWN_METHOD, "No such method: %s", call_info.method); + break; + + case NO_SUCH_INTERFACE: + pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_INTERFACE, "No such interface: %s", call_info.interface); break; case NO_SUCH_PROPERTY: - pa_assert_se((reply = dbus_message_new_error_printf(message, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "%s: No such property", attempted_property))); - pa_assert_se(dbus_connection_send(connection, reply, NULL)); + pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "No such property: %s", call_info.property); + break; + + case NO_SUCH_PROPERTY_INTERFACE: + pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_INTERFACE, "No such property interface: %s", call_info.property_interface); + break; + + case INVALID_METHOD_SIG: + pa_dbus_send_error(connection, message, DBUS_ERROR_INVALID_ARGS, + "Invalid signature for method %s: '%s'. Expected '%s'.", + call_info.method, call_info.method_sig, call_info.expected_method_sig); break; - case INVALID_MESSAGE_ARGUMENTS: - pa_assert_se((reply = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, "Invalid arguments for %s", dbus_message_get_member(message)))); - pa_assert_se(dbus_connection_send(connection, reply, NULL)); + case INVALID_PROPERTY_SIG: + pa_dbus_send_error(connection, message, DBUS_ERROR_INVALID_ARGS, + "Invalid signature for property %s: '%s'. Expected '%s'.", + call_info.property, call_info.property_sig, call_info.expected_property_sig); break; default: @@ -476,9 +590,6 @@ static DBusHandlerResult handle_message_cb(DBusConnection *connection, DBusMessa } finish: - if (reply) - dbus_message_unref(reply); - return DBUS_HANDLER_RESULT_HANDLED; } @@ -498,7 +609,7 @@ static void register_object(pa_dbus_protocol *p, struct object_entry *obj_entry) pa_assert(p); pa_assert(obj_entry); - while ((conn_entry = pa_hashmap_iterate(p->connections, &state, NULL))) + PA_HASHMAP_FOREACH(conn_entry, p->connections, state) pa_assert_se(dbus_connection_register_object_path(conn_entry->connection, obj_entry->path, &vtable, p)); } @@ -522,6 +633,23 @@ static pa_dbus_arg_info *copy_args(const pa_dbus_arg_info *src, unsigned n) { return dst; } +static void method_handler_free(pa_dbus_method_handler *h) { + unsigned i; + + pa_assert(h); + + pa_xfree((char *) h->method_name); + + for (i = 0; i < h->n_arguments; ++i) { + pa_xfree((char *) h->arguments[i].name); + pa_xfree((char *) h->arguments[i].type); + pa_xfree((char *) h->arguments[i].direction); + } + + pa_xfree((pa_dbus_arg_info *) h->arguments); + pa_xfree(h); +} + static pa_hashmap *create_method_handlers(const pa_dbus_interface_info *info) { pa_hashmap *handlers; unsigned i; @@ -529,7 +657,7 @@ static pa_hashmap *create_method_handlers(const pa_dbus_interface_info *info) { pa_assert(info); pa_assert(info->method_handlers || info->n_method_handlers == 0); - handlers = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); + handlers = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) method_handler_free); for (i = 0; i < info->n_method_handlers; ++i) { pa_dbus_method_handler *h = pa_xnew(pa_dbus_method_handler, 1); @@ -538,12 +666,46 @@ static pa_hashmap *create_method_handlers(const pa_dbus_interface_info *info) { h->n_arguments = info->method_handlers[i].n_arguments; h->receive_cb = info->method_handlers[i].receive_cb; - pa_hashmap_put(handlers, h->method_name, h); + pa_hashmap_put(handlers, (char *) h->method_name, h); } return handlers; } +static pa_hashmap *extract_method_signatures(pa_hashmap *method_handlers) { + pa_hashmap *signatures = NULL; + pa_dbus_method_handler *handler = NULL; + void *state = NULL; + pa_strbuf *sig_buf = NULL; + unsigned i = 0; + + pa_assert(method_handlers); + + signatures = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, pa_xfree); + + PA_HASHMAP_FOREACH(handler, method_handlers, state) { + sig_buf = pa_strbuf_new(); + + for (i = 0; i < handler->n_arguments; ++i) { + if (pa_streq(handler->arguments[i].direction, "in")) + pa_strbuf_puts(sig_buf, handler->arguments[i].type); + } + + pa_hashmap_put(signatures, (char *) handler->method_name, pa_strbuf_tostring_free(sig_buf)); + } + + return signatures; +} + +static void property_handler_free(pa_dbus_property_handler *h) { + pa_assert(h); + + pa_xfree((char *) h->property_name); + pa_xfree((char *) h->type); + + pa_xfree(h); +} + static pa_hashmap *create_property_handlers(const pa_dbus_interface_info *info) { pa_hashmap *handlers; unsigned i = 0; @@ -551,7 +713,7 @@ static pa_hashmap *create_property_handlers(const pa_dbus_interface_info *info) pa_assert(info); pa_assert(info->property_handlers || info->n_property_handlers == 0); - handlers = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); + handlers = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) property_handler_free); for (i = 0; i < info->n_property_handlers; ++i) { pa_dbus_property_handler *h = pa_xnew(pa_dbus_property_handler, 1); @@ -560,7 +722,7 @@ static pa_hashmap *create_property_handlers(const pa_dbus_interface_info *info) h->get_cb = info->property_handlers[i].get_cb; h->set_cb = info->property_handlers[i].set_cb; - pa_hashmap_put(handlers, h->property_name, h); + pa_hashmap_put(handlers, (char *) h->property_name, h); } return handlers; @@ -594,7 +756,7 @@ int pa_dbus_protocol_add_interface(pa_dbus_protocol *p, void *userdata) { struct object_entry *obj_entry; struct interface_entry *iface_entry; - pa_bool_t obj_entry_created = FALSE; + bool obj_entry_created = false; pa_assert(p); pa_assert(path); @@ -611,8 +773,8 @@ int pa_dbus_protocol_add_interface(pa_dbus_protocol *p, obj_entry->interfaces = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); obj_entry->introspection = NULL; - pa_hashmap_put(p->objects, path, obj_entry); - obj_entry_created = TRUE; + pa_hashmap_put(p->objects, obj_entry->path, obj_entry); + obj_entry_created = true; } if (pa_hashmap_get(obj_entry->interfaces, info->name) != NULL) @@ -621,6 +783,7 @@ int pa_dbus_protocol_add_interface(pa_dbus_protocol *p, iface_entry = pa_xnew(struct interface_entry, 1); iface_entry->name = pa_xstrdup(info->name); iface_entry->method_handlers = create_method_handlers(info); + iface_entry->method_signatures = extract_method_signatures(iface_entry->method_handlers); iface_entry->property_handlers = create_property_handlers(info); iface_entry->get_all_properties_cb = info->get_all_properties_cb; iface_entry->signals = copy_signals(info); @@ -633,17 +796,11 @@ int pa_dbus_protocol_add_interface(pa_dbus_protocol *p, if (obj_entry_created) register_object(p, obj_entry); - pa_log("Interface %s added for object %s. GetAll callback? %s", iface_entry->name, obj_entry->path, iface_entry->get_all_properties_cb ? "yes" : "no"); + pa_log_debug("Interface %s added for object %s", iface_entry->name, obj_entry->path); return 0; fail: - if (obj_entry_created) { - pa_hashmap_remove(p->objects, path); - pa_dbus_protocol_unref(p); - pa_xfree(obj_entry); - } - return -1; } @@ -654,38 +811,10 @@ static void unregister_object(pa_dbus_protocol *p, struct object_entry *obj_entr pa_assert(p); pa_assert(obj_entry); - while ((conn_entry = pa_hashmap_iterate(p->connections, &state, NULL))) + PA_HASHMAP_FOREACH(conn_entry, p->connections, state) pa_assert_se(dbus_connection_unregister_object_path(conn_entry->connection, obj_entry->path)); } -static void method_handler_free_cb(void *p, void *userdata) { - pa_dbus_method_handler *h = p; - unsigned i; - - pa_assert(h); - - pa_xfree((char *) h->method_name); - - for (i = 0; i < h->n_arguments; ++i) { - pa_xfree((char *) h->arguments[i].name); - pa_xfree((char *) h->arguments[i].type); - pa_xfree((char *) h->arguments[i].direction); - } - - pa_xfree((pa_dbus_arg_info *) h->arguments); -} - -static void property_handler_free_cb(void *p, void *userdata) { - pa_dbus_property_handler *h = p; - - pa_assert(h); - - pa_xfree((char *) h->property_name); - pa_xfree((char *) h->type); - - pa_xfree(h); -} - int pa_dbus_protocol_remove_interface(pa_dbus_protocol *p, const char* path, const char* interface) { struct object_entry *obj_entry; struct interface_entry *iface_entry; @@ -703,9 +832,12 @@ int pa_dbus_protocol_remove_interface(pa_dbus_protocol *p, const char* path, con update_introspection(obj_entry); + pa_log_debug("Interface %s removed from object %s", iface_entry->name, obj_entry->path); + pa_xfree(iface_entry->name); - pa_hashmap_free(iface_entry->method_handlers, method_handler_free_cb, NULL); - pa_hashmap_free(iface_entry->property_handlers, property_handler_free_cb, NULL); + pa_hashmap_free(iface_entry->method_signatures); + pa_hashmap_free(iface_entry->method_handlers); + pa_hashmap_free(iface_entry->property_handlers); for (i = 0; i < iface_entry->n_signals; ++i) { unsigned j; @@ -729,7 +861,7 @@ int pa_dbus_protocol_remove_interface(pa_dbus_protocol *p, const char* path, con pa_hashmap_remove(p->objects, path); pa_xfree(obj_entry->path); - pa_hashmap_free(obj_entry->interfaces, NULL, NULL); + pa_hashmap_free(obj_entry->interfaces); pa_xfree(obj_entry->introspection); pa_xfree(obj_entry); } @@ -744,10 +876,18 @@ static void register_all_objects(pa_dbus_protocol *p, DBusConnection *conn) { pa_assert(p); pa_assert(conn); - while ((obj_entry = pa_hashmap_iterate(p->objects, &state, NULL))) + PA_HASHMAP_FOREACH(obj_entry, p->objects, state) pa_assert_se(dbus_connection_register_object_path(conn, obj_entry->path, &vtable, p)); } +static void signal_paths_entry_free(struct signal_paths_entry *e) { + pa_assert(e); + + pa_xfree(e->signal); + pa_idxset_free(e->paths, pa_xfree); + pa_xfree(e); +} + int pa_dbus_protocol_register_connection(pa_dbus_protocol *p, DBusConnection *conn, pa_client *client) { struct connection_entry *conn_entry; @@ -763,9 +903,10 @@ int pa_dbus_protocol_register_connection(pa_dbus_protocol *p, DBusConnection *co conn_entry = pa_xnew(struct connection_entry, 1); conn_entry->connection = dbus_connection_ref(conn); conn_entry->client = client; - conn_entry->listening_for_all_signals = FALSE; + conn_entry->listening_for_all_signals = false; conn_entry->all_signals_objects = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); - conn_entry->listening_signals = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); + conn_entry->listening_signals = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, + (pa_free_cb_t) signal_paths_entry_free); pa_hashmap_put(p->connections, conn, conn_entry); @@ -779,26 +920,24 @@ static void unregister_all_objects(pa_dbus_protocol *p, DBusConnection *conn) { pa_assert(p); pa_assert(conn); - while ((obj_entry = pa_hashmap_iterate(p->objects, &state, NULL))) + PA_HASHMAP_FOREACH(obj_entry, p->objects, state) pa_assert_se(dbus_connection_unregister_object_path(conn, obj_entry->path)); } -static void free_listened_object_name_cb(void *p, void *userdata) { - pa_assert(p); - - pa_xfree(p); -} +static struct signal_paths_entry *signal_paths_entry_new(const char *signal_name) { + struct signal_paths_entry *e = NULL; -static void free_listening_signals_idxset_cb(void *p, void *userdata) { - pa_idxset *set = p; + pa_assert(signal_name); - pa_assert(set); + e = pa_xnew0(struct signal_paths_entry, 1); + e->signal = pa_xstrdup(signal_name); + e->paths = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); - pa_idxset_free(set, free_listened_object_name_cb, NULL); + return e; } int pa_dbus_protocol_unregister_connection(pa_dbus_protocol *p, DBusConnection *conn) { - struct connection_entry *conn_entry; + struct connection_entry *conn_entry = NULL; pa_assert(p); pa_assert(conn); @@ -809,8 +948,8 @@ int pa_dbus_protocol_unregister_connection(pa_dbus_protocol *p, DBusConnection * unregister_all_objects(p, conn); dbus_connection_unref(conn_entry->connection); - pa_idxset_free(conn_entry->all_signals_objects, free_listened_object_name_cb, NULL); - pa_hashmap_free(conn_entry->listening_signals, free_listening_signals_idxset_cb, NULL); + pa_idxset_free(conn_entry->all_signals_objects, pa_xfree); + pa_hashmap_free(conn_entry->listening_signals); pa_xfree(conn_entry); return 0; @@ -828,11 +967,15 @@ pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn return conn_entry->client; } -void pa_dbus_protocol_add_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal, char **objects, unsigned n_objects) { - struct connection_entry *conn_entry; - pa_idxset *object_set; - char *object_path; - unsigned i; +void pa_dbus_protocol_add_signal_listener( + pa_dbus_protocol *p, + DBusConnection *conn, + const char *signal_name, + char **objects, + unsigned n_objects) { + struct connection_entry *conn_entry = NULL; + struct signal_paths_entry *signal_paths_entry = NULL; + unsigned i = 0; pa_assert(p); pa_assert(conn); @@ -842,91 +985,87 @@ void pa_dbus_protocol_add_signal_listener(pa_dbus_protocol *p, DBusConnection *c /* all_signals_objects will either be emptied or replaced with new objects, * so we empty it here unconditionally. If listening_for_all_signals is - * currently FALSE, the idxset is empty already. */ - while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL))) - pa_xfree(object_path); + * currently false, the idxset is empty already so this does nothing. */ + pa_idxset_remove_all(conn_entry->all_signals_objects, pa_xfree); - if (signal) { - conn_entry->listening_for_all_signals = FALSE; + if (signal_name) { + conn_entry->listening_for_all_signals = false; - /* Replace the old object list with a new one. */ - if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal))) - pa_idxset_free(object_set, free_listened_object_name_cb, NULL); - object_set = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); + /* Replace the old signal paths entry for this signal with a new + * one. */ + pa_hashmap_remove_and_free(conn_entry->listening_signals, signal_name); + signal_paths_entry = signal_paths_entry_new(signal_name); for (i = 0; i < n_objects; ++i) - pa_idxset_put(object_set, pa_xstrdup(objects[i]), NULL); + pa_idxset_put(signal_paths_entry->paths, pa_xstrdup(objects[i]), NULL); + + pa_hashmap_put(conn_entry->listening_signals, signal_paths_entry->signal, signal_paths_entry); } else { - conn_entry->listening_for_all_signals = TRUE; + conn_entry->listening_for_all_signals = true; /* We're not interested in individual signals anymore, so let's empty * listening_signals. */ - while ((object_set = pa_hashmap_steal_first(conn_entry->listening_signals))) - pa_idxset_free(object_set, free_listened_object_name_cb, NULL); + pa_hashmap_remove_all(conn_entry->listening_signals); for (i = 0; i < n_objects; ++i) pa_idxset_put(conn_entry->all_signals_objects, pa_xstrdup(objects[i]), NULL); } } -void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal) { - struct connection_entry *conn_entry; - pa_idxset *object_set; +void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal_name) { + struct connection_entry *conn_entry = NULL; + struct signal_paths_entry *signal_paths_entry = NULL; pa_assert(p); pa_assert(conn); pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn))); - if (signal) { - if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal))) - pa_idxset_free(object_set, free_listened_object_name_cb, NULL); + if (signal_name) { + if ((signal_paths_entry = pa_hashmap_remove(conn_entry->listening_signals, signal_name))) + signal_paths_entry_free(signal_paths_entry); } else { - char *object_path; - - conn_entry->listening_for_all_signals = FALSE; - - while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL))) - pa_xfree(object_path); - - while ((object_set = pa_hashmap_steal_first(conn_entry->listening_signals))) - pa_idxset_free(object_set, free_listened_object_name_cb, NULL); + conn_entry->listening_for_all_signals = false; + pa_idxset_remove_all(conn_entry->all_signals_objects, pa_xfree); + pa_hashmap_remove_all(conn_entry->listening_signals); } } -void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal) { +void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal_msg) { struct connection_entry *conn_entry; + struct signal_paths_entry *signal_paths_entry; void *state = NULL; - pa_idxset *object_set; DBusMessage *signal_copy; + char *signal_string; pa_assert(p); - pa_assert(signal); - pa_assert(dbus_message_get_type(signal) == DBUS_MESSAGE_TYPE_SIGNAL); - - /* XXX: We have to do some linear searching to find connections that want - * to receive the signal. This shouldn't be very significant performance - * problem, and adding an (object path, signal name) -> connection mapping - * would be likely to create substantial complexity. */ + pa_assert(signal_msg); + pa_assert(dbus_message_get_type(signal_msg) == DBUS_MESSAGE_TYPE_SIGNAL); + pa_assert(dbus_message_get_path(signal_msg)); + pa_assert(dbus_message_get_interface(signal_msg)); + pa_assert(dbus_message_get_member(signal_msg)); - while ((conn_entry = pa_hashmap_iterate(p->connections, &state, NULL))) { + signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal_msg), dbus_message_get_member(signal_msg)); + PA_HASHMAP_FOREACH(conn_entry, p->connections, state) { if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */ - && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal), NULL) + && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal_msg), NULL) || pa_idxset_isempty(conn_entry->all_signals_objects))) || (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */ - && (object_set = pa_hashmap_get(conn_entry->listening_signals, signal)) - && (pa_idxset_get_by_data(object_set, dbus_message_get_path(signal), NULL) - || pa_idxset_isempty(object_set)))) { + && (signal_paths_entry = pa_hashmap_get(conn_entry->listening_signals, signal_string)) + && (pa_idxset_get_by_data(signal_paths_entry->paths, dbus_message_get_path(signal_msg), NULL) + || pa_idxset_isempty(signal_paths_entry->paths)))) { - pa_assert_se(signal_copy = dbus_message_copy(signal)); + pa_assert_se(signal_copy = dbus_message_copy(signal_msg)); pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL)); dbus_message_unref(signal_copy); } } + + pa_xfree(signal_string); } const char **pa_dbus_protocol_get_extensions(pa_dbus_protocol *p, unsigned *n) { @@ -945,10 +1084,8 @@ const char **pa_dbus_protocol_get_extensions(pa_dbus_protocol *p, unsigned *n) { extensions = pa_xnew(const char *, *n); - while ((ext_name = pa_idxset_iterate(p->extensions, &state, NULL))) { - extensions[i] = ext_name; - ++i; - } + while ((ext_name = pa_idxset_iterate(p->extensions, &state, NULL))) + extensions[i++] = ext_name; return extensions; } @@ -987,7 +1124,12 @@ int pa_dbus_protocol_unregister_extension(pa_dbus_protocol *p, const char *name) return 0; } -pa_hook_slot *pa_dbus_protocol_hook_connect(pa_dbus_protocol *p, pa_dbus_protocol_hook_t hook, pa_hook_priority_t prio, pa_hook_cb_t cb, void *data) { +pa_hook_slot *pa_dbus_protocol_hook_connect( + pa_dbus_protocol *p, + pa_dbus_protocol_hook_t hook, + pa_hook_priority_t prio, + pa_hook_cb_t cb, + void *data) { pa_assert(p); pa_assert(hook < PA_DBUS_PROTOCOL_HOOK_MAX); pa_assert(cb);