/* Integration tests for the dbus-daemon * * Author: Simon McVittie * Copyright © 2008 Red Hat, Inc. * Copyright © 2010-2011 Nokia Corporation * Copyright © 2015-2018 Collabora Ltd. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation files * (the "Software"), to deal in the Software without restriction, * including without limitation the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include #include #include #include #include #include #include "bus/stats.h" #include "test-utils-glib.h" #include #ifdef DBUS_UNIX # include # include # include # include # include # ifdef HAVE_GIO_UNIX /* The CMake build system doesn't know how to check for this yet */ # include # endif # ifdef HAVE_SYS_RESOURCE_H # include # endif # ifdef HAVE_SYS_TIME_H # include # endif #endif /* Platforms where we know that credentials-passing passes both the * uid and the pid. Please keep these in alphabetical order. * * These platforms should #error in _dbus_read_credentials_socket() * if we didn't detect their flavour of credentials-passing, since that * would be a regression. */ #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \ defined(__linux__) || \ defined(__NetBSD__) || \ defined(__OpenBSD__) # define UNIX_USER_SHOULD_WORK # define PID_SHOULD_WORK #endif /* Platforms where we know that credentials-passing passes the * uid, but not necessarily the pid. Again, alphabetical order please. * * These platforms should also #error in _dbus_read_credentials_socket() * if we didn't detect their flavour of credentials-passing. */ #if 0 /* defined(__your_platform_here__) */ # define UNIX_USER_SHOULD_WORK #endif typedef struct { gboolean skip; TestMainContext *ctx; DBusError e; GError *ge; GPid daemon_pid; gchar *address; DBusConnection *left_conn; gboolean left_conn_shouted_signal_filter; DBusConnection *right_conn; GQueue held_messages; gboolean right_conn_echo; gboolean right_conn_hold; gboolean wait_forever_called; guint activation_forking_counter; guint signal_counter; gchar *tmp_runtime_dir; gchar *saved_runtime_dir; } Fixture; static DBusHandlerResult echo_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { Fixture *f = user_data; DBusMessage *reply; if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* WaitForever() never replies, emulating a service that has got stuck */ if (dbus_message_is_method_call (message, "com.example", "WaitForever")) { f->wait_forever_called = TRUE; return DBUS_HANDLER_RESULT_HANDLED; } reply = dbus_message_new_method_return (message); if (reply == NULL) g_error ("OOM"); if (!dbus_connection_send (connection, reply, NULL)) g_error ("OOM"); dbus_clear_message (&reply); return DBUS_HANDLER_RESULT_HANDLED; } static DBusHandlerResult hold_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { Fixture *f = user_data; if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; g_queue_push_tail (&f->held_messages, dbus_message_ref (message)); return DBUS_HANDLER_RESULT_HANDLED; } static DBusHandlerResult shouted_signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { Fixture *f = user_data; if (dbus_message_is_signal (message, "com.example", "Shouted")) f->signal_counter++; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } typedef struct { const char *bug_ref; guint min_messages; const char *config_file; TestUser user; enum { SPECIFY_ADDRESS = 0, RELY_ON_DEFAULT } connect_mode; } Config; static void setup (Fixture *f, gconstpointer context) { const Config *config = context; /* Some tests are fairly slow, so make the test timeout per-test */ test_timeout_reset (1); f->ctx = test_main_context_get (); f->ge = NULL; dbus_error_init (&f->e); if (config != NULL && config->connect_mode == RELY_ON_DEFAULT) { /* this is chosen to be something needing escaping */ f->tmp_runtime_dir = g_dir_make_tmp ("dbus=daemon=test.XXXXXX", &f->ge); g_assert_no_error (f->ge); /* we're relying on being single-threaded for this to be safe */ f->saved_runtime_dir = g_strdup (g_getenv ("XDG_RUNTIME_DIR")); g_setenv ("XDG_RUNTIME_DIR", f->tmp_runtime_dir, TRUE); g_unsetenv ("DBUS_SESSION_BUS_ADDRESS"); } f->address = test_get_dbus_daemon (config ? config->config_file : NULL, config ? config->user : TEST_USER_ME, NULL, &f->daemon_pid); if (f->address == NULL) { f->skip = TRUE; return; } f->left_conn = test_connect_to_bus (f->ctx, f->address); if (config != NULL && config->connect_mode == RELY_ON_DEFAULT) { /* use the default bus for the echo service ("right"), to check that * it ends up on the same bus as the client ("left") */ f->right_conn = dbus_bus_get_private (DBUS_BUS_SESSION, &f->e); test_assert_no_error (&f->e); test_connection_setup (f->ctx, f->right_conn); } else { f->right_conn = test_connect_to_bus (f->ctx, f->address); } } static void add_echo_filter (Fixture *f) { if (!dbus_connection_add_filter (f->right_conn, echo_filter, f, NULL)) g_error ("OOM"); f->right_conn_echo = TRUE; } static void add_hold_filter (Fixture *f) { if (!dbus_connection_add_filter (f->right_conn, hold_filter, f, NULL)) g_error ("OOM"); f->right_conn_hold = TRUE; } static void add_shouted_signal_filter (Fixture *f) { if (!dbus_connection_add_filter (f->left_conn, shouted_signal_filter, f, NULL)) g_error ("OOM"); f->left_conn_shouted_signal_filter = TRUE; } static void right_conn_emit_shouted (Fixture *f) { DBusMessage *m; m = dbus_message_new_signal ("/", "com.example", "Shouted"); if (m == NULL) g_error ("OOM"); if (!dbus_connection_send (f->right_conn, m, NULL)) g_error ("OOM"); dbus_clear_message (&m); } static void pc_count (DBusPendingCall *pc, void *data) { guint *received_p = data; (*received_p)++; } static void pc_enqueue (DBusPendingCall *pc, void *data) { GQueue *q = data; DBusMessage *m = dbus_pending_call_steal_reply (pc); g_test_message ("message of type %d", dbus_message_get_type (m)); g_queue_push_tail (q, m); } static void echo_left_to_right (Fixture *f, guint count) { guint sent; guint received = 0; for (sent = 0; sent < count; sent++) { DBusMessage *m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), "/", "com.example", "Spam"); DBusPendingCall *pc; if (m == NULL) g_error ("OOM"); if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) pc_count (pc, &received); else if (!dbus_pending_call_set_notify (pc, pc_count, &received, NULL)) g_error ("OOM"); dbus_clear_pending_call (&pc); dbus_clear_message (&m); } while (received < count) test_main_context_iterate (f->ctx, TRUE); } static void test_echo (Fixture *f, gconstpointer context) { const Config *config = context; guint count = 2000; double elapsed; if (f->skip) return; if (config != NULL && config->bug_ref != NULL) g_test_bug (config->bug_ref); if (g_test_perf ()) count = 100000; if (config != NULL) count = MAX (config->min_messages, count); add_echo_filter (f); g_test_timer_start (); echo_left_to_right (f, count); elapsed = g_test_timer_elapsed (); g_test_maximized_result (count / elapsed, "%u messages / %f seconds", count, elapsed); } static void test_no_reply (Fixture *f, gconstpointer context) { const Config *config = context; DBusMessage *m; DBusPendingCall *pc; DBusMessage *reply = NULL; enum { TIMEOUT, DISCONNECT } mode; gboolean ok; if (f->skip) return; g_test_bug ("76112"); if (config != NULL && config->config_file != NULL) mode = TIMEOUT; else mode = DISCONNECT; m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), "/", "com.example", "WaitForever"); add_echo_filter (f); if (m == NULL) g_error ("OOM"); /* Not using test_main_context_call_and_wait() here because we need to * do things with the right connection as a side-effect */ if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) test_pending_call_store_reply (pc, &reply); else if (!dbus_pending_call_set_notify (pc, test_pending_call_store_reply, &reply, NULL)) g_error ("OOM"); dbus_clear_pending_call (&pc); dbus_clear_message (&m); if (mode == DISCONNECT) { while (!f->wait_forever_called) test_main_context_iterate (f->ctx, TRUE); dbus_connection_remove_filter (f->right_conn, echo_filter, f); test_connection_shutdown (f->ctx, f->right_conn); dbus_connection_close (f->right_conn); dbus_clear_connection (&f->right_conn); } while (reply == NULL) test_main_context_iterate (f->ctx, TRUE); /* using inefficient string comparison for better assertion message */ g_assert_cmpstr ( dbus_message_type_to_string (dbus_message_get_type (reply)), ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_ERROR)); ok = dbus_set_error_from_message (&f->e, reply); g_assert (ok); g_assert_cmpstr (f->e.name, ==, DBUS_ERROR_NO_REPLY); if (mode == DISCONNECT) g_assert_cmpstr (f->e.message, ==, "Message recipient disconnected from message bus without replying"); else g_assert_cmpstr (f->e.message, ==, "Message did not receive a reply (timeout by message bus)"); dbus_clear_message (&reply); } #ifdef G_OS_UNIX static int gid_cmp (const void *ap, const void *bp) { gid_t a = *(const gid_t *)ap; gid_t b = *(const gid_t *)bp; if (a < b) return -1; if (a > b) return 1; return 0; } #endif static void test_creds (Fixture *f, gconstpointer context) { const char *unique = dbus_bus_get_unique_name (f->left_conn); DBusMessage *m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetConnectionCredentials"); DBusMessage *reply = NULL; DBusMessageIter args_iter; DBusMessageIter arr_iter; DBusMessageIter pair_iter; DBusMessageIter var_iter; enum { SEEN_UNIX_USER = 1, SEEN_PID = 2, SEEN_WINDOWS_SID = 4, SEEN_LINUX_SECURITY_LABEL = 8, SEEN_UNIX_GROUPS = 16, } seen = 0; if (m == NULL) g_error ("OOM"); if (!dbus_message_append_args (m, DBUS_TYPE_STRING, &unique, DBUS_TYPE_INVALID)) g_error ("OOM"); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); g_assert_cmpstr (dbus_message_get_signature (reply), ==, "a{sv}"); dbus_message_iter_init (reply, &args_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&args_iter), ==, DBUS_TYPE_ARRAY); g_assert_cmpuint (dbus_message_iter_get_element_type (&args_iter), ==, DBUS_TYPE_DICT_ENTRY); dbus_message_iter_recurse (&args_iter, &arr_iter); while (dbus_message_iter_get_arg_type (&arr_iter) != DBUS_TYPE_INVALID) { const char *name; dbus_message_iter_recurse (&arr_iter, &pair_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&pair_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_get_basic (&pair_iter, &name); dbus_message_iter_next (&pair_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&pair_iter), ==, DBUS_TYPE_VARIANT); dbus_message_iter_recurse (&pair_iter, &var_iter); if (g_strcmp0 (name, "UnixUserID") == 0) { #ifdef G_OS_UNIX guint32 u32; g_assert (!(seen & SEEN_UNIX_USER)); g_assert_cmpuint (dbus_message_iter_get_arg_type (&var_iter), ==, DBUS_TYPE_UINT32); dbus_message_iter_get_basic (&var_iter, &u32); g_test_message ("%s of this process is %u", name, u32); g_assert_cmpuint (u32, ==, geteuid ()); seen |= SEEN_UNIX_USER; #else g_assert_not_reached (); #endif } else if (g_strcmp0 (name, "UnixGroupIDs") == 0) { #ifdef G_OS_UNIX guint32 *groups; gid_t egid = getegid(); gid_t *actual_groups; int len, ret, i; size_t nmemb; DBusMessageIter array_iter; g_assert (!(seen & SEEN_UNIX_GROUPS)); g_assert_cmpuint (dbus_message_iter_get_arg_type (&var_iter), ==, DBUS_TYPE_ARRAY); dbus_message_iter_recurse (&var_iter, &array_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&array_iter), ==, DBUS_TYPE_UINT32); dbus_message_iter_get_fixed_array (&array_iter, &groups, &len); g_test_message ("%s of this process present (%d groups)", name, len); g_assert_cmpint (len, >=, 1); actual_groups = g_new0 (gid_t, len+1); ret = getgroups (len, actual_groups); if (ret < 0) g_error ("getgroups: %s", g_strerror (errno)); nmemb = ret; if (!lfind (&egid, actual_groups, &nmemb, sizeof (gid_t), gid_cmp)) actual_groups[ret++] = egid; g_assert_cmpint (ret, ==, len); qsort (actual_groups, len, sizeof (gid_t), gid_cmp); for (i = 0; i < len; i++) g_assert_true (groups[i] == actual_groups[i]); g_free (actual_groups); seen |= SEEN_UNIX_GROUPS; #else g_assert_not_reached (); #endif } else if (g_strcmp0 (name, "WindowsSID") == 0) { #ifdef G_OS_WIN32 gchar *sid; char *self_sid; g_assert (!(seen & SEEN_WINDOWS_SID)); g_assert_cmpuint (dbus_message_iter_get_arg_type (&var_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_get_basic (&var_iter, &sid); g_test_message ("%s of this process is %s", name, sid); if (_dbus_getsid (&self_sid, 0)) { g_assert_cmpstr (self_sid, ==, sid); LocalFree(self_sid); } seen |= SEEN_WINDOWS_SID; #else g_assert_not_reached (); #endif } else if (g_strcmp0 (name, "ProcessID") == 0) { guint32 u32; g_assert (!(seen & SEEN_PID)); g_assert_cmpuint (dbus_message_iter_get_arg_type (&var_iter), ==, DBUS_TYPE_UINT32); dbus_message_iter_get_basic (&var_iter, &u32); g_test_message ("%s of this process is %u", name, u32); #ifdef G_OS_UNIX g_assert_cmpuint (u32, ==, getpid ()); #elif defined(G_OS_WIN32) g_assert_cmpuint (u32, ==, GetCurrentProcessId ()); #else g_assert_not_reached (); #endif seen |= SEEN_PID; } else if (g_strcmp0 (name, "LinuxSecurityLabel") == 0) { #ifdef __linux__ gchar *label; int len; DBusMessageIter ay_iter; g_assert (!(seen & SEEN_LINUX_SECURITY_LABEL)); g_assert_cmpuint (dbus_message_iter_get_arg_type (&var_iter), ==, DBUS_TYPE_ARRAY); dbus_message_iter_recurse (&var_iter, &ay_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&ay_iter), ==, DBUS_TYPE_BYTE); dbus_message_iter_get_fixed_array (&ay_iter, &label, &len); g_test_message ("%s of this process is %s", name, label); g_assert_cmpuint (strlen (label) + 1, ==, len); seen |= SEEN_LINUX_SECURITY_LABEL; /* * At this point we would like to do something like: * * g_assert_cmpstr (label, ==, real_security_label); * * but there is no LSM-agnostic way to find out our real security * label in a way that matches SO_PEERSEC. The closest thing * available is reading /proc/self/attr/current, but that is only * equal to SO_PEERSEC after applying LSM-specific * canonicalization (for example for AppArmor you have to remove * a trailing newline from /proc/self/attr/current). */ #else g_assert_not_reached (); #endif } dbus_message_iter_next (&arr_iter); } #ifdef UNIX_USER_SHOULD_WORK g_assert (seen & SEEN_UNIX_USER); #endif #ifdef PID_SHOULD_WORK g_assert (seen & SEEN_PID); #endif #ifdef G_OS_WIN32 g_assert (seen & SEEN_WINDOWS_SID); #endif dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_processid (Fixture *f, gconstpointer context) { const char *unique = dbus_bus_get_unique_name (f->left_conn); DBusMessage *m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetConnectionUnixProcessID"); DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; guint32 pid; if (m == NULL) g_error ("OOM"); if (!dbus_message_append_args (m, DBUS_TYPE_STRING, &unique, DBUS_TYPE_INVALID)) g_error ("OOM"); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (dbus_set_error_from_message (&error, reply)) { g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN); #ifdef PID_SHOULD_WORK g_error ("Expected pid to be passed, but got %s: %s", error.name, error.message); #endif dbus_error_free (&error); } else if (dbus_message_get_args (reply, &error, DBUS_TYPE_UINT32, &pid, DBUS_TYPE_INVALID)) { g_assert_cmpstr (dbus_message_get_signature (reply), ==, "u"); test_assert_no_error (&error); g_test_message ("GetConnectionUnixProcessID returned %u", pid); #ifdef G_OS_UNIX g_assert_cmpuint (pid, ==, getpid ()); #elif defined(G_OS_WIN32) g_assert_cmpuint (pid, ==, GetCurrentProcessId ()); #else g_assert_not_reached (); #endif } else { g_error ("Unexpected error: %s: %s", error.name, error.message); } dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_canonical_path_uae (Fixture *f, gconstpointer context) { DBusMessage *m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "UpdateActivationEnvironment"); DBusMessage *reply = NULL; DBusMessageIter args_iter; DBusMessageIter arr_iter; if (m == NULL) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); /* Append an empty a{ss} (string => string dictionary). */ if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_ARRAY, "{ss}", &arr_iter) || !dbus_message_iter_close_container (&args_iter, &arr_iter)) g_error ("OOM"); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); /* it succeeds */ g_assert_cmpint (dbus_message_get_type (reply), ==, DBUS_MESSAGE_TYPE_METHOD_RETURN); dbus_clear_message (&reply); dbus_clear_message (&m); /* Now try with the wrong object path */ m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, "/com/example/Wrong", DBUS_INTERFACE_DBUS, "UpdateActivationEnvironment"); if (m == NULL) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); /* Append an empty a{ss} (string => string dictionary). */ if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_ARRAY, "{ss}", &arr_iter) || !dbus_message_iter_close_container (&args_iter, &arr_iter)) g_error ("OOM"); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); /* it fails, yielding an error message with one string argument */ g_assert_cmpint (dbus_message_get_type (reply), ==, DBUS_MESSAGE_TYPE_ERROR); g_assert_cmpstr (dbus_message_get_error_name (reply), ==, DBUS_ERROR_ACCESS_DENIED); g_assert_cmpstr (dbus_message_get_signature (reply), ==, "s"); dbus_clear_message (&reply); dbus_clear_message (&m); } static Config max_connections_per_user_config = { NULL, 1, "valid-config-files/max-connections-per-user.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static void test_max_connections (Fixture *f, gconstpointer context) { DBusError error = DBUS_ERROR_INIT; DBusConnection *third_conn; DBusConnection *failing_conn; #ifdef DBUS_WIN const Config *config = context; #endif if (f->skip) return; #ifdef DBUS_WIN if (config == &max_connections_per_user_config) { /* is currently only * implemented in terms of Unix uids. It could be implemented for * Windows SIDs too, but there wouldn't be much point, because we * don't support use of a multi-user dbus-daemon on Windows, so * in practice all connections have the same SID. */ g_test_skip ("Maximum connections per Windows SID are not " "implemented"); return; } #endif /* We have two connections already */ g_assert (f->left_conn != NULL); g_assert (f->right_conn != NULL); /* Our configuration file sets the limit to 3 connections, either globally * or per uid, so this one is the last that will work */ third_conn = test_connect_to_bus (f->ctx, f->address); /* This one is going to fail. We don't guarantee whether it will fail * now, or while registering (implementation detail: it's the latter). */ failing_conn = dbus_connection_open_private (f->address, &error); if (failing_conn != NULL) { gboolean ok = dbus_bus_register (failing_conn, &error); g_assert (!ok); } g_assert (dbus_error_is_set (&error)); g_assert_cmpstr (error.name, ==, DBUS_ERROR_LIMITS_EXCEEDED); if (failing_conn != NULL) dbus_connection_close (failing_conn); dbus_clear_connection (&failing_conn); test_connection_shutdown (f->ctx, third_conn); dbus_connection_close (third_conn); dbus_clear_connection (&third_conn); dbus_error_free (&error); } static void test_max_replies_per_connection (Fixture *f, gconstpointer context) { GQueue received = G_QUEUE_INIT; GQueue errors = G_QUEUE_INIT; DBusMessage *m; DBusPendingCall *pc; guint i; DBusError error = DBUS_ERROR_INIT; if (f->skip) return; add_hold_filter (f); /* The configured limit is 3 replies per connection. */ for (i = 0; i < 3; i++) { m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), "/", "com.example", "Spam"); if (m == NULL) g_error ("OOM"); if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) pc_enqueue (pc, &received); else if (!dbus_pending_call_set_notify (pc, pc_enqueue, &received, NULL)) g_error ("OOM"); dbus_pending_call_unref (pc); dbus_message_unref (m); } while (g_queue_get_length (&f->held_messages) < 3) test_main_context_iterate (f->ctx, TRUE); g_assert_cmpuint (g_queue_get_length (&received), ==, 0); g_assert_cmpuint (g_queue_get_length (&errors), ==, 0); /* Go a couple of messages over the limit. */ for (i = 0; i < 2; i++) { m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), "/", "com.example", "Spam"); if (m == NULL) g_error ("OOM"); if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) pc_enqueue (pc, &errors); else if (!dbus_pending_call_set_notify (pc, pc_enqueue, &errors, NULL)) g_error ("OOM"); dbus_pending_call_unref (pc); dbus_message_unref (m); } /* Reply to the held messages. */ for (m = g_queue_pop_head (&f->held_messages); m != NULL; m = g_queue_pop_head (&f->held_messages)) { DBusMessage *reply = dbus_message_new_method_return (m); if (reply == NULL) g_error ("OOM"); if (!dbus_connection_send (f->right_conn, reply, NULL)) g_error ("OOM"); dbus_clear_message (&m); dbus_clear_message (&reply); } /* Wait for all 5 replies to come in. */ while (g_queue_get_length (&received) + g_queue_get_length (&errors) < 5) test_main_context_iterate (f->ctx, TRUE); /* The first three succeeded. */ for (i = 0; i < 3; i++) { m = g_queue_pop_head (&received); g_assert (m != NULL); if (dbus_set_error_from_message (&error, m)) g_error ("Unexpected error: %s: %s", error.name, error.message); dbus_clear_message (&m); } /* The last two failed. */ for (i = 0; i < 2; i++) { m = g_queue_pop_head (&errors); g_assert (m != NULL); if (!dbus_set_error_from_message (&error, m)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_LIMITS_EXCEEDED); dbus_error_free (&error); dbus_clear_message (&m); } g_assert_cmpuint (g_queue_get_length (&received), ==, 0); g_assert_cmpuint (g_queue_get_length (&errors), ==, 0); g_queue_clear (&received); g_queue_clear (&errors); } static void test_max_match_rules_per_connection (Fixture *f, gconstpointer context) { DBusError error = DBUS_ERROR_INIT; if (f->skip) return; dbus_bus_add_match (f->left_conn, "sender='com.example.C1'", &error); test_assert_no_error (&error); dbus_bus_add_match (f->left_conn, "sender='com.example.C2'", &error); test_assert_no_error (&error); dbus_bus_add_match (f->left_conn, "sender='com.example.C3'", &error); test_assert_no_error (&error); dbus_bus_add_match (f->left_conn, "sender='com.example.C4'", &error); g_assert_cmpstr (error.name, ==, DBUS_ERROR_LIMITS_EXCEEDED); dbus_error_free (&error); dbus_bus_remove_match (f->left_conn, "sender='com.example.C3'", &error); test_assert_no_error (&error); dbus_bus_add_match (f->left_conn, "sender='com.example.C4'", &error); test_assert_no_error (&error); } static void test_max_names_per_connection (Fixture *f, gconstpointer context) { DBusError error = DBUS_ERROR_INIT; int ret; if (f->skip) return; /* The limit in the configuration file is set to 4, but we only own 3 * names here - remember that the unique name is a name too. */ ret = dbus_bus_request_name (f->left_conn, "com.example.C1", 0, &error); test_assert_no_error (&error); g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); ret = dbus_bus_request_name (f->left_conn, "com.example.C2", 0, &error); test_assert_no_error (&error); g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); ret = dbus_bus_request_name (f->left_conn, "com.example.C3", 0, &error); test_assert_no_error (&error); g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); ret = dbus_bus_request_name (f->left_conn, "com.example.C4", 0, &error); g_assert_cmpstr (error.name, ==, DBUS_ERROR_LIMITS_EXCEEDED); dbus_error_free (&error); g_assert_cmpint (ret, ==, -1); ret = dbus_bus_release_name (f->left_conn, "com.example.C3", &error); test_assert_no_error (&error); g_assert_cmpint (ret, ==, DBUS_RELEASE_NAME_REPLY_RELEASED); ret = dbus_bus_request_name (f->left_conn, "com.example.C4", 0, &error); test_assert_no_error (&error); g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); } #if defined(DBUS_UNIX) && defined(HAVE_UNIX_FD_PASSING) && defined(HAVE_GIO_UNIX) static DBusHandlerResult wait_for_disconnected_cb (DBusConnection *client_conn, DBusMessage *message, void *data) { gboolean *disconnected = data; if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected")) { *disconnected = TRUE; return DBUS_HANDLER_RESULT_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } static const guchar partial_message[] = { DBUS_LITTLE_ENDIAN, DBUS_MESSAGE_TYPE_METHOD_CALL, 0, /* flags */ 1, /* version */ 0xff, 0xff, 0, 0, /* length of body = 65535 bytes */ 1, 2, 3, 4, /* cookie */ 0xff, 0xff, 0, 0, /* length of header fields array = 65535 bytes */ 42 /* pretending to be the beginning of the header fields array */ }; static void send_all_with_fd (GSocket *socket, const guchar *local_partial_message, gsize len, int fd) { GSocketControlMessage *fdm = g_unix_fd_message_new (); GError *error = NULL; gssize sent; GOutputVector vector = { local_partial_message, len }; g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (fdm), fd, &error); g_assert_no_error (error); sent = g_socket_send_message (socket, NULL, &vector, 1, &fdm, 1, G_SOCKET_MSG_NONE, NULL, &error); g_assert_no_error (error); g_assert_cmpint (sent, >=, 1); g_assert_cmpint (sent, <=, vector.size); while (((gsize) sent) < vector.size) { vector.size -= sent; vector.buffer = ((const guchar *) vector.buffer) + sent; sent = g_socket_send_message (socket, NULL, &vector, 1, NULL, 0, G_SOCKET_MSG_NONE, NULL, &error); g_assert_no_error (error); g_assert_cmpint (sent, >=, 1); g_assert_cmpint (sent, <=, vector.size); } g_object_unref (fdm); } static void test_pending_fd_timeout (Fixture *f, gconstpointer context) { GError *error = NULL; gint64 start; int fd; GSocket *socket; gboolean have_mem; gboolean disconnected = FALSE; if (f->skip) return; if (getuid () == 0) { g_test_skip ("Cannot test, uid 0 is immune to this limit"); return; } have_mem = dbus_connection_add_filter (f->left_conn, wait_for_disconnected_cb, &disconnected, NULL); g_assert (have_mem); /* This is not API. Never do this. */ if (!dbus_connection_get_socket (f->left_conn, &fd)) g_error ("failed to steal fd from left connection"); socket = g_socket_new_from_fd (fd, &error); g_assert_no_error (error); g_assert (socket != NULL); /* We send part of a message that contains a fd, then stop. */ start = g_get_monotonic_time (); send_all_with_fd (socket, partial_message, G_N_ELEMENTS (partial_message), fd); while (!disconnected) { test_progress ('.'); test_main_context_iterate (f->ctx, TRUE); /* It should take 0.5s to get disconnected, as configured in * valid-config-files/pending-fd-timeout.conf; but this test * might get starved by other processes running in parallel * (particularly on shared CI systems), so we have to be a lot * more generous. Allow up to 10 seconds. */ g_assert_cmpint (g_get_monotonic_time (), <=, start + (10 * G_USEC_PER_SEC)); } g_object_unref (socket); } typedef struct { const gchar *path; guint n_fds; gboolean should_work; } CountFdsVector; static const CountFdsVector count_fds_vectors[] = { /* Deny sending if number of fds <= 2 */ { "/test/DenySendMax2", 1, FALSE }, { "/test/DenySendMax2", 2, FALSE }, { "/test/DenySendMax2", 3, TRUE }, { "/test/DenySendMax2", 4, TRUE }, /* Deny receiving if number of fds <= 3 */ { "/test/DenyReceiveMax3", 2, FALSE }, { "/test/DenyReceiveMax3", 3, FALSE }, { "/test/DenyReceiveMax3", 4, TRUE }, { "/test/DenyReceiveMax3", 5, TRUE }, /* Deny sending if number of fds >= 4 */ { "/test/DenySendMin4", 2, TRUE }, { "/test/DenySendMin4", 3, TRUE }, { "/test/DenySendMin4", 4, FALSE }, { "/test/DenySendMin4", 5, FALSE }, /* Deny receiving if number of fds >= 5 */ { "/test/DenyReceiveMin5", 3, TRUE }, { "/test/DenyReceiveMin5", 4, TRUE }, { "/test/DenyReceiveMin5", 5, FALSE }, { "/test/DenyReceiveMin5", 6, FALSE }, }; static void test_count_fds (Fixture *f, gconstpointer context) { GQueue received = G_QUEUE_INIT; DBusMessage *m; DBusPendingCall *pc; guint i; DBusError error = DBUS_ERROR_INIT; const int stdin_fd = 0; if (f->skip) return; add_hold_filter (f); for (i = 0; i < G_N_ELEMENTS (count_fds_vectors); i++) { const CountFdsVector *vector = &count_fds_vectors[i]; guint j; m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), vector->path, "com.example", "Spam"); if (m == NULL) g_error ("OOM"); for (j = 0; j < vector->n_fds; j++) { if (!dbus_message_append_args (m, DBUS_TYPE_UNIX_FD, &stdin_fd, DBUS_TYPE_INVALID)) g_error ("OOM"); } if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) pc_enqueue (pc, &received); else if (!dbus_pending_call_set_notify (pc, pc_enqueue, &received, NULL)) g_error ("OOM"); dbus_pending_call_unref (pc); dbus_message_unref (m); if (vector->should_work) { DBusMessage *reply; while (g_queue_get_length (&f->held_messages) < 1) test_main_context_iterate (f->ctx, TRUE); g_assert_cmpint (g_queue_get_length (&f->held_messages), ==, 1); m = g_queue_pop_head (&f->held_messages); g_assert_cmpint (g_queue_get_length (&f->held_messages), ==, 0); reply = dbus_message_new_method_return (m); if (reply == NULL) g_error ("OOM"); if (!dbus_connection_send (f->right_conn, reply, NULL)) g_error ("OOM"); dbus_message_unref (reply); dbus_message_unref (m); } while (g_queue_get_length (&received) < 1) test_main_context_iterate (f->ctx, TRUE); g_assert_cmpint (g_queue_get_length (&received), ==, 1); m = g_queue_pop_head (&received); g_assert (m != NULL); g_assert_cmpint (g_queue_get_length (&received), ==, 0); if (vector->should_work) { if (dbus_set_error_from_message (&error, m)) g_error ("Unexpected error: %s: %s", error.name, error.message); g_test_message ("Sending %u fds to %s was not denied, as expected", vector->n_fds, vector->path); } else if (!dbus_set_error_from_message (&error, m)) { g_error ("Unexpected success"); } else { g_assert_cmpstr (error.name, ==, DBUS_ERROR_ACCESS_DENIED); dbus_error_free (&error); g_test_message ("Sending %u fds to %s was denied, as expected", vector->n_fds, vector->path); } dbus_message_unref (m); } } #endif static void test_peer_get_machine_id (Fixture *f, gconstpointer context) { char *what_i_think; const char *what_daemon_thinks; DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; if (f->skip) return; what_i_think = dbus_try_get_local_machine_id (&error); if (what_i_think == NULL) { if (g_getenv ("DBUS_TEST_UNINSTALLED") != NULL) { /* When running unit tests during make check or make installcheck, * tolerate this */ g_test_skip ("Machine UUID not available"); dbus_error_free (&error); return; } else { /* When running integration tests, don't tolerate it */ g_error ("%s", error.message); } } /* Check that the dbus-daemon agrees with us. */ m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PEER, "GetMachineId"); if (m == NULL) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &what_daemon_thinks, DBUS_TYPE_INVALID)) g_error ("%s: %s", error.name, error.message); g_assert_cmpstr (what_i_think, ==, what_daemon_thinks); g_assert_nonnull (what_daemon_thinks); g_assert_cmpuint (strlen (what_daemon_thinks), ==, 32); dbus_clear_message (&reply); dbus_clear_message (&m); dbus_free (what_i_think); } static void test_peer_ping (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PEER, "Ping"); if (m == NULL) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_message_get_args (reply, &error, DBUS_TYPE_INVALID)) g_error ("%s: %s", error.name, error.message); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_invalid_path (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; const char *property = "Interfaces"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, "/", DBUS_INTERFACE_PROPERTIES, "Get"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); /* That object path does not have that interface */ g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_invalid_iface (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = "com.example.Nope"; const char *property = "Whatever"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Get"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_invalid (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; const char *property = "Whatever"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Get"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_PROPERTY); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_all_invalid_iface (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = "com.example.Nope"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "GetAll"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_all_invalid_path (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, "/", DBUS_INTERFACE_PROPERTIES, "GetAll"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); /* That object path does not have that interface */ g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_set_invalid_iface (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = "com.example.Nope"; const char *property = "Whatever"; DBusMessageIter args_iter; DBusMessageIter var_iter; dbus_bool_t b = FALSE; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Set"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_VARIANT, "b", &var_iter) || !dbus_message_iter_append_basic (&var_iter, DBUS_TYPE_BOOLEAN, &b) || !dbus_message_iter_close_container (&args_iter, &var_iter)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_set_invalid_path (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; const char *property = "Interfaces"; DBusMessageIter args_iter; DBusMessageIter var_iter; dbus_bool_t b = FALSE; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, "/", DBUS_INTERFACE_PROPERTIES, "Set"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_VARIANT, "b", &var_iter) || !dbus_message_iter_append_basic (&var_iter, DBUS_TYPE_BOOLEAN, &b) || !dbus_message_iter_close_container (&args_iter, &var_iter)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_INTERFACE); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_set_invalid (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; const char *property = "Whatever"; DBusMessageIter args_iter; DBusMessageIter var_iter; dbus_bool_t b = FALSE; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Set"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_VARIANT, "b", &var_iter) || !dbus_message_iter_append_basic (&var_iter, DBUS_TYPE_BOOLEAN, &b) || !dbus_message_iter_close_container (&args_iter, &var_iter)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_UNKNOWN_PROPERTY); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_set (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; const char *iface = DBUS_INTERFACE_DBUS; const char *property = "Features"; DBusMessageIter args_iter; DBusMessageIter var_iter; dbus_bool_t b = FALSE; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Set"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) g_error ("OOM"); dbus_message_iter_init_append (m, &args_iter); if (!dbus_message_iter_open_container (&args_iter, DBUS_TYPE_VARIANT, "b", &var_iter) || !dbus_message_iter_append_basic (&var_iter, DBUS_TYPE_BOOLEAN, &b) || !dbus_message_iter_close_container (&args_iter, &var_iter)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_set_error_from_message (&error, reply)) g_error ("Unexpected success"); g_assert_cmpstr (error.name, ==, DBUS_ERROR_PROPERTY_READ_ONLY); dbus_error_free (&error); dbus_clear_message (&reply); dbus_clear_message (&m); } static void check_features (DBusMessageIter *var_iter) { DBusMessageIter arr_iter; gboolean have_systemd_activation = FALSE; gboolean have_header_filtering = FALSE; g_assert_cmpint (dbus_message_iter_get_arg_type (var_iter), ==, DBUS_TYPE_ARRAY); g_assert_cmpint (dbus_message_iter_get_element_type (var_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_recurse (var_iter, &arr_iter); while (dbus_message_iter_get_arg_type (&arr_iter) != DBUS_TYPE_INVALID) { const char *feature; g_assert_cmpint (dbus_message_iter_get_arg_type (&arr_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_get_basic (&arr_iter, &feature); g_test_message ("Feature: %s", feature); if (g_strcmp0 (feature, "HeaderFiltering") == 0) have_header_filtering = TRUE; else if (g_strcmp0 (feature, "SystemdActivation") == 0) have_systemd_activation = TRUE; dbus_message_iter_next (&arr_iter); } g_assert_true (have_header_filtering); /* We pass --systemd-activation to the daemon for this unit test on Unix * (it can only work in practice on Linux, but there's nothing * inherently Linux-specific about the protocol). */ #ifdef DBUS_UNIX g_assert_true (have_systemd_activation); #else g_assert_false (have_systemd_activation); #endif } static void test_features (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusMessageIter args_iter; DBusMessageIter var_iter; const char *iface = DBUS_INTERFACE_DBUS; const char *features = "Features"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Get"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &features, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_message_iter_init (reply, &args_iter)) g_error ("Reply has no arguments"); g_assert_cmpint (dbus_message_iter_get_arg_type (&args_iter), ==, DBUS_TYPE_VARIANT); dbus_message_iter_recurse (&args_iter, &var_iter); check_features (&var_iter); if (dbus_message_iter_next (&args_iter)) g_error ("Reply has too many arguments"); dbus_clear_message (&reply); dbus_clear_message (&m); } static void check_interfaces (DBusMessageIter *var_iter) { DBusMessageIter arr_iter; gboolean have_monitoring = FALSE; gboolean have_stats = FALSE; gboolean have_verbose = FALSE; g_assert_cmpint (dbus_message_iter_get_arg_type (var_iter), ==, DBUS_TYPE_ARRAY); g_assert_cmpint (dbus_message_iter_get_element_type (var_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_recurse (var_iter, &arr_iter); while (dbus_message_iter_get_arg_type (&arr_iter) != DBUS_TYPE_INVALID) { const char *iface; g_assert_cmpint (dbus_message_iter_get_arg_type (&arr_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_get_basic (&arr_iter, &iface); g_test_message ("Interface: %s", iface); g_assert_cmpstr (iface, !=, DBUS_INTERFACE_DBUS); g_assert_cmpstr (iface, !=, DBUS_INTERFACE_PROPERTIES); g_assert_cmpstr (iface, !=, DBUS_INTERFACE_INTROSPECTABLE); g_assert_cmpstr (iface, !=, DBUS_INTERFACE_PEER); if (g_strcmp0 (iface, DBUS_INTERFACE_MONITORING) == 0) have_monitoring = TRUE; else if (g_strcmp0 (iface, BUS_INTERFACE_STATS) == 0) have_stats = TRUE; else if (g_strcmp0 (iface, DBUS_INTERFACE_VERBOSE) == 0) have_verbose = TRUE; dbus_message_iter_next (&arr_iter); } g_assert_true (have_monitoring); #ifdef DBUS_ENABLE_STATS g_assert_true (have_stats); #else g_assert_false (have_stats); #endif #ifdef DBUS_ENABLE_VERBOSE_MODE g_assert_true (have_verbose); #else g_assert_false (have_verbose); #endif } static void test_interfaces (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusMessageIter args_iter; DBusMessageIter var_iter; const char *iface = DBUS_INTERFACE_DBUS; const char *ifaces = "Interfaces"; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "Get"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_STRING, &ifaces, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); if (!dbus_message_iter_init (reply, &args_iter)) g_error ("Reply has no arguments"); if (dbus_message_iter_get_arg_type (&args_iter) != DBUS_TYPE_VARIANT) g_error ("Reply does not have a variant argument"); dbus_message_iter_recurse (&args_iter, &var_iter); check_interfaces (&var_iter); if (dbus_message_iter_next (&args_iter)) g_error ("Reply has too many arguments"); dbus_clear_message (&reply); dbus_clear_message (&m); } static void test_get_all (Fixture *f, gconstpointer context) { DBusMessage *m = NULL; DBusMessage *reply = NULL; DBusMessageIter args_iter; DBusMessageIter arr_iter; DBusMessageIter pair_iter; DBusMessageIter var_iter; const char *iface = DBUS_INTERFACE_DBUS; gboolean have_features = FALSE; gboolean have_interfaces = FALSE; if (f->skip) return; m = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_PROPERTIES, "GetAll"); if (m == NULL || !dbus_message_append_args (m, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID)) test_oom (); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, m, DBUS_TIMEOUT_USE_DEFAULT); dbus_message_iter_init (reply, &args_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&args_iter), ==, DBUS_TYPE_ARRAY); g_assert_cmpuint (dbus_message_iter_get_element_type (&args_iter), ==, DBUS_TYPE_DICT_ENTRY); dbus_message_iter_recurse (&args_iter, &arr_iter); while (dbus_message_iter_get_arg_type (&arr_iter) != DBUS_TYPE_INVALID) { const char *name; dbus_message_iter_recurse (&arr_iter, &pair_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&pair_iter), ==, DBUS_TYPE_STRING); dbus_message_iter_get_basic (&pair_iter, &name); dbus_message_iter_next (&pair_iter); g_assert_cmpuint (dbus_message_iter_get_arg_type (&pair_iter), ==, DBUS_TYPE_VARIANT); dbus_message_iter_recurse (&pair_iter, &var_iter); if (g_strcmp0 (name, "Features") == 0) { check_features (&var_iter); have_features = TRUE; } else if (g_strcmp0 (name, "Interfaces") == 0) { check_interfaces (&var_iter); have_interfaces = TRUE; } dbus_message_iter_next (&arr_iter); } g_assert_true (have_features); g_assert_true (have_interfaces); if (dbus_message_iter_next (&args_iter)) g_error ("Reply has too many arguments"); dbus_clear_message (&reply); dbus_clear_message (&m); } #define DESIRED_RLIMIT 65536 #ifdef DBUS_UNIX static void test_fd_limit (Fixture *f, gconstpointer context) { #ifdef HAVE_PRLIMIT struct rlimit lim; struct rlimit new_limit; const struct passwd *pwd = NULL; #endif if (f->skip) return; #ifdef HAVE_PRLIMIT if (getuid () != 0) { g_test_skip ("Cannot test, only uid 0 is expected to raise fd limit"); return; } pwd = getpwnam (DBUS_USER); if (pwd == NULL) { gchar *message = g_strdup_printf ("user '%s' does not exist", DBUS_USER); g_test_skip (message); g_free (message); return; } if (prlimit (getpid (), RLIMIT_NOFILE, NULL, &lim) < 0) g_error ("get prlimit (self): %s", g_strerror (errno)); g_test_message ("our RLIMIT_NOFILE: rlim_cur: %ld, rlim_max: %ld", (long) lim.rlim_cur, (long) lim.rlim_max); if (lim.rlim_cur == RLIM_INFINITY || lim.rlim_cur >= DESIRED_RLIMIT) { /* The dbus-daemon will have inherited our large rlimit */ g_test_skip ("Cannot test, our own fd limit was already large"); return; } new_limit = lim; new_limit.rlim_cur = DESIRED_RLIMIT; new_limit.rlim_max = DESIRED_RLIMIT; /* Try to increase the rlimit ourselves. If we're root in an * unprivileged Linux container, then we won't have CAP_SYS_RESOURCE * and this will fail with EPERM. If so, the dbus-daemon wouldn't be * able to increase its rlimit either. */ if (prlimit (getpid (), RLIMIT_NOFILE, &new_limit, NULL) < 0) { gchar *message; message = g_strdup_printf ("Cannot test, we cannot change the rlimit so " "presumably neither can the dbus-daemon: %s", g_strerror (errno)); g_test_skip (message); g_free (message); return; } /* Immediately put our original limit back so it won't interfere with * subsequent tests. This should always succeed. */ if (prlimit (getpid (), RLIMIT_NOFILE, &lim, NULL) < 0) g_error ("Cannot restore our original limits: %s", g_strerror (errno)); if (prlimit (f->daemon_pid, RLIMIT_NOFILE, NULL, &lim) < 0) g_error ("get prlimit (dbus-daemon): %s", g_strerror (errno)); g_test_message ("dbus-daemon's RLIMIT_NOFILE: rlim_cur: %ld, rlim_max: %ld", (long) lim.rlim_cur, (long) lim.rlim_max); if (lim.rlim_cur != RLIM_INFINITY) g_assert_cmpint (lim.rlim_cur, >=, DESIRED_RLIMIT); #else /* !HAVE_PRLIMIT */ g_test_skip ("prlimit() not supported on this platform"); #endif /* !HAVE_PRLIMIT */ } #define ECHO_SERVICE "org.freedesktop.DBus.TestSuiteEchoService" #define FORKING_ECHO_SERVICE "org.freedesktop.DBus.TestSuiteForkingEchoService" #define ECHO_SERVICE_PATH "/org/freedesktop/TestSuite" #define ECHO_SERVICE_INTERFACE "org.freedesktop.TestSuite" #ifdef ENABLE_TRADITIONAL_ACTIVATION /* * Helper for test_activation_forking: whenever the forking service is * activated, start it again. */ static DBusHandlerResult activation_forking_signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { Fixture *f = user_data; if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) { dbus_bool_t ok; const char *name; const char *old_owner; const char *new_owner; ok = dbus_message_get_args (message, &f->e, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old_owner, DBUS_TYPE_STRING, &new_owner, DBUS_TYPE_INVALID); test_assert_no_error (&f->e); g_assert_true (ok); g_test_message ("owner of \"%s\": \"%s\" -> \"%s\"", name, old_owner, new_owner); if (g_strcmp0 (name, FORKING_ECHO_SERVICE) != 0) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (f->activation_forking_counter > 10) { g_test_message ("Activated 10 times OK, TestSuiteForkingEchoService pass"); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } f->activation_forking_counter++; if (g_strcmp0 (new_owner, "") == 0) { /* Reactivate it, and tell it to exit immediately. */ DBusMessage *echo_call = NULL; DBusMessage *exit_call = NULL; gchar *payload = NULL; payload = g_strdup_printf ("counter %u", f->activation_forking_counter); echo_call = dbus_message_new_method_call (FORKING_ECHO_SERVICE, ECHO_SERVICE_PATH, ECHO_SERVICE_INTERFACE, "Echo"); exit_call = dbus_message_new_method_call (FORKING_ECHO_SERVICE, ECHO_SERVICE_PATH, ECHO_SERVICE_INTERFACE, "Exit"); if (echo_call == NULL || !dbus_message_append_args (echo_call, DBUS_TYPE_STRING, &payload, DBUS_TYPE_INVALID) || exit_call == NULL || !dbus_connection_send (connection, echo_call, NULL) || !dbus_connection_send (connection, exit_call, NULL)) g_error ("OOM"); dbus_clear_message (&echo_call); dbus_clear_message (&exit_call); g_free (payload); } } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } /* * Assert that Unix services are allowed to daemonize, and this does not * cause us to signal an activation failure. */ static void test_activation_forking (Fixture *f, gconstpointer context G_GNUC_UNUSED) { DBusMessage *call = NULL; DBusMessage *reply = NULL; const char *hello = "hello world"; if (f->skip) return; if (!dbus_connection_add_filter (f->left_conn, activation_forking_signal_filter, f, NULL)) g_error ("OOM"); /* Start it up */ call = dbus_message_new_method_call (FORKING_ECHO_SERVICE, ECHO_SERVICE_PATH, ECHO_SERVICE_INTERFACE, "Echo"); if (call == NULL || !dbus_message_append_args (call, DBUS_TYPE_STRING, &hello, DBUS_TYPE_INVALID)) g_error ("OOM"); dbus_bus_add_match (f->left_conn, "sender='org.freedesktop.DBus'", &f->e); test_assert_no_error (&f->e); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, call, DBUS_TIMEOUT_USE_DEFAULT); dbus_clear_message (&call); g_test_message ("TestSuiteForkingEchoService initial reply OK"); dbus_clear_message (&reply); /* Now monitor for exits: when that happens, start it up again. * The goal here is to try to hit any race conditions in activation. */ f->activation_forking_counter = 0; call = dbus_message_new_method_call (FORKING_ECHO_SERVICE, ECHO_SERVICE_PATH, ECHO_SERVICE_INTERFACE, "Exit"); if (call == NULL || !dbus_connection_send (f->left_conn, call, NULL)) g_error ("OOM"); dbus_clear_message (&call); while (f->activation_forking_counter <= 10) test_main_context_iterate (f->ctx, TRUE); dbus_connection_remove_filter (f->left_conn, activation_forking_signal_filter, f); } /* * Helper for test_system_signals: Receive Foo signals and add them to * the held_messages queue. */ static DBusHandlerResult foo_signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { Fixture *f = user_data; if (dbus_message_is_signal (message, ECHO_SERVICE_INTERFACE, "Foo")) g_queue_push_tail (&f->held_messages, dbus_message_ref (message)); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } /* * Assert that the system bus(-like) configuration allows services * to emit signals, even if there is no service-specific configuration * to allow it. * * Essentially equivalent to the old test/name-test/test-wait-for-echo.py. */ static void test_system_signals (Fixture *f, gconstpointer context G_GNUC_UNUSED) { DBusMessage *call = NULL; DBusMessage *response = NULL; g_test_bug ("18229"); if (f->skip) return; if (!dbus_connection_add_filter (f->left_conn, foo_signal_filter, f, NULL)) g_error ("OOM"); dbus_bus_add_match (f->left_conn, "interface='" ECHO_SERVICE_INTERFACE "'", &f->e); test_assert_no_error (&f->e); call = dbus_message_new_method_call (ECHO_SERVICE, ECHO_SERVICE_PATH, ECHO_SERVICE_INTERFACE, "EmitFoo"); if (call == NULL || !dbus_connection_send (f->left_conn, call, NULL)) g_error ("OOM"); dbus_clear_message (&call); while (g_queue_get_length (&f->held_messages) < 1) test_main_context_iterate (f->ctx, TRUE); g_test_message ("got signal"); g_assert_cmpuint (g_queue_get_length (&f->held_messages), ==, 1); response = g_queue_pop_head (&f->held_messages); g_assert_cmpint (dbus_message_get_type (response), ==, DBUS_MESSAGE_TYPE_SIGNAL); g_assert_cmpstr (dbus_message_get_interface (response), ==, ECHO_SERVICE_INTERFACE); g_assert_cmpstr (dbus_message_get_path (response), ==, ECHO_SERVICE_PATH); g_assert_cmpstr (dbus_message_get_signature (response), ==, "d"); g_assert_cmpstr (dbus_message_get_member (response), ==, "Foo"); dbus_clear_message (&response); dbus_connection_remove_filter (f->left_conn, foo_signal_filter, f); } #endif #endif static void take_well_known_name (DBusConnection *conn, const char *name, DBusError *error, int ownership_type) { int ret = dbus_bus_request_name (conn, name, 0, error); test_assert_no_error (error); g_assert_cmpint (ret, ==, ownership_type); } static void drop_well_known_name (DBusConnection *conn, const char *name, DBusError *error) { int ret = dbus_bus_release_name (conn, name, error); test_assert_no_error (error); g_assert_cmpint (ret, ==, DBUS_RELEASE_NAME_REPLY_RELEASED); } static void helper_send_destination_prefix_check (Fixture *f, const char *name, const char *interface, const char *member, dbus_bool_t allowed, const char *additional_name, int ownership_type) { DBusMessage *call = NULL; DBusMessage *reply = NULL; take_well_known_name (f->right_conn, name, &f->e, ownership_type); if (additional_name) take_well_known_name (f->right_conn, additional_name, &f->e, ownership_type); call = dbus_message_new_method_call (dbus_bus_get_unique_name (f->right_conn), "/", interface, member); if (call == NULL) g_error ("OOM"); reply = test_main_context_call_and_wait (f->ctx, f->left_conn, call, DBUS_TIMEOUT_USE_DEFAULT); dbus_clear_message (&call); g_test_message ("reply from %s(%d):%s OK", name, ownership_type, member); if (allowed) { g_test_message ("checking reply from %s for correct method_return", name); g_assert_cmpint (dbus_message_get_type (reply), ==, DBUS_MESSAGE_TYPE_METHOD_RETURN); } else { g_test_message ("checking reply from %s for correct access_denied", name); g_assert_cmpint (dbus_message_get_type (reply), ==, DBUS_MESSAGE_TYPE_ERROR); g_assert_cmpstr (dbus_message_get_error_name (reply), ==, DBUS_ERROR_ACCESS_DENIED); } dbus_clear_message (&reply); drop_well_known_name (f->right_conn, name, &f->e); if (additional_name) drop_well_known_name (f->right_conn, additional_name, &f->e); } static void helper_send_destination_prefix (Fixture *f, const char *name, const char *interface, const char *member, dbus_bool_t allowed, const char *additional_name) { /* check with primary ownership */ helper_send_destination_prefix_check (f, name, interface, member, allowed, additional_name, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); /* check with queued ownership */ take_well_known_name (f->left_conn, name, &f->e, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); if (additional_name) take_well_known_name (f->left_conn, additional_name, &f->e, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER); helper_send_destination_prefix_check (f, name, interface, member, allowed, additional_name, DBUS_REQUEST_NAME_REPLY_IN_QUEUE); drop_well_known_name (f->left_conn, name, &f->e); if (additional_name) drop_well_known_name (f->left_conn, additional_name, &f->e); } static void test_send_destination_prefix (Fixture *f, gconstpointer context G_GNUC_UNUSED) { if (f->skip) return; add_echo_filter (f); /* * Names are constructed with prefix foo.bar.test.dest_prefix followed by some of the tokens: * - a - allow send_destination for this name * - d - deny send_destination for this name * - ap - allow send_destination_prefix for this name * - dp - deny send_destination_prefix for this name * - f, f1, f2, f3 - fillers for generating names down the name hierarchy * - apf, dpf, ao, do - just some neighbour names * - m - names with 'm' have rules for interface and member * - apxdp, dpxap - names that have contradicting rules, e.g. for apxdp there are "allow send_destination_prefix" * rules first, followed by "deny send_destination_prefix" rules */ /* basic checks - base allow */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.apf", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.apf.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); /* basic checks - base deny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dpf", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dpf.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); /* With interface and method in the policy: * everything is allowed, except foo.bar.a.CallDeny and whole foo.bar.d minus foo.bar.d.CallAllow.*/ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.a", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.a", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.a", "NonExistent", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.d", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.d", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.d", "NonExistent", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m", "foo.bar.none", "NonExistent", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.a", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.a", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.a", "NonExistent", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.d", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.d", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.d", "NonExistent", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.m.f.f.f.f.f", "foo.bar.none", "NonExistent", TRUE, NULL); /* With interface and method in the policy: * everything is denied, except foo.bar.d.CallAllow and whole foo.bar.a minus foo.bar.a.CallDeny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.a", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.a", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.a", "NonExistent", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.d", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.d", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.d", "NonExistent", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m", "foo.bar.none", "NonExistent", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.a", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.a", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.a", "NonExistent", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.d", "CallDeny", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.d", "CallAllow", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.d", "NonExistent", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.m.f.f.f.f.f", "foo.bar.none", "NonExistent", FALSE, NULL); /* multiple names owned - everything is allowed */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.ap.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.ao"); /* multiple names owned - mixed allow/deny, but denied wins */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ap.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.dp.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.do", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ap.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.do"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.dp.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ao"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ao.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.dp.f.f"); /* multiple names owned - mixed allow/deny, but allowed wins */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.ao.ao"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao.ao", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f1.ap.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f"); /* multiple names owned - everything is denied */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.do.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.do.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.dp.f"); /* holes in default allow */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ao"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ap"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ap.f1.dp.f.f.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap", "com.example.Anything", "Anything", FALSE, "foo.bar.test.dest_prefix.ap.f1.dp.f.f.f.f"); /* holes in holes in default allow */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.d.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.d.ap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.ap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f1.dp.ap.a", "com.example.Anything", "Anything", TRUE, NULL); /* redefinitions in default allow */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.ap", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.ap.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.ap.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.a", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.dp.ap.f.a", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.f.f.f.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f2.apxdp.f.f.f.ap.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); /* cancelled definitions in default allow */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.dp", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.dp.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.dp.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.dp.ap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ap.f3.dpxap.ap.dp.a", "com.example.Anything", "Anything", TRUE, NULL); /* holes in default deny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.a", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.a.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.f.f.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.do"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.do", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f1.ap.f.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.f.f.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.do.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.do.f.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f1.ap.f.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.f.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f.f.f", "com.example.Anything", "Anything", TRUE, "foo.bar.test.dest_prefix.dp.f1.ap.f.f"); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.ao", "com.example.Anything", "Anything", TRUE, NULL); /* holes in holes in default deny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.a.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.a.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f1.ap.d.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); /* redefinitions in default deny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.dp", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.dp.f.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.dp.a", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.dp.a.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.d.f.f.f", "com.example.Anything", "Anything", TRUE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.ap.dp.f.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.f.f.f.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f2.dpxap.f.f.f.dp.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); /* cancelled definitions in default deny */ helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap.dp", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap.dp.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap.d", "com.example.Anything", "Anything", FALSE, NULL); helper_send_destination_prefix (f, "foo.bar.test.dest_prefix.dp.f3.apxdp.dp.ap.d.f.f.f.f", "com.example.Anything", "Anything", FALSE, NULL); } static void teardown (Fixture *f, gconstpointer context G_GNUC_UNUSED) { dbus_error_free (&f->e); g_clear_error (&f->ge); if (f->left_conn != NULL) { if (f->left_conn_shouted_signal_filter) { dbus_connection_remove_filter (f->left_conn, shouted_signal_filter, f); f->left_conn_shouted_signal_filter = FALSE; } test_connection_shutdown (f->ctx, f->left_conn); dbus_connection_close (f->left_conn); } if (f->right_conn != NULL) { GList *link; if (f->right_conn_echo) { dbus_connection_remove_filter (f->right_conn, echo_filter, f); f->right_conn_echo = FALSE; } if (f->right_conn_hold) { dbus_connection_remove_filter (f->right_conn, hold_filter, f); f->right_conn_hold = FALSE; } for (link = f->held_messages.head; link != NULL; link = link->next) dbus_message_unref (link->data); g_queue_clear (&f->held_messages); test_connection_shutdown (f->ctx, f->right_conn); dbus_connection_close (f->right_conn); } dbus_clear_connection (&f->left_conn); dbus_clear_connection (&f->right_conn); if (f->daemon_pid != 0) { test_kill_pid (f->daemon_pid); g_spawn_close_pid (f->daemon_pid); f->daemon_pid = 0; } if (f->tmp_runtime_dir != NULL) { gchar *path; /* the socket may exist */ path = g_strdup_printf ("%s/bus", f->tmp_runtime_dir); test_remove_if_exists (path); g_free (path); /* there shouldn't be anything else in there */ test_rmdir_must_exist (f->tmp_runtime_dir); /* we're relying on being single-threaded for this to be safe */ if (f->saved_runtime_dir != NULL) g_setenv ("XDG_RUNTIME_DIR", f->saved_runtime_dir, TRUE); else g_unsetenv ("XDG_RUNTIME_DIR"); g_free (f->saved_runtime_dir); g_free (f->tmp_runtime_dir); } test_main_context_unref (f->ctx); g_free (f->address); } static Config limited_config = { "34393", 10000, "valid-config-files/incoming-limit.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config finite_timeout_config = { NULL, 1, "valid-config-files/finite-timeout.conf", TEST_USER_ME, SPECIFY_ADDRESS }; #ifdef DBUS_UNIX static Config listen_unix_runtime_config = { "61303", 1, "valid-config-files/listen-unix-runtime.conf", TEST_USER_ME, RELY_ON_DEFAULT }; #endif static Config max_completed_connections_config = { NULL, 1, "valid-config-files/max-completed-connections.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config max_replies_per_connection_config = { NULL, 1, "valid-config-files/max-replies-per-connection.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config max_match_rules_per_connection_config = { NULL, 1, "valid-config-files/max-match-rules-per-connection.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config max_names_per_connection_config = { NULL, 1, "valid-config-files/max-names-per-connection.conf", TEST_USER_ME, SPECIFY_ADDRESS }; #if defined(DBUS_UNIX) && defined(HAVE_UNIX_FD_PASSING) && defined(HAVE_GIO_UNIX) static Config pending_fd_timeout_config = { NULL, 1, "valid-config-files/pending-fd-timeout.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config count_fds_config = { NULL, 1, "valid-config-files/count-fds.conf", TEST_USER_ME, SPECIFY_ADDRESS }; #endif #if defined(DBUS_UNIX) static Config as_another_user_config = { NULL, 1, "valid-config-files/as-another-user.conf", /* We start the dbus-daemon as root and drop privileges, like the * real system bus does */ TEST_USER_ROOT_DROP_TO_MESSAGEBUS, SPECIFY_ADDRESS }; #ifdef ENABLE_TRADITIONAL_ACTIVATION static Config tmp_session_config = { NULL, 1, "valid-config-files/tmp-session.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static Config nearly_system_config = { NULL, 1, "valid-config-files-system/tmp-session-like-system.conf", TEST_USER_ME, SPECIFY_ADDRESS }; #endif #endif static Config send_destination_prefix_config = { NULL, 1, "valid-config-files/send-destination-prefix-rules.conf", TEST_USER_ME, SPECIFY_ADDRESS }; static void test_match_remove_fails (Fixture *f, gconstpointer context G_GNUC_UNUSED) { const char *match_rule = "type='signal'"; if (f->skip) return; /* Unlike in test_match_remove_succeeds(), we never added this */ dbus_bus_remove_match (f->left_conn, match_rule, &f->e); g_assert_cmpstr (f->e.name, ==, DBUS_ERROR_MATCH_RULE_NOT_FOUND); } static void test_match_remove_succeeds (Fixture *f, gconstpointer context G_GNUC_UNUSED) { const char *match_rule = "type='signal'"; if (f->skip) return; add_shouted_signal_filter (f); /* We use this to make sure that a method call from the "left" connection * will get a reply from the "right", to sync up */ add_echo_filter (f); /* Emit a signal from the "right" connection, and assert that the "left" * does not receive it yet */ f->signal_counter = 0; right_conn_emit_shouted (f); /* Because messages are totally-ordered, if the "left" connection was * going to receive the signal, it would receive it before it got * the reply from this async call to the "right" connection */ echo_left_to_right (f, 1); g_assert_cmpuint (f->signal_counter, ==, 0); dbus_bus_add_match (f->left_conn, match_rule, &f->e); test_assert_no_error (&f->e); f->signal_counter = 0; /* Emit a signal from the "right" connection, and assert that the "left" * receives it */ right_conn_emit_shouted (f); while (f->signal_counter < 1) test_main_context_iterate (f->ctx, TRUE); dbus_bus_remove_match (f->left_conn, match_rule, &f->e); test_assert_no_error (&f->e); /* Emit a signal from the "right" connection, and assert that the "left" * does not receive it this time */ f->signal_counter = 0; right_conn_emit_shouted (f); /* Because messages are totally-ordered, if the "left" connection was * going to receive the signal, it would receive it before it got * the reply from this async call to the "right" connection */ echo_left_to_right (f, 1); g_assert_cmpuint (f->signal_counter, ==, 0); } int main (int argc, char **argv) { int ret; test_init (&argc, &argv); g_test_add ("/echo/session", Fixture, NULL, setup, test_echo, teardown); g_test_add ("/echo/limited", Fixture, &limited_config, setup, test_echo, teardown); g_test_add ("/no-reply/disconnect", Fixture, NULL, setup, test_no_reply, teardown); g_test_add ("/no-reply/timeout", Fixture, &finite_timeout_config, setup, test_no_reply, teardown); g_test_add ("/creds", Fixture, NULL, setup, test_creds, teardown); g_test_add ("/processid", Fixture, NULL, setup, test_processid, teardown); g_test_add ("/canonical-path/uae", Fixture, NULL, setup, test_canonical_path_uae, teardown); g_test_add ("/limits/max-completed-connections", Fixture, &max_completed_connections_config, setup, test_max_connections, teardown); g_test_add ("/limits/max-connections-per-user", Fixture, &max_connections_per_user_config, setup, test_max_connections, teardown); g_test_add ("/limits/max-replies-per-connection", Fixture, &max_replies_per_connection_config, setup, test_max_replies_per_connection, teardown); g_test_add ("/limits/max-match-rules-per-connection", Fixture, &max_match_rules_per_connection_config, setup, test_max_match_rules_per_connection, teardown); g_test_add ("/limits/max-names-per-connection", Fixture, &max_names_per_connection_config, setup, test_max_names_per_connection, teardown); g_test_add ("/match/remove/fails", Fixture, NULL, setup, test_match_remove_fails, teardown); g_test_add ("/match/remove/succeeds", Fixture, NULL, setup, test_match_remove_succeeds, teardown); g_test_add ("/peer/ping", Fixture, NULL, setup, test_peer_ping, teardown); g_test_add ("/peer/get-machine-id", Fixture, NULL, setup, test_peer_get_machine_id, teardown); g_test_add ("/properties/get-invalid-iface", Fixture, NULL, setup, test_get_invalid_iface, teardown); g_test_add ("/properties/get-invalid-path", Fixture, NULL, setup, test_get_invalid_path, teardown); g_test_add ("/properties/get-invalid", Fixture, NULL, setup, test_get_invalid, teardown); g_test_add ("/properties/get-all-invalid-iface", Fixture, NULL, setup, test_get_all_invalid_iface, teardown); g_test_add ("/properties/get-all-invalid-path", Fixture, NULL, setup, test_get_all_invalid_path, teardown); g_test_add ("/properties/set-invalid-iface", Fixture, NULL, setup, test_set_invalid_iface, teardown); g_test_add ("/properties/set-invalid-path", Fixture, NULL, setup, test_set_invalid_path, teardown); g_test_add ("/properties/set-invalid", Fixture, NULL, setup, test_set_invalid, teardown); g_test_add ("/properties/set", Fixture, NULL, setup, test_set, teardown); g_test_add ("/properties/features", Fixture, NULL, setup, test_features, teardown); g_test_add ("/properties/interfaces", Fixture, NULL, setup, test_interfaces, teardown); g_test_add ("/properties/get-all", Fixture, NULL, setup, test_get_all, teardown); #if defined(DBUS_UNIX) && defined(HAVE_UNIX_FD_PASSING) && defined(HAVE_GIO_UNIX) g_test_add ("/limits/pending-fd-timeout", Fixture, &pending_fd_timeout_config, setup, test_pending_fd_timeout, teardown); g_test_add ("/policy/count-fds", Fixture, &count_fds_config, setup, test_count_fds, teardown); #endif #ifdef DBUS_UNIX /* We can't test this in loopback.c with the rest of unix:runtime=yes, * because dbus_bus_get[_private] is the only way to use the default, * and that blocks on a round-trip to the dbus-daemon */ g_test_add ("/unix-runtime-is-default", Fixture, &listen_unix_runtime_config, setup, test_echo, teardown); g_test_add ("/fd-limit/session", Fixture, NULL, setup, test_fd_limit, teardown); g_test_add ("/fd-limit/system", Fixture, &as_another_user_config, setup, test_fd_limit, teardown); #ifdef ENABLE_TRADITIONAL_ACTIVATION g_test_add ("/activation/forking", Fixture, &tmp_session_config, setup, test_activation_forking, teardown); g_test_add ("/system-policy/allow-signals", Fixture, &nearly_system_config, setup, test_system_signals, teardown); #endif #endif g_test_add ("/system-policy/send-destination/prefix", Fixture, &send_destination_prefix_config, setup, test_send_destination_prefix, teardown); ret = g_test_run (); dbus_shutdown (); return ret; }