From 0e096632c53b746b9f4b4c0249d9e5a18c1c543d Mon Sep 17 00:00:00 2001 From: Tanu Kaskinen Date: Sun, 30 Aug 2009 19:52:22 +0300 Subject: dbus: Do message argument type checking early, centrally. --- src/modules/dbus/iface-card.c | 19 +- src/modules/dbus/iface-client.c | 17 +- src/modules/dbus/iface-core.c | 247 ++++++++++---------------- src/modules/dbus/iface-device.c | 56 +++--- src/modules/dbus/iface-sample.c | 24 +-- src/modules/dbus/iface-stream.c | 33 ++-- src/modules/module-stream-restore.c | 120 ++++--------- src/pulsecore/dbus-util.c | 193 +++------------------ src/pulsecore/dbus-util.h | 42 +++-- src/pulsecore/protocol-dbus.c | 336 +++++++++++++++++++++++------------- src/pulsecore/protocol-dbus.h | 26 ++- 11 files changed, 471 insertions(+), 642 deletions(-) diff --git a/src/modules/dbus/iface-card.c b/src/modules/dbus/iface-card.c index 7e37f8bb..1714df36 100644 --- a/src/modules/dbus/iface-card.c +++ b/src/modules/dbus/iface-card.c @@ -43,7 +43,7 @@ static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userd static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_profiles(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_active_profile(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -322,7 +322,7 @@ static void handle_get_active_profile(DBusConnection *conn, DBusMessage *msg, vo pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &active_profile); } -static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_card *c = userdata; const char *new_active_path; pa_dbusiface_card_profile *new_active; @@ -330,11 +330,9 @@ static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, vo pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &new_active_path) < 0) - return; - if (!c->active_profile) { pa_assert(pa_hashmap_isempty(c->profiles)); @@ -344,6 +342,8 @@ static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, vo return; } + dbus_message_iter_get_basic(iter, &new_active_path); + if (!(new_active = pa_hashmap_get(c->profiles, new_active_path))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such profile.", new_active_path); return; @@ -430,7 +430,6 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat static void handle_get_profile_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_card *c = userdata; - DBusError error; const char *profile_name = NULL; pa_dbusiface_card_profile *profile = NULL; const char *profile_path = NULL; @@ -439,13 +438,7 @@ static void handle_get_profile_by_name(DBusConnection *conn, DBusMessage *msg, v pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &profile_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &profile_name, DBUS_TYPE_INVALID)); if (!(profile = pa_hashmap_get(c->profiles, profile_name))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such profile on card %s.", profile_name, c->card->name); diff --git a/src/modules/dbus/iface-client.c b/src/modules/dbus/iface-client.c index a68259a9..54550d2c 100644 --- a/src/modules/dbus/iface-client.c +++ b/src/modules/dbus/iface-client.c @@ -339,16 +339,12 @@ static void handle_update_properties(DBusConnection *conn, DBusMessage *msg, voi return; } - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter))) return; - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &update_mode) < 0) - goto finish; + dbus_message_iter_get_basic(&msg_iter, &update_mode); if (!(update_mode == PA_UPDATE_SET || update_mode == PA_UPDATE_MERGE || update_mode == PA_UPDATE_REPLACE)) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid update mode: %u", update_mode); @@ -368,7 +364,6 @@ static void handle_remove_properties(DBusConnection *conn, DBusMessage *msg, voi pa_dbusiface_client *c = userdata; char **keys = NULL; int n_keys = 0; - DBusError error; pa_bool_t changed = FALSE; int i = 0; @@ -376,18 +371,12 @@ static void handle_remove_properties(DBusConnection *conn, DBusMessage *msg, voi pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - if (pa_dbus_protocol_get_client(c->dbus_protocol, conn) != c->client) { pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "Client tried to modify the property list of another client."); return; } - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &keys, &n_keys, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &keys, &n_keys, DBUS_TYPE_INVALID)); for (i = 0; i < n_keys; ++i) changed |= pa_proplist_unset(c->client->proplist, keys[i]) >= 0; diff --git a/src/modules/dbus/iface-core.c b/src/modules/dbus/iface-core.c index c54a3b7a..0507ac9c 100644 --- a/src/modules/dbus/iface-core.c +++ b/src/modules/dbus/iface-core.c @@ -57,18 +57,18 @@ static void handle_get_is_local(DBusConnection *conn, DBusMessage *msg, void *us static void handle_get_username(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_hostname(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -428,30 +428,32 @@ static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, pa_xfree(default_channels); } -static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_core *c = userdata; + DBusMessageIter array_iter; pa_channel_map new_channel_map; - dbus_uint32_t *default_channels; - unsigned n_channels; + const dbus_uint32_t *default_channels; + int n_channels; unsigned i; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); pa_channel_map_init(&new_channel_map); - if (pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_channels, &n_channels) < 0) - return; + dbus_message_iter_recurse(iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &default_channels, &n_channels); if (n_channels <= 0) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel array."); return; } - if (n_channels > PA_CHANNELS_MAX) { + if (n_channels > (int) PA_CHANNELS_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Too many channels: %u. The maximum number of channels is %u.", n_channels, PA_CHANNELS_MAX); + "Too many channels: %i. The maximum number of channels is %u.", n_channels, PA_CHANNELS_MAX); return; } @@ -485,16 +487,16 @@ static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage * pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_format); } -static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_core *c = userdata; dbus_uint32_t default_sample_format; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_format) < 0) - return; + dbus_message_iter_get_basic(iter, &default_sample_format); if (default_sample_format >= PA_SAMPLE_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format."); @@ -519,16 +521,16 @@ static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *ms pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate); } -static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_core *c = userdata; dbus_uint32_t default_sample_rate; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate) < 0) - return; + dbus_message_iter_get_basic(iter, &default_sample_rate); if (default_sample_rate <= 0 || default_sample_rate > PA_RATE_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate."); @@ -639,13 +641,14 @@ static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, voi pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path); } -static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_core *c = userdata; pa_dbusiface_device *fallback_sink; const char *object_path; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); if (!c->fallback_sink) { @@ -654,8 +657,7 @@ static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, voi return; } - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0) - return; + dbus_message_iter_get_basic(iter, &object_path); if (!(fallback_sink = pa_hashmap_get(c->sinks_by_path, object_path))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", object_path); @@ -727,13 +729,14 @@ static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, v pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path); } -static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_core *c = userdata; pa_dbusiface_device *fallback_source; const char *object_path; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(c); if (!c->fallback_source) { @@ -742,8 +745,7 @@ static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, v return; } - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0) - return; + dbus_message_iter_get_basic(iter, &object_path); if (!(fallback_source = pa_hashmap_get(c->sources_by_path, object_path))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", object_path); @@ -1117,19 +1119,12 @@ static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void pa_card *card; pa_dbusiface_card *dbus_card; const char *object_path; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &card_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &card_name, DBUS_TYPE_INVALID)); if (!(card = pa_namereg_get(c->core, card_name, PA_NAMEREG_CARD))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such card."); @@ -1149,19 +1144,12 @@ static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void pa_sink *sink; pa_dbusiface_device *dbus_sink; const char *object_path; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sink_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &sink_name, DBUS_TYPE_INVALID)); if (!(sink = pa_namereg_get(c->core, sink_name, PA_NAMEREG_SINK))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", sink_name); @@ -1181,19 +1169,12 @@ static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, vo pa_source *source; pa_dbusiface_device *dbus_source; const char *object_path; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &source_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &source_name, DBUS_TYPE_INVALID)); if (!(source = pa_namereg_get(c->core, source_name, PA_NAMEREG_SOURCE))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", source_name); @@ -1213,19 +1194,12 @@ static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, vo pa_scache_entry *sample; pa_dbusiface_sample *dbus_sample; const char *object_path; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sample_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &sample_name, DBUS_TYPE_INVALID)); if (!(sample = pa_namereg_get(c->core, sample_name, PA_NAMEREG_SAMPLE))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sample."); @@ -1242,17 +1216,18 @@ static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, vo static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_core *c = userdata; DBusMessageIter msg_iter; + DBusMessageIter array_iter; const char *name; dbus_uint32_t sample_format; dbus_uint32_t sample_rate; const dbus_uint32_t *channels; - unsigned n_channels; + int n_channels; const dbus_uint32_t *default_volume; - unsigned n_volume_entries; + int n_volume_entries; pa_proplist *property_list; const uint8_t *data; - unsigned data_length; - unsigned i; + int data_length; + int i; pa_sample_spec ss; pa_channel_map map; pa_memchunk chunk; @@ -1267,31 +1242,29 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u chunk.memblock = NULL; - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } - - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0) - return; + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &name); - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_format) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &sample_format); - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_rate) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &sample_rate); - if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &channels, &n_channels) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_recurse(&msg_iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &channels, &n_channels); - if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &default_volume, &n_volume_entries) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_recurse(&msg_iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &default_volume, &n_volume_entries); + pa_assert_se(dbus_message_iter_next(&msg_iter)); if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter))) return; - if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_BYTE, &data, &data_length) < 0) - goto finish; + dbus_message_iter_recurse(&msg_iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &data, &data_length); if (sample_format >= PA_SAMPLE_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format."); @@ -1303,14 +1276,14 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u goto finish; } - if (n_channels == 0) { + if (n_channels <= 0) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel map."); goto finish; } - if (n_channels > PA_CHANNELS_MAX) { + if (n_channels > (int) PA_CHANNELS_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Too many channels: %u. The maximum is %u.", n_channels, PA_CHANNELS_MAX); + "Too many channels: %i. The maximum is %u.", n_channels, PA_CHANNELS_MAX); goto finish; } @@ -1323,13 +1296,14 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u if (n_volume_entries != 0 && n_volume_entries != n_channels) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "The channels and default_volume arguments have different number of elements."); + "The channels and default_volume arguments have different number of elements (%i and %i, resp).", + n_channels, n_volume_entries); goto finish; } for (i = 0; i < n_volume_entries; ++i) { if (default_volume[i] > PA_VOLUME_MAX) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume."); + pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume: %u.", default_volume[i]); goto finish; } } @@ -1340,7 +1314,9 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u } if (data_length > PA_SCACHE_ENTRY_SIZE_MAX) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too big sample."); + pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, + "Too big sample: %i bytes. The maximum sample length is %u bytes.", + data_length, PA_SCACHE_ENTRY_SIZE_MAX); goto finish; } @@ -1348,9 +1324,13 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u ss.rate = sample_rate; ss.channels = n_channels; + pa_assert(pa_sample_spec_valid(&ss)); + if (!pa_frame_aligned(data_length, &ss)) { + char buf[PA_SAMPLE_SPEC_SNPRINT_MAX]; pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "The sample length in bytes doesn't align with the sample format and channels."); + "The sample length (%i bytes) doesn't align with the sample format and channels (%s).", + data_length, pa_sample_spec_snprint(buf, sizeof(buf), &ss)); goto finish; } @@ -1414,15 +1394,15 @@ static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *use DBusMessageIter msg_iter; DBusMessageIter dict_iter; DBusMessageIter dict_entry_iter; - char *name; - const char *key; - const char *value; - char *escaped_value; + char *name = NULL; + const char *key = NULL; + const char *value = NULL; + char *escaped_value = NULL; pa_strbuf *arg_buffer = NULL; - pa_module *module; - pa_dbusiface_module *dbus_module; - const char *object_path; - int arg_type; + char *arg_string = NULL; + pa_module *module = NULL; + pa_dbusiface_module *dbus_module = NULL; + const char *object_path = NULL; pa_assert(conn); pa_assert(msg); @@ -1433,35 +1413,12 @@ static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *use return; } - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } - - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0) - return; - - arg_type = dbus_message_iter_get_arg_type(&msg_iter); - if (arg_type != DBUS_TYPE_ARRAY) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Too few arguments. A dictionary from strings to strings was expected."); - else - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Wrong argument type: '%c'. An dictionary from strings to strings was expected.", - (char) arg_type); - return; - } - - arg_type = dbus_message_iter_get_element_type(&msg_iter); - if (arg_type != DBUS_TYPE_DICT_ENTRY) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Wrong array element type: '%c'. A dict entry (string to string) was expected.", (char) arg_type); - return; - } + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &name); arg_buffer = pa_strbuf_new(); + pa_assert_se(dbus_message_iter_next(&msg_iter)); dbus_message_iter_recurse(&msg_iter, &dict_iter); while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) { @@ -1470,41 +1427,26 @@ static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *use dbus_message_iter_recurse(&dict_iter, &dict_entry_iter); - arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter); - if (arg_type != DBUS_TYPE_STRING) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Wrong dict key type: '%c'. A string was expected.", (char) arg_type); - goto finish; - } - dbus_message_iter_get_basic(&dict_entry_iter, &key); - dbus_message_iter_next(&dict_entry_iter); if (strlen(key) <= 0 || !pa_ascii_valid(key) || contains_space(key)) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid module argument name: %s", key); goto finish; } - arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter); - if (arg_type != DBUS_TYPE_STRING) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Dict value missing."); - else - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Wrong dict value type: '%c'. A string was expected.", (char) arg_type); - goto finish; - } - + pa_assert_se(dbus_message_iter_next(&dict_entry_iter)); dbus_message_iter_get_basic(&dict_entry_iter, &value); - dbus_message_iter_next(&dict_iter); - escaped_value = pa_escape(value, "\""); pa_strbuf_printf(arg_buffer, "%s=\"%s\"", key, escaped_value); pa_xfree(escaped_value); + + dbus_message_iter_next(&dict_iter); } - if (!(module = pa_module_load(c->core, name, pa_strbuf_tostring(arg_buffer)))) { + arg_string = pa_strbuf_tostring(arg_buffer); + + if (!(module = pa_module_load(c->core, name, arg_string))) { pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Failed to load module."); goto finish; } @@ -1519,6 +1461,8 @@ static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *use finish: if (arg_buffer) pa_strbuf_free(arg_buffer); + + pa_xfree(arg_string); } static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata) { @@ -1543,47 +1487,32 @@ static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, voi const char *signal; char **objects = NULL; int n_objects; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, - DBUS_TYPE_STRING, &signal, - DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects, - DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - goto finish; - } + pa_assert_se(dbus_message_get_args(msg, NULL, + DBUS_TYPE_STRING, &signal, + DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects, + DBUS_TYPE_INVALID)); pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL, objects, n_objects); pa_dbus_send_empty_reply(conn, msg); -finish: dbus_free_string_array(objects); } static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_core *c = userdata; const char *signal; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(c); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID)); pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL); diff --git a/src/modules/dbus/iface-device.c b/src/modules/dbus/iface-device.c index 8f719bce..27525113 100644 --- a/src/modules/dbus/iface-device.c +++ b/src/modules/dbus/iface-device.c @@ -43,13 +43,13 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_channels(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_has_flat_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_has_convertible_to_decibel_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_base_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_volume_steps(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_has_hardware_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_has_hardware_mute(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_configured_latency(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -60,7 +60,7 @@ static void handle_get_is_network_device(DBusConnection *conn, DBusMessage *msg, static void handle_get_state(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_ports(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_active_port(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -408,16 +408,18 @@ static void handle_get_volume(DBusConnection *conn, DBusMessage *msg, void *user pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, volume, d->volume.channels); } -static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_device *d = userdata; - unsigned device_channels = 0; + DBusMessageIter array_iter; + int device_channels = 0; dbus_uint32_t *volume = NULL; - unsigned n_volume_entries = 0; + int n_volume_entries = 0; pa_cvolume new_vol; - unsigned i = 0; + int i = 0; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(d); pa_cvolume_init(&new_vol); @@ -426,12 +428,12 @@ static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *user new_vol.channels = device_channels; - if (pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &volume, &n_volume_entries) < 0) - return; + dbus_message_iter_recurse(iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &volume, &n_volume_entries); if (n_volume_entries != device_channels) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, - "Expected %u volume entries, got %u.", device_channels, n_volume_entries); + "Expected %u volume entries, got %i.", device_channels, n_volume_entries); return; } @@ -515,16 +517,16 @@ static void handle_get_is_muted(DBusConnection *conn, DBusMessage *msg, void *us pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &d->is_muted); } -static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_device *d = userdata; dbus_bool_t is_muted = FALSE; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(d); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_BOOLEAN, &is_muted) < 0) - return; + dbus_message_iter_get_basic(iter, &is_muted); if (d->type == DEVICE_TYPE_SINK) pa_sink_set_mute(d->sink, is_muted, TRUE); @@ -722,7 +724,7 @@ static void handle_get_active_port(DBusConnection *conn, DBusMessage *msg, void pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &active_port); } -static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_device *d = userdata; const char *new_active_path; pa_dbusiface_device_port *new_active; @@ -730,11 +732,9 @@ static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, void pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(d); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &new_active_path) < 0) - return; - if (!d->active_port) { pa_assert(pa_hashmap_isempty(d->ports)); @@ -747,8 +747,10 @@ static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, void return; } + dbus_message_iter_get_basic(iter, &new_active_path); + if (!(new_active = pa_hashmap_get(d->ports, new_active_path))) { - pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such port.", new_active_path); + pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such port: %s", new_active_path); return; } @@ -923,19 +925,12 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat static void handle_suspend(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_device *d = userdata; dbus_bool_t suspend = FALSE; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(d); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_BOOLEAN, &suspend, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &suspend, DBUS_TYPE_INVALID)); if ((d->type == DEVICE_TYPE_SINK) && (pa_sink_suspend(d->sink, suspend, PA_SUSPEND_USER) < 0)) { pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Internal error in PulseAudio: pa_sink_suspend() failed."); @@ -950,7 +945,6 @@ static void handle_suspend(DBusConnection *conn, DBusMessage *msg, void *userdat static void handle_get_port_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_device *d = userdata; - DBusError error; const char *port_name = NULL; pa_dbusiface_device_port *port = NULL; const char *port_path = NULL; @@ -959,13 +953,7 @@ static void handle_get_port_by_name(DBusConnection *conn, DBusMessage *msg, void pa_assert(msg); pa_assert(d); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &port_name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &port_name, DBUS_TYPE_INVALID)); if (!(port = pa_hashmap_get(d->ports, port_name))) { if (d->type == DEVICE_TYPE_SINK) diff --git a/src/modules/dbus/iface-sample.c b/src/modules/dbus/iface-sample.c index 7147be14..b0542a60 100644 --- a/src/modules/dbus/iface-sample.c +++ b/src/modules/dbus/iface-sample.c @@ -359,14 +359,10 @@ static void handle_play(DBusConnection *conn, DBusMessage *msg, void *userdata) pa_assert(msg); pa_assert(s); - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } - - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &volume) < 0) - return; + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &volume); + pa_assert_se(dbus_message_iter_next(&msg_iter)); if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter))) return; @@ -405,17 +401,13 @@ static void handle_play_to_sink(DBusConnection *conn, DBusMessage *msg, void *us pa_assert(msg); pa_assert(s); - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } - - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_OBJECT_PATH, &sink_path) < 0) - return; + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &sink_path); - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &volume) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &volume); + pa_assert_se(dbus_message_iter_next(&msg_iter)); if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter))) return; diff --git a/src/modules/dbus/iface-stream.c b/src/modules/dbus/iface-stream.c index 183625ba..a5f9bb51 100644 --- a/src/modules/dbus/iface-stream.c +++ b/src/modules/dbus/iface-stream.c @@ -70,9 +70,9 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_channels(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_get_buffer_latency(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_device_latency(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_get_resample_method(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -343,16 +343,18 @@ static void handle_get_volume(DBusConnection *conn, DBusMessage *msg, void *user pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, volume, s->volume.channels); } -static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_stream *s = userdata; - unsigned stream_channels = 0; + DBusMessageIter array_iter; + int stream_channels = 0; dbus_uint32_t *volume = NULL; - unsigned n_volume_entries = 0; + int n_volume_entries = 0; pa_cvolume new_vol; - unsigned i = 0; + int i = 0; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(s); if (s->type == STREAM_TYPE_RECORD) { @@ -366,8 +368,8 @@ static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, void *user new_vol.channels = stream_channels; - if (pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &volume, &n_volume_entries) < 0) - return; + dbus_message_iter_recurse(iter, &array_iter); + dbus_message_iter_get_fixed_array(&array_iter, &volume, &n_volume_entries); if (n_volume_entries != stream_channels) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, @@ -403,16 +405,16 @@ static void handle_get_is_muted(DBusConnection *conn, DBusMessage *msg, void *us pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &s->is_muted); } -static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { pa_dbusiface_stream *s = userdata; dbus_bool_t is_muted = FALSE; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(s); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_BOOLEAN, &is_muted) < 0) - return; + dbus_message_iter_get_basic(iter, &is_muted); if (s->type == STREAM_TYPE_RECORD) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "Record streams don't have mute."); @@ -575,19 +577,12 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat static void handle_move(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_dbusiface_stream *s = userdata; const char *device = NULL; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(s); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &device, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &device, DBUS_TYPE_INVALID)); if (s->type == STREAM_TYPE_PLAYBACK) { pa_sink *sink = pa_dbusiface_core_get_sink(s->core, device); diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index 076b3918..d45cf792 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -167,11 +167,11 @@ static void handle_get_entry_by_name(DBusConnection *conn, DBusMessage *msg, voi static void handle_entry_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_entry_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata); static void handle_entry_get_device(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_entry_get_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_entry_get_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); -static void handle_entry_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata); +static void handle_entry_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); static void handle_entry_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata); @@ -326,18 +326,20 @@ static void dbus_entry_free(struct dbus_entry *de) { /* Reads an array [(UInt32, UInt32)] from the iterator. The struct items are * are a channel position and a volume value, respectively. The result is - * stored in the map and vol arguments. If the volume can't be read from the - * iterator, an error reply is sent and a negative number is returned. In case - * of a failure we make no guarantees about the state of map and vol. In case - * of an empty array the channels field of both map and vol are set to 0. */ + * stored in the map and vol arguments. The iterator must point to a "a(uu)" + * element. If the data is invalid, an error reply is sent and a negative + * number is returned. In case of a failure we make no guarantees about the + * state of map and vol. In case of an empty array the channels field of both + * map and vol are set to 0. This function calls dbus_message_iter_next(iter) + * before returning. */ static int get_volume_arg(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, pa_channel_map *map, pa_cvolume *vol) { DBusMessageIter array_iter; DBusMessageIter struct_iter; - int arg_type; pa_assert(conn); pa_assert(msg); pa_assert(iter); + pa_assert(pa_streq(dbus_message_iter_get_signature(iter), "a(uu)")); pa_assert(map); pa_assert(vol); @@ -347,21 +349,6 @@ static int get_volume_arg(DBusConnection *conn, DBusMessage *msg, DBusMessageIte map->channels = 0; vol->channels = 0; - arg_type = dbus_message_iter_get_arg_type(iter); - if (arg_type != DBUS_TYPE_ARRAY) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments. An array was expected."); - else - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong argument type: '%c'. An array was expected.", (char) arg_type); - return -1; - } - - arg_type = dbus_message_iter_get_element_type(iter); - if (arg_type != DBUS_TYPE_STRUCT) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong array element type: '%c'. A struct was expected.", (char) arg_type); - return -1; - } - dbus_message_iter_recurse(iter, &array_iter); while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID) { @@ -370,29 +357,14 @@ static int get_volume_arg(DBusConnection *conn, DBusMessage *msg, DBusMessageIte dbus_message_iter_recurse(&array_iter, &struct_iter); - arg_type = dbus_message_iter_get_arg_type(&struct_iter); - if (arg_type != DBUS_TYPE_UINT32) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong channel position type: '%c'. An unsigned 32-bit integer was expected.", (char) arg_type); - return -1; - } - dbus_message_iter_get_basic(&struct_iter, &chan_pos); - dbus_message_iter_next(&struct_iter); if (chan_pos >= PA_CHANNEL_POSITION_MAX) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position: %u", chan_pos); return -1; } - arg_type = dbus_message_iter_get_arg_type(&struct_iter); - if (arg_type != DBUS_TYPE_UINT32) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Channel volume missing."); - else - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong volume value type: '%c'. An unsigned 32-bit integer was expected.", (char) arg_type); - return -1; - } - + pa_assert_se(dbus_message_iter_next(&struct_iter)); dbus_message_iter_get_basic(&struct_iter, &chan_vol); if (chan_vol > PA_VOLUME_MAX) { @@ -612,40 +584,35 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat static void handle_add_entry(DBusConnection *conn, DBusMessage *msg, void *userdata) { struct userdata *u = userdata; DBusMessageIter msg_iter; - const char *name; - const char *device; + const char *name = NULL; + const char *device = NULL; pa_channel_map map; pa_cvolume vol; - dbus_bool_t muted; - dbus_bool_t apply_immediately; + dbus_bool_t muted = FALSE; + dbus_bool_t apply_immediately = FALSE; pa_datum key; pa_datum value; - struct dbus_entry *dbus_entry; - struct entry *e; + struct dbus_entry *dbus_entry = NULL; + struct entry *e = NULL; pa_assert(conn); pa_assert(msg); pa_assert(u); - if (!dbus_message_iter_init(msg, &msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } + pa_assert_se(dbus_message_iter_init(msg, &msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &name); - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0) - return; - - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &device) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &device); + pa_assert_se(dbus_message_iter_next(&msg_iter)); if (get_volume_arg(conn, msg, &msg_iter, &map, &vol) < 0) return; - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_BOOLEAN, &muted) < 0) - return; + dbus_message_iter_get_basic(&msg_iter, &muted); - if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_BOOLEAN, &apply_immediately) < 0) - return; + pa_assert_se(dbus_message_iter_next(&msg_iter)); + dbus_message_iter_get_basic(&msg_iter, &apply_immediately); if (!*name) { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "An empty string was given as the entry name."); @@ -714,19 +681,12 @@ static void handle_get_entry_by_name(DBusConnection *conn, DBusMessage *msg, voi struct userdata *u = userdata; const char *name; struct dbus_entry *de; - DBusError error; pa_assert(conn); pa_assert(msg); pa_assert(u); - dbus_error_init(&error); - - if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - return; - } + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)); if (!(de = pa_hashmap_get(u->dbus_entries, name))) { pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such stream restore entry."); @@ -774,7 +734,7 @@ static void handle_entry_get_device(DBusConnection *conn, DBusMessage *msg, void pa_xfree(e); } -static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { struct dbus_entry *de = userdata; const char *device; struct entry *e; @@ -782,10 +742,10 @@ static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, void pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(de); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_STRING, &device) < 0) - return; + dbus_message_iter_get_basic(iter, &device); pa_assert_se(e = read_entry(de->userdata, de->entry_name)); @@ -835,25 +795,19 @@ static void handle_entry_get_volume(DBusConnection *conn, DBusMessage *msg, void pa_xfree(e); } -static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { struct dbus_entry *de = userdata; - DBusMessageIter msg_iter; pa_channel_map map; pa_cvolume vol; - struct entry *e; - pa_bool_t updated; + struct entry *e = NULL; + pa_bool_t updated = FALSE; pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(de); - /* Skip the interface and property name arguments. */ - if (!dbus_message_iter_init(msg, &msg_iter) || !dbus_message_iter_next(&msg_iter) || !dbus_message_iter_next(&msg_iter)) { - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return; - } - - if (get_volume_arg(conn, msg, &msg_iter, &map, &vol) < 0) + if (get_volume_arg(conn, msg, iter, &map, &vol) < 0) return; pa_assert_se(e = read_entry(de->userdata, de->entry_name)); @@ -901,7 +855,7 @@ static void handle_entry_get_is_muted(DBusConnection *conn, DBusMessage *msg, vo pa_xfree(e); } -static void handle_entry_set_is_muted(DBusConnection *conn, DBusMessage *msg, void *userdata) { +static void handle_entry_set_is_muted(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) { struct dbus_entry *de = userdata; pa_bool_t muted; struct entry *e; @@ -909,10 +863,10 @@ static void handle_entry_set_is_muted(DBusConnection *conn, DBusMessage *msg, vo pa_assert(conn); pa_assert(msg); + pa_assert(iter); pa_assert(de); - if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_BOOLEAN, &muted) < 0) - return; + dbus_message_iter_get_basic(iter, &muted); pa_assert_se(e = read_entry(de->userdata, de->entry_name)); diff --git a/src/pulsecore/dbus-util.c b/src/pulsecore/dbus-util.c index b45e6a6c..e3700ea5 100644 --- a/src/pulsecore/dbus-util.c +++ b/src/pulsecore/dbus-util.c @@ -291,7 +291,10 @@ pa_dbus_wrap_connection* pa_dbus_wrap_connection_new(pa_mainloop_api *m, pa_bool return pconn; } -pa_dbus_wrap_connection* pa_dbus_wrap_connection_new_from_existing(pa_mainloop_api *m, pa_bool_t use_rtclock, DBusConnection *conn) { +pa_dbus_wrap_connection* pa_dbus_wrap_connection_new_from_existing( + pa_mainloop_api *m, + pa_bool_t use_rtclock, + DBusConnection *conn) { pa_dbus_wrap_connection *pconn; pa_assert(m); @@ -522,7 +525,10 @@ void pa_dbus_send_basic_variant_reply(DBusConnection *c, DBusMessage *in_reply_t pa_assert_se((reply = dbus_message_new_method_return(in_reply_to))); dbus_message_iter_init_append(reply, &msg_iter); - pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_VARIANT, signature_from_basic_type(type), &variant_iter)); + pa_assert_se(dbus_message_iter_open_container(&msg_iter, + DBUS_TYPE_VARIANT, + signature_from_basic_type(type), + &variant_iter)); pa_assert_se(dbus_message_iter_append_basic(&variant_iter, type, data)); pa_assert_se(dbus_message_iter_close_container(&msg_iter, &variant_iter)); pa_assert_se(dbus_connection_send(c, reply, NULL)); @@ -548,7 +554,12 @@ static unsigned basic_type_size(int type) { } } -void pa_dbus_send_basic_array_variant_reply(DBusConnection *c, DBusMessage *in_reply_to, int item_type, void *array, unsigned n) { +void pa_dbus_send_basic_array_variant_reply( + DBusConnection *c, + DBusMessage *in_reply_to, + int item_type, + void *array, + unsigned n) { DBusMessage *reply = NULL; DBusMessageIter msg_iter; @@ -641,7 +652,12 @@ void pa_dbus_append_basic_variant_dict_entry(DBusMessageIter *dict_iter, const c pa_assert_se(dbus_message_iter_close_container(dict_iter, &dict_entry_iter)); } -void pa_dbus_append_basic_array_variant_dict_entry(DBusMessageIter *dict_iter, const char *key, int item_type, const void *array, unsigned n) { +void pa_dbus_append_basic_array_variant_dict_entry( + DBusMessageIter *dict_iter, + const char *key, + int item_type, + const void *array, + unsigned n) { DBusMessageIter dict_entry_iter; pa_assert(dict_iter); @@ -711,156 +727,18 @@ void pa_dbus_append_proplist_variant_dict_entry(DBusMessageIter *dict_iter, cons pa_assert_se(dbus_message_iter_close_container(dict_iter, &dict_entry_iter)); } -int pa_dbus_get_basic_set_property_arg(DBusConnection *c, DBusMessage *msg, int type, void *data) { - DBusMessageIter msg_iter; - DBusMessageIter variant_iter; - - pa_assert(c); - pa_assert(msg); - pa_assert(dbus_type_is_basic(type)); - pa_assert(data); - - /* Skip the interface and property name arguments. */ - if (!dbus_message_iter_init(msg, &msg_iter) || !dbus_message_iter_next(&msg_iter) || !dbus_message_iter_next(&msg_iter)) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return -1; - } - - if (dbus_message_iter_get_arg_type(&msg_iter) != DBUS_TYPE_VARIANT) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Message argument isn't a variant."); - return -1; - } - - dbus_message_iter_recurse(&msg_iter, &variant_iter); - - if (pa_dbus_get_basic_arg(c, msg, &variant_iter, type, data) < 0) - return -1; - - return 0; -} - -int pa_dbus_get_fixed_array_set_property_arg(DBusConnection *c, DBusMessage *msg, int item_type, void *data, unsigned *n) { - DBusMessageIter msg_iter; - DBusMessageIter variant_iter; - - pa_assert(c); - pa_assert(msg); - pa_assert(dbus_type_is_fixed(item_type)); - pa_assert(data); - pa_assert(n); - - /* Skip the interface and property name arguments. */ - if (!dbus_message_iter_init(msg, &msg_iter) || !dbus_message_iter_next(&msg_iter) || !dbus_message_iter_next(&msg_iter)) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments."); - return -1; - } - - if (dbus_message_iter_get_arg_type(&msg_iter) != DBUS_TYPE_VARIANT) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Message argument isn't a variant."); - return -1; - } - - dbus_message_iter_recurse(&msg_iter, &variant_iter); - - if (pa_dbus_get_fixed_array_arg(c, msg, &variant_iter, item_type, data, n) < 0) - return -1; - - return 0; -} - -int pa_dbus_get_basic_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter, int type, void *data) { - int arg_type; - - pa_assert(c); - pa_assert(msg); - pa_assert(iter); - pa_assert(dbus_type_is_basic(type)); - pa_assert(data); - - arg_type = dbus_message_iter_get_arg_type(iter); - if (arg_type != type) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments. D-Bus type '%c' expected.", (char) type); - else - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong argument type: '%c'. Expected type '%c'.", (char) arg_type, (char) type); - return -1; - } - - dbus_message_iter_get_basic(iter, data); - - dbus_message_iter_next(iter); - - return 0; -} - -int pa_dbus_get_fixed_array_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter, int item_type, void *array, unsigned *n) { - DBusMessageIter array_iter; - int signed_n; - int arg_type; - int element_type; - - pa_assert(c); - pa_assert(msg); - pa_assert(iter); - pa_assert(dbus_type_is_fixed(item_type)); - pa_assert(array); - pa_assert(n); - - arg_type = dbus_message_iter_get_arg_type(iter); - if (arg_type != DBUS_TYPE_ARRAY) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments. An array of type '%c' was expected.", (char) item_type); - else - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong argument type: '%c'. An array of type '%c' was expected.", (char) arg_type, (char) item_type); - return -1; - } - - element_type = dbus_message_iter_get_element_type(iter); - if (element_type != item_type) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong array element type: '%c'. Element type '%c' was expected.", (char) element_type, (char) item_type); - return -1; - } - - dbus_message_iter_recurse(iter, &array_iter); - - dbus_message_iter_get_fixed_array(&array_iter, array, &signed_n); - - dbus_message_iter_next(iter); - - pa_assert(signed_n >= 0); - - *n = signed_n; - - return 0; -} - pa_proplist *pa_dbus_get_proplist_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter) { DBusMessageIter dict_iter; DBusMessageIter dict_entry_iter; - int arg_type; pa_proplist *proplist = NULL; - const char *key; - const uint8_t *value; - int value_length; + const char *key = NULL; + const uint8_t *value = NULL; + int value_length = 0; pa_assert(c); pa_assert(msg); pa_assert(iter); - - arg_type = dbus_message_iter_get_arg_type(iter); - if (arg_type != DBUS_TYPE_ARRAY) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments. An array was expected."); - else - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong argument type: '%c'. An array was expected.", (char) arg_type); - return NULL; - } - - arg_type = dbus_message_iter_get_element_type(iter); - if (arg_type != DBUS_TYPE_DICT_ENTRY) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong array element type: '%c'. A dictionary entry was expected.", (char) arg_type); - return NULL; - } + pa_assert(pa_streq(dbus_message_iter_get_signature(iter), "a{say}")); proplist = pa_proplist_new(); @@ -869,32 +747,11 @@ pa_proplist *pa_dbus_get_proplist_arg(DBusConnection *c, DBusMessage *msg, DBusM while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&dict_iter, &dict_entry_iter); - arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter); - if (arg_type != DBUS_TYPE_STRING) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong dict key type: '%c'. A string was expected.", (char) arg_type); - goto fail; - } - dbus_message_iter_get_basic(&dict_entry_iter, &key); dbus_message_iter_next(&dict_entry_iter); if (strlen(key) <= 0 || !pa_ascii_valid(key)) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Invalid property list key."); - goto fail; - } - - arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter); - if (arg_type != DBUS_TYPE_ARRAY) { - if (arg_type == DBUS_TYPE_INVALID) - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Dict value missing."); - else - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong dict value type: '%c'. An array was expected.", (char) arg_type); - goto fail; - } - - arg_type = dbus_message_iter_get_element_type(&dict_entry_iter); - if (arg_type != DBUS_TYPE_BYTE) { - pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Wrong dict value item type: '%c'. A byte was expected.", (char) arg_type); + pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Invalid property list key: '%s'.", key); goto fail; } diff --git a/src/pulsecore/dbus-util.h b/src/pulsecore/dbus-util.h index 9cee293c..f35e66cb 100644 --- a/src/pulsecore/dbus-util.h +++ b/src/pulsecore/dbus-util.h @@ -32,7 +32,10 @@ typedef struct pa_dbus_wrap_connection pa_dbus_wrap_connection; pa_dbus_wrap_connection* pa_dbus_wrap_connection_new(pa_mainloop_api *mainloop, pa_bool_t use_rtclock, DBusBusType type, DBusError *error); -pa_dbus_wrap_connection* pa_dbus_wrap_connection_new_from_existing(pa_mainloop_api *mainloop, pa_bool_t use_rtclock, DBusConnection *conn); +pa_dbus_wrap_connection* pa_dbus_wrap_connection_new_from_existing( + pa_mainloop_api *mainloop, + pa_bool_t use_rtclock, + DBusConnection *conn); void pa_dbus_wrap_connection_free(pa_dbus_wrap_connection* conn); DBusConnection* pa_dbus_wrap_connection_get(pa_dbus_wrap_connection *conn); @@ -63,36 +66,41 @@ void pa_dbus_sync_pending_list(pa_dbus_pending **p); void pa_dbus_free_pending_list(pa_dbus_pending **p); /* Sends an error message as the reply to the given message. */ -void pa_dbus_send_error(DBusConnection *c, DBusMessage *in_reply_to, const char *name, const char *format, ...) PA_GCC_PRINTF_ATTR(4, 5); +void pa_dbus_send_error( + DBusConnection *c, + DBusMessage *in_reply_to, + const char *name, + const char *format, ...) PA_GCC_PRINTF_ATTR(4, 5); void pa_dbus_send_empty_reply(DBusConnection *c, DBusMessage *in_reply_to); void pa_dbus_send_basic_value_reply(DBusConnection *c, DBusMessage *in_reply_to, int type, void *data); void pa_dbus_send_basic_variant_reply(DBusConnection *c, DBusMessage *in_reply_to, int type, void *data); -void pa_dbus_send_basic_array_variant_reply(DBusConnection *c, DBusMessage *in_reply_to, int item_type, void *array, unsigned n); +void pa_dbus_send_basic_array_variant_reply( + DBusConnection *c, + DBusMessage *in_reply_to, + int item_type, + void *array, + unsigned n); void pa_dbus_send_proplist_variant_reply(DBusConnection *c, DBusMessage *in_reply_to, pa_proplist *proplist); void pa_dbus_append_basic_array(DBusMessageIter *iter, int item_type, const void *array, unsigned n); void pa_dbus_append_basic_array_variant(DBusMessageIter *iter, int item_type, const void *array, unsigned n); void pa_dbus_append_basic_variant(DBusMessageIter *iter, int type, void *data); void pa_dbus_append_basic_variant_dict_entry(DBusMessageIter *dict_iter, const char *key, int type, void *data); -void pa_dbus_append_basic_array_variant_dict_entry(DBusMessageIter *dict_iter, const char *key, int item_type, const void *array, unsigned n); +void pa_dbus_append_basic_array_variant_dict_entry( + DBusMessageIter *dict_iter, + const char *key, + int item_type, + const void *array, + unsigned n); void pa_dbus_append_proplist(DBusMessageIter *iter, pa_proplist *proplist); void pa_dbus_append_proplist_variant(DBusMessageIter *iter, pa_proplist *proplist); void pa_dbus_append_proplist_variant_dict_entry(DBusMessageIter *dict_iter, const char *key, pa_proplist *proplist); -/* Helper functions for extracting the value argument of a Set call. If the - * message is invalid, an error reply is sent and a negative number is - * returned. */ -int pa_dbus_get_basic_set_property_arg(DBusConnection *c, DBusMessage *msg, int type, void *data); -int pa_dbus_get_fixed_array_set_property_arg(DBusConnection *c, DBusMessage *msg, int item_type, void *data, unsigned *n); - -/* If the arguments can't be read from the iterator, an error reply is sent and - * a negative number is returned. */ -int pa_dbus_get_basic_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter, int type, void *data); -int pa_dbus_get_fixed_array_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter, int item_type, void *array, unsigned *n); - -/* Returns a new proplist that the caller has to free. If the proplist can't be - * read from the iterator, an error reply is sent and NULL is returned. */ +/* Returns a new proplist that the caller has to free. If the proplist contains + * invalid keys, an error reply is sent and NULL is returned. The iterator must + * point to "a{say}" element. This function calls dbus_message_iter_next(iter) + * before returning. */ pa_proplist *pa_dbus_get_proplist_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter); #endif diff --git a/src/pulsecore/protocol-dbus.c b/src/pulsecore/protocol-dbus.c index d1e19ff3..91022511 100644 --- a/src/pulsecore/protocol-dbus.c +++ b/src/pulsecore/protocol-dbus.c @@ -257,37 +257,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 expexted + * 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 }; -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) { +/* 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. */ +}; + +/* 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); - - PA_HASHMAP_FOREACH(*iface_entry, obj_entry->interfaces, state) { - 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(); } } @@ -295,120 +348,138 @@ 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); - PA_HASHMAP_FOREACH(*iface_entry, obj_entry->interfaces, state) { - if ((*method_handler = pa_hashmap_get((*iface_entry)->method_handlers, 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))) return FOUND_METHOD; } 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 { - 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 FOUND_GET_PROPERTY; + 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 FOUND_SET_PROPERTY; 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); -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; + } else + pa_assert_not_reached(); +} - pa_assert(obj_entry); - pa_assert(msg); - pa_assert(iface_entry); - pa_assert(method_handler); - pa_assert(property_handler); - pa_assert(attempted_property); +static enum find_result_t find_handler(struct call_info *call_info) { + pa_assert(call_info); - *iface_entry = NULL; - *method_handler = NULL; + if (call_info->interface) { + if (pa_streq(call_info->interface, DBUS_INTERFACE_PROPERTIES)) + return find_handler_from_properties_call(call_info); - if (dbus_message_has_interface(msg, DBUS_INTERFACE_PROPERTIES)) - return find_handler_from_properties_call(obj_entry, msg, iface_entry, property_handler, attempted_property); + else if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->interface))) + return NO_SUCH_INTERFACE; - 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)))) + else if ((call_info->method_handler = pa_hashmap_get(call_info->iface_entry->method_handlers, call_info->method))) 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; + struct call_info call_info; pa_assert(connection); pa_assert(message); @@ -423,49 +494,72 @@ static DBusHandlerResult handle_message_cb(DBusConnection *connection, DBusMessa 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_dbus_send_basic_value_reply(connection, message, DBUS_TYPE_STRING, &obj_entry->introspection); + 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); - /* TODO: Write an else branch where a dummy response is sent. */ + 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_dbus_send_error(connection, message, DBUS_ERROR_ACCESS_DENIED, "%s access denied for property %s", dbus_message_get_member(message), attempted_property); + 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_dbus_send_error(connection, message, DBUS_ERROR_UNKNOWN_METHOD, "%s: No such method", dbus_message_get_member(message)); + pa_dbus_send_error(connection, message, DBUS_ERROR_UNKNOWN_METHOD, "No such method: %s", call_info.method); break; case NO_SUCH_PROPERTY: - pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "%s: No such property", attempted_property); + pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "No such property: %s", call_info.property); break; - case INVALID_MESSAGE_ARGUMENTS: - pa_dbus_send_error(connection, message, DBUS_ERROR_INVALID_ARGS, "Invalid arguments for %s", dbus_message_get_member(message)); + 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_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); + default: pa_assert_not_reached(); } @@ -821,7 +915,12 @@ 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) { +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; @@ -981,7 +1080,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); diff --git a/src/pulsecore/protocol-dbus.h b/src/pulsecore/protocol-dbus.h index d771b4fc..6d100f7c 100644 --- a/src/pulsecore/protocol-dbus.h +++ b/src/pulsecore/protocol-dbus.h @@ -56,9 +56,19 @@ void pa_dbus_protocol_unref(pa_dbus_protocol *p); * message isn't a good idea; if you can't handle the message, reply with an * error. * + * The message signature is already checked against the introspection data, so + * you don't have to do that yourself. + * * All messages are method calls. */ typedef void (*pa_dbus_receive_cb_t)(DBusConnection *conn, DBusMessage *msg, void *userdata); +/* A specialized version of pa_dbus_receive_cb_t: the additional iterator + * argument points to the element inside the new value variant. + * + * The new value signature is checked against the introspection data, so you + * don't have to do that yourself. */ +typedef void (*pa_dbus_set_property_cb_t)(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata); + typedef struct pa_dbus_arg_info { const char *name; const char *type; @@ -85,7 +95,7 @@ typedef struct pa_dbus_property_handler { /* The access mode for the property is determined by checking whether * get_cb or set_cb is NULL. */ pa_dbus_receive_cb_t get_cb; - pa_dbus_receive_cb_t set_cb; + pa_dbus_set_property_cb_t set_cb; } pa_dbus_property_handler; typedef struct pa_dbus_interface_info { @@ -140,7 +150,12 @@ pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn * only signals from the given objects are delivered. If this function is * called multiple time for the same connection and signal, the latest call * always replaces the previous object list. */ -void pa_dbus_protocol_add_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal, char **objects, unsigned n_objects); +void pa_dbus_protocol_add_signal_listener( + pa_dbus_protocol *p, + DBusConnection *conn, + const char *signal, + char **objects, + unsigned n_objects); /* Disables the delivery of the signal for the given connection. The connection * must have been registered. If signal is NULL, all signals are disabled. If @@ -192,6 +207,11 @@ typedef enum pa_dbus_protocol_hook { PA_DBUS_PROTOCOL_HOOK_MAX } pa_dbus_protocol_hook_t; -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); #endif -- cgit