test/monitor.c

   1 /* Integration tests for monitor-mode D-Bus connections
   2  *
   3  * Copyright © 2010-2011 Nokia Corporation
   4  * Copyright © 2015 Collabora Ltd.
   5  *
   6  * Permission is hereby granted, free of charge, to any person
   7  * obtaining a copy of this software and associated documentation files
   8  * (the "Software"), to deal in the Software without restriction,
   9  * including without limitation the rights to use, copy, modify, merge,
  10  * publish, distribute, sublicense, and/or sell copies of the Software,
  11  * and to permit persons to whom the Software is furnished to do so,
  12  * subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  21  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27 #include <config.h>
  28
  29 #include <string.h>
  30
  31 #include "test-utils-glib.h"
  32
  33 typedef struct {
  34     const char *config_file;
  35     const char * const *match_rules;
  36     gboolean care_about_our_names;
  37 } Config;
  38
  39 typedef struct {
  40     const Config *config;
  41     TestMainContext *ctx;
  42     DBusError e;
  43     GError *ge;
  44
  45     gchar *address;
  46     GPid daemon_pid;
  47
  48     DBusConnection *monitor;
  49     DBusConnection *sender;
  50     DBusConnection *recipient;
  51
  52     GQueue monitored;
  53
  54     const char *monitor_name;
  55     const char *sender_name;
  56     const char *recipient_name;
  57
  58     DBusConnection *systemd;
  59     const char *systemd_name;
  60     DBusMessage *systemd_message;
  61     DBusConnection *activated;
  62     const char *activated_name;
  63     DBusMessage *activated_message;
  64 } Fixture;
  65
  66 static const char * const no_match_rules[] = {
  67     NULL
  68 };
  69
  70 static const char * const wildcard_match_rules[] = {
  71     "",
  72     NULL,
  73     FALSE
  74 };
  75
  76 static const char * const eavesdrop_match_rules[] = {
  77     "eavesdrop=true",
  78     NULL,
  79     FALSE
  80 };
  81
  82 static const char * const no_eavesdrop_match_rules[] = {
  83     "eavesdrop=false",
  84     NULL,
  85     FALSE
  86 };
  87
  88 static const char * const selective_match_rules[] = {
  89     "interface='com.example.Interesting'",
  90     "interface='com.example.Fun'",
  91     NULL,
  92     FALSE
  93 };
  94
  95 static Config forbidding_config = {
  96     "valid-config-files/forbidding.conf",
  97     NULL,
  98     FALSE
  99 };
 100
 101 static Config wildcard_config = {
 102     NULL,
 103     wildcard_match_rules,
 104     FALSE
 105 };
 106
 107 static Config selective_config = {
 108     NULL,
 109     selective_match_rules,
 110     FALSE
 111 };
 112
 113 static Config no_rules_config = {
 114     NULL,
 115     no_match_rules,
 116     FALSE
 117 };
 118
 119 static Config eavesdrop_config = {
 120     NULL,
 121     eavesdrop_match_rules,
 122     FALSE
 123 };
 124
 125 static Config no_eavesdrop_config = {
 126     NULL,
 127     no_eavesdrop_match_rules,
 128     FALSE
 129 };
 130
 131 #ifdef DBUS_UNIX
 132 static Config fake_systemd_config = {
 133     "valid-config-files/systemd-activation.conf",
 134     NULL,
 135     FALSE
 136 };
 137 #endif
 138
 139 static Config side_effects_config = {
 140     NULL,
 141     NULL,
 142     TRUE
 143 };
 144
 145 static inline const char *
 146 not_null2 (const char *x,
 147     const char *fallback)
 148 {
 149   if (x == NULL)
 150     return fallback;
 151
 152   return x;
 153 }
 154
 155 static inline const char *
 156 not_null (const char *x)
 157 {
 158   return not_null2 (x, "(null)");
 159 }
 160
 161 #define log_message(m) _log_message (m, __FILE__, __LINE__)
 162
 163 G_GNUC_UNUSED
 164 static void
 165 _log_message (DBusMessage *m,
 166     const char *file,
 167     int line)
 168 {
 169   g_test_message ("%s:%d: message type %d (%s)", file, line,
 170       dbus_message_get_type (m),
 171       dbus_message_type_to_string (dbus_message_get_type (m)));
 172   g_test_message ("\tfrom: %s",
 173       not_null2 (dbus_message_get_sender (m), "(dbus-daemon)"));
 174   g_test_message ("\tto: %s",
 175       not_null2 (dbus_message_get_destination (m), "(broadcast)"));
 176   g_test_message ("\tpath: %s",
 177       not_null (dbus_message_get_path (m)));
 178   g_test_message ("\tinterface: %s",
 179       not_null (dbus_message_get_interface (m)));
 180   g_test_message ("\tmember: %s",
 181       not_null (dbus_message_get_member (m)));
 182   g_test_message ("\tsignature: %s",
 183       not_null (dbus_message_get_signature (m)));
 184   g_test_message ("\terror name: %s",
 185       not_null (dbus_message_get_error_name (m)));
 186
 187   if (strcmp ("s", dbus_message_get_signature (m)) == 0)
 188     {
 189       DBusError e = DBUS_ERROR_INIT;
 190       const char *s;
 191
 192       dbus_message_get_args (m, &e,
 193             DBUS_TYPE_STRING, &s,
 194             DBUS_TYPE_INVALID);
 195       test_assert_no_error (&e);
 196       g_test_message ("\tstring payload: %s", s);
 197     }
 198 }
 199
 200 /* these are macros so they get the right line number */
 201
 202 #define assert_hello(m) \
 203 do { \
 204   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 205       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_CALL)); \
 206   g_assert_cmpstr (dbus_message_get_destination (m), ==, DBUS_SERVICE_DBUS); \
 207   g_assert_cmpstr (dbus_message_get_path (m), ==, DBUS_PATH_DBUS); \
 208   g_assert_cmpstr (dbus_message_get_interface (m), ==, DBUS_INTERFACE_DBUS); \
 209   g_assert_cmpstr (dbus_message_get_member (m), ==, "Hello"); \
 210   g_assert_cmpstr (dbus_message_get_signature (m), ==, ""); \
 211   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 212   g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
 213 } while (0)
 214
 215 #define assert_hello_reply(m) \
 216 do { \
 217   DBusError _e = DBUS_ERROR_INIT; \
 218   const char *_s; \
 219     \
 220   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 221       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_RETURN)); \
 222   g_assert_cmpstr (dbus_message_get_sender (m), ==, DBUS_SERVICE_DBUS); \
 223   g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
 224   g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
 225   g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
 226   g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
 227   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 228   g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
 229     \
 230   dbus_message_get_args (m, &_e, \
 231         DBUS_TYPE_STRING, &_s, \
 232         DBUS_TYPE_INVALID); \
 233   test_assert_no_error (&_e); \
 234   g_assert_cmpstr (dbus_message_get_destination (m), ==, _s); \
 235 } while (0)
 236
 237 #define assert_name_acquired(m) \
 238 do { \
 239   DBusError _e = DBUS_ERROR_INIT; \
 240   const char *_s; \
 241     \
 242   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 243       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_SIGNAL)); \
 244   g_assert_cmpstr (dbus_message_get_sender (m), ==, DBUS_SERVICE_DBUS); \
 245   g_assert_cmpstr (dbus_message_get_path (m), ==, DBUS_PATH_DBUS); \
 246   g_assert_cmpstr (dbus_message_get_interface (m), ==, DBUS_INTERFACE_DBUS); \
 247   g_assert_cmpstr (dbus_message_get_member (m), ==, "NameAcquired"); \
 248   g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
 249   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 250   g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
 251     \
 252   dbus_message_get_args (m, &_e, \
 253         DBUS_TYPE_STRING, &_s, \
 254         DBUS_TYPE_INVALID); \
 255   test_assert_no_error (&_e); \
 256   g_assert_cmpstr (dbus_message_get_destination (m), ==, _s); \
 257 } while (0)
 258
 259 #define assert_method_call(m, sender, \
 260     destination, path, iface, method, signature) \
 261 do { \
 262   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 263       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_CALL)); \
 264   g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
 265   g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
 266   g_assert_cmpstr (dbus_message_get_path (m), ==, path); \
 267   g_assert_cmpstr (dbus_message_get_interface (m), ==, iface); \
 268   g_assert_cmpstr (dbus_message_get_member (m), ==, method); \
 269   g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
 270   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 271   g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
 272 } while (0)
 273
 274 #define assert_signal(m, \
 275     sender, path, iface, member, signature, \
 276     destination) \
 277 do { \
 278   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 279       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_SIGNAL)); \
 280   g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
 281   g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
 282   g_assert_cmpstr (dbus_message_get_path (m), ==, path); \
 283   g_assert_cmpstr (dbus_message_get_interface (m), ==, iface); \
 284   g_assert_cmpstr (dbus_message_get_member (m), ==, member); \
 285   g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
 286   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 287   g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
 288 } while (0)
 289
 290 #define assert_method_reply(m, sender, destination, signature) \
 291 do { \
 292   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 293       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_RETURN)); \
 294   g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
 295   g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
 296   g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
 297   g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
 298   g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
 299   g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
 300   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 301   g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
 302 } while (0)
 303
 304 #define assert_error_reply(m, sender, destination, error_name) \
 305 do { \
 306   g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
 307       ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_ERROR)); \
 308   g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
 309   g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
 310   g_assert_cmpstr (dbus_message_get_error_name (m), ==, error_name); \
 311   g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
 312   g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
 313   g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
 314   g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
 315   g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
 316   g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
 317 } while (0)
 318
 319 /* This is called after processing pending replies to our own method
 320  * calls, but before anything else.
 321  */
 322 static DBusHandlerResult
 323 monitor_filter (DBusConnection *connection,
 324     DBusMessage *message,
 325     void *user_data)
 326 {
 327   Fixture *f = user_data;
 328
 329   g_assert_cmpstr (dbus_message_get_interface (message), !=,
 330       "com.example.Tedious");
 331
 332   /* we are not interested in the monitor getting NameAcquired or NameLost
 333    * for most tests */
 334   if (f->config == NULL || !f->config->care_about_our_names)
 335     {
 336       if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 337             "NameAcquired") ||
 338           dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 339             "NameLost"))
 340         {
 341           DBusError e = DBUS_ERROR_INIT;
 342           const char *s;
 343
 344           dbus_message_get_args (message, &e,
 345                 DBUS_TYPE_STRING, &s,
 346                 DBUS_TYPE_INVALID);
 347           test_assert_no_error (&e);
 348
 349           if (strcmp (s, f->monitor_name) == 0)
 350             {
 351               /* ignore */
 352               return DBUS_HANDLER_RESULT_HANDLED;
 353             }
 354         }
 355     }
 356
 357   g_queue_push_tail (&f->monitored, dbus_message_ref (message));
 358
 359   return DBUS_HANDLER_RESULT_HANDLED;
 360 }
 361
 362 static DBusHandlerResult
 363 recipient_filter (DBusConnection *connection,
 364     DBusMessage *message,
 365     void *user_data)
 366 {
 367   g_assert_cmpstr (dbus_message_get_interface (message), !=,
 368       "com.example.CannotSend");
 369   g_assert_cmpstr (dbus_message_get_interface (message), !=,
 370       "com.example.CannotReceive");
 371
 372   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 373 }
 374
 375 static DBusHandlerResult
 376 systemd_filter (DBusConnection *connection,
 377     DBusMessage *message,
 378     void *user_data)
 379 {
 380   Fixture *f = user_data;
 381
 382   if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 383         "NameAcquired") ||
 384       dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 385         "NameLost"))
 386     {
 387       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 388     }
 389
 390   g_assert (f->systemd_message == NULL);
 391   f->systemd_message = dbus_message_ref (message);
 392
 393   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 394 }
 395
 396 static DBusHandlerResult
 397 activated_filter (DBusConnection *connection,
 398     DBusMessage *message,
 399     void *user_data)
 400 {
 401   Fixture *f = user_data;
 402
 403   if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 404         "NameAcquired") ||
 405       dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 406         "NameLost"))
 407     {
 408       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 409     }
 410
 411   g_assert (f->activated_message == NULL);
 412   f->activated_message = dbus_message_ref (message);
 413
 414   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 415 }
 416
 417 static void
 418 setup (Fixture *f,
 419     gconstpointer context)
 420 {
 421   f->config = context;
 422
 423   f->ctx = test_main_context_get ();
 424
 425   f->ge = NULL;
 426   dbus_error_init (&f->e);
 427
 428   f->address = test_get_dbus_daemon (f->config ? f->config->config_file : NULL,
 429       TEST_USER_ME, &f->daemon_pid);
 430
 431   if (f->address == NULL)
 432     return;
 433
 434   f->monitor = test_connect_to_bus (f->ctx, f->address);
 435   f->monitor_name = dbus_bus_get_unique_name (f->monitor);
 436   f->sender = test_connect_to_bus (f->ctx, f->address);
 437   f->sender_name = dbus_bus_get_unique_name (f->sender);
 438   f->recipient = test_connect_to_bus (f->ctx, f->address);
 439   f->recipient_name = dbus_bus_get_unique_name (f->recipient);
 440
 441   if (!dbus_connection_add_filter (f->monitor, monitor_filter, f, NULL))
 442     g_error ("OOM");
 443
 444   if (!dbus_connection_add_filter (f->recipient, recipient_filter, f, NULL))
 445     g_error ("OOM");
 446 }
 447
 448 static void
 449 become_monitor (Fixture *f)
 450 {
 451   DBusMessage *m;
 452   DBusPendingCall *pc;
 453   dbus_bool_t ok;
 454   DBusMessageIter appender, array_appender;
 455   const char * const *match_rules;
 456   int i;
 457   dbus_uint32_t zero = 0;
 458
 459   dbus_connection_set_route_peer_messages (f->monitor, TRUE);
 460
 461   if (f->config != NULL && f->config->match_rules != NULL)
 462     match_rules = f->config->match_rules;
 463   else
 464     match_rules = wildcard_match_rules;
 465
 466   m = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
 467       DBUS_PATH_DBUS, DBUS_INTERFACE_MONITORING, "BecomeMonitor");
 468
 469   if (m == NULL)
 470     g_error ("OOM");
 471
 472   dbus_message_iter_init_append (m, &appender);
 473
 474   if (!dbus_message_iter_open_container (&appender, DBUS_TYPE_ARRAY, "s",
 475         &array_appender))
 476     g_error ("OOM");
 477
 478   for (i = 0; match_rules[i] != NULL; i++)
 479     {
 480       if (!dbus_message_iter_append_basic (&array_appender, DBUS_TYPE_STRING,
 481             &match_rules[i]))
 482         g_error ("OOM");
 483     }
 484
 485   if (!dbus_message_iter_close_container (&appender, &array_appender) ||
 486       !dbus_message_iter_append_basic (&appender, DBUS_TYPE_UINT32, &zero))
 487     g_error ("OOM");
 488
 489   if (!dbus_connection_send_with_reply (f->monitor, m, &pc,
 490         DBUS_TIMEOUT_USE_DEFAULT) ||
 491       pc == NULL)
 492     g_error ("OOM");
 493
 494   dbus_message_unref (m);
 495   m = NULL;
 496
 497   if (dbus_pending_call_get_completed (pc))
 498     test_pending_call_store_reply (pc, &m);
 499   else if (!dbus_pending_call_set_notify (pc, test_pending_call_store_reply,
 500         &m, NULL))
 501     g_error ("OOM");
 502
 503   while (m == NULL)
 504     test_main_context_iterate (f->ctx, TRUE);
 505
 506   ok = dbus_message_get_args (m, &f->e,
 507       DBUS_TYPE_INVALID);
 508   test_assert_no_error (&f->e);
 509   g_assert (ok);
 510
 511   dbus_pending_call_unref (pc);
 512   dbus_message_unref (m);
 513   m = NULL;
 514 }
 515
 516 /*
 517  * Test the side-effects of becoming a monitor.
 518  */
 519 static void
 520 test_become_monitor (Fixture *f,
 521     gconstpointer context)
 522 {
 523   DBusMessage *m;
 524   int ret;
 525   dbus_bool_t got_unique = FALSE, got_a = FALSE, got_b = FALSE, got_c = FALSE;
 526   dbus_bool_t lost_unique = FALSE, lost_a = FALSE, lost_b = FALSE, lost_c = FALSE;
 527
 528   if (f->address == NULL)
 529     return;
 530
 531   ret = dbus_bus_request_name (f->monitor, "com.example.A",
 532       DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
 533   test_assert_no_error (&f->e);
 534   g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
 535
 536   ret = dbus_bus_request_name (f->monitor, "com.example.B",
 537       DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
 538   test_assert_no_error (&f->e);
 539   g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
 540
 541   ret = dbus_bus_request_name (f->monitor, "com.example.C",
 542       DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
 543   test_assert_no_error (&f->e);
 544   g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
 545
 546   while (!got_unique || !got_a || !got_b || !got_c)
 547     {
 548       if (g_queue_is_empty (&f->monitored))
 549         test_main_context_iterate (f->ctx, TRUE);
 550
 551       while ((m = g_queue_pop_head (&f->monitored)) != NULL)
 552         {
 553           if (dbus_message_is_signal (m, DBUS_INTERFACE_DBUS,
 554                 "NameAcquired"))
 555             {
 556               const char *name;
 557               dbus_bool_t ok = dbus_message_get_args (m, &f->e,
 558                   DBUS_TYPE_STRING, &name,
 559                   DBUS_TYPE_INVALID);
 560
 561               g_assert_cmpstr (dbus_message_get_path (m), ==,
 562                   DBUS_PATH_DBUS);
 563
 564               test_assert_no_error (&f->e);
 565               g_assert (ok);
 566
 567               if (g_str_equal (name, f->monitor_name))
 568                 {
 569                   g_assert (!got_unique);
 570                   got_unique = TRUE;
 571                 }
 572               else if (g_str_equal (name, "com.example.A"))
 573                 {
 574                   g_assert (!got_a);
 575                   got_a = TRUE;
 576                 }
 577               else if (g_str_equal (name, "com.example.B"))
 578                 {
 579                   g_assert (!got_b);
 580                   got_b = TRUE;
 581                 }
 582               else
 583                 {
 584                   g_assert_cmpstr (name, ==, "com.example.C");
 585                   g_assert (!got_c);
 586                   got_c = TRUE;
 587                 }
 588             }
 589           else
 590             {
 591               g_error ("unexpected message %s.%s",
 592                   dbus_message_get_interface (m),
 593                   dbus_message_get_member (m));
 594             }
 595
 596           dbus_message_unref (m);
 597         }
 598     }
 599
 600   become_monitor (f);
 601
 602   while (!lost_unique || !lost_a || !lost_b || !lost_c)
 603     {
 604       if (g_queue_is_empty (&f->monitored))
 605         test_main_context_iterate (f->ctx, TRUE);
 606
 607       while ((m = g_queue_pop_head (&f->monitored)) != NULL)
 608         {
 609           if (dbus_message_is_signal (m, DBUS_INTERFACE_DBUS,
 610                 "NameLost"))
 611             {
 612               const char *name;
 613               dbus_bool_t ok = dbus_message_get_args (m, &f->e,
 614                   DBUS_TYPE_STRING, &name,
 615                   DBUS_TYPE_INVALID);
 616
 617               test_assert_no_error (&f->e);
 618               g_assert (ok);
 619
 620               if (g_str_equal (name, f->monitor_name))
 621                 {
 622                   g_assert (!lost_unique);
 623                   lost_unique = TRUE;
 624                 }
 625               else if (g_str_equal (name, "com.example.A"))
 626                 {
 627                   g_assert (!lost_a);
 628                   lost_a = TRUE;
 629                 }
 630               else if (g_str_equal (name, "com.example.B"))
 631                 {
 632                   g_assert (!lost_b);
 633                   lost_b = TRUE;
 634                 }
 635               else
 636                 {
 637                   g_assert_cmpstr (name, ==, "com.example.C");
 638                   g_assert (!lost_c);
 639                   lost_c = TRUE;
 640                 }
 641             }
 642           else
 643             {
 644               g_error ("unexpected message %s.%s",
 645                   dbus_message_get_interface (m),
 646                   dbus_message_get_member (m));
 647             }
 648
 649           dbus_message_unref (m);
 650         }
 651     }
 652
 653   /* Calling methods is forbidden; we get disconnected. */
 654   dbus_bus_add_match (f->monitor, "", &f->e);
 655   g_assert_cmpstr (f->e.name, ==, DBUS_ERROR_NO_REPLY);
 656   g_assert (!dbus_connection_get_is_connected (f->monitor));
 657
 658   while (TRUE)
 659     {
 660       if (g_queue_is_empty (&f->monitored))
 661         test_main_context_iterate (f->ctx, TRUE);
 662
 663       /* When we iterate all the connection's messages, we see ourselves
 664        * losing all our names, then we're disconnected. */
 665       while ((m = g_queue_pop_head (&f->monitored)) != NULL)
 666         {
 667           if (dbus_message_is_signal (m, DBUS_INTERFACE_LOCAL, "Disconnected"))
 668             {
 669               dbus_message_unref (m);
 670               goto disconnected;
 671             }
 672           else
 673             {
 674               g_error ("unexpected message %s.%s",
 675                   dbus_message_get_interface (m),
 676                   dbus_message_get_member (m));
 677             }
 678
 679           dbus_message_unref (m);
 680         }
 681     }
 682
 683 disconnected:
 684
 685   g_assert (lost_a);
 686   g_assert (lost_b);
 687   g_assert (lost_c);
 688 }
 689
 690 static void
 691 test_broadcast (Fixture *f,
 692     gconstpointer context)
 693 {
 694   DBusMessage *m;
 695
 696   if (f->address == NULL)
 697     return;
 698
 699   dbus_bus_add_match (f->recipient, "type='signal'", &f->e);
 700   test_assert_no_error (&f->e);
 701
 702   become_monitor (f);
 703
 704   m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal1");
 705   dbus_connection_send (f->sender, m, NULL);
 706   dbus_message_unref (m);
 707
 708   m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal2");
 709   dbus_connection_send (f->sender, m, NULL);
 710   dbus_message_unref (m);
 711
 712   m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal3");
 713   dbus_connection_send (f->sender, m, NULL);
 714   dbus_message_unref (m);
 715
 716   while (g_queue_get_length (&f->monitored) < 3)
 717     test_main_context_iterate (f->ctx, TRUE);
 718
 719   m = g_queue_pop_head (&f->monitored);
 720   assert_signal (m, f->sender_name, "/foo", "com.example.bar",
 721       "BroadcastSignal1", "", NULL);
 722   dbus_message_unref (m);
 723
 724   m = g_queue_pop_head (&f->monitored);
 725   assert_signal (m, f->sender_name, "/foo", "com.example.bar",
 726       "BroadcastSignal2", "", NULL);
 727   dbus_message_unref (m);
 728
 729   m = g_queue_pop_head (&f->monitored);
 730   assert_signal (m, f->sender_name, "/foo", "com.example.bar",
 731       "BroadcastSignal3", "", NULL);
 732   dbus_message_unref (m);
 733
 734   m = g_queue_pop_head (&f->monitored);
 735   g_assert (m == NULL);
 736 }
 737
 738 static void
 739 test_forbidden_broadcast (Fixture *f,
 740     gconstpointer context)
 741 {
 742   DBusMessage *m;
 743
 744   if (f->address == NULL)
 745     return;
 746
 747   dbus_bus_add_match (f->recipient, "type='signal'", &f->e);
 748   test_assert_no_error (&f->e);
 749
 750   become_monitor (f);
 751
 752   m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
 753       "BroadcastSignal1");
 754   dbus_connection_send (f->sender, m, NULL);
 755   dbus_message_unref (m);
 756
 757   m = dbus_message_new_signal ("/foo", "com.example.CannotReceive",
 758       "BroadcastSignal2");
 759   dbus_connection_send (f->sender, m, NULL);
 760   dbus_message_unref (m);
 761
 762   m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
 763       "BroadcastSignal3");
 764   dbus_connection_send (f->sender, m, NULL);
 765   dbus_message_unref (m);
 766
 767   while (g_queue_get_length (&f->monitored) < 6)
 768     test_main_context_iterate (f->ctx, TRUE);
 769
 770   m = g_queue_pop_head (&f->monitored);
 771   assert_signal (m, f->sender_name, "/foo", "com.example.CannotSend",
 772       "BroadcastSignal1", "", NULL);
 773   dbus_message_unref (m);
 774
 775   m = g_queue_pop_head (&f->monitored);
 776   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 777       DBUS_ERROR_ACCESS_DENIED);
 778   dbus_message_unref (m);
 779
 780   m = g_queue_pop_head (&f->monitored);
 781   assert_signal (m, f->sender_name, "/foo", "com.example.CannotReceive",
 782       "BroadcastSignal2", "", NULL);
 783   dbus_message_unref (m);
 784
 785   m = g_queue_pop_head (&f->monitored);
 786   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 787       DBUS_ERROR_ACCESS_DENIED);
 788   dbus_message_unref (m);
 789
 790   m = g_queue_pop_head (&f->monitored);
 791   assert_signal (m, f->sender_name, "/foo", "com.example.CannotSend",
 792       "BroadcastSignal3", "", NULL);
 793   dbus_message_unref (m);
 794
 795   m = g_queue_pop_head (&f->monitored);
 796   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 797       DBUS_ERROR_ACCESS_DENIED);
 798   dbus_message_unref (m);
 799
 800   m = g_queue_pop_head (&f->monitored);
 801   g_assert (m == NULL);
 802 }
 803
 804 static void
 805 test_unicast_signal (Fixture *f,
 806     gconstpointer context)
 807 {
 808   DBusMessage *m;
 809
 810   if (f->address == NULL)
 811     return;
 812
 813   become_monitor (f);
 814
 815   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal1");
 816   if (!dbus_message_set_destination (m, f->recipient_name))
 817     g_error ("OOM");
 818   dbus_connection_send (f->sender, m, NULL);
 819   dbus_message_unref (m);
 820
 821   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal2");
 822   if (!dbus_message_set_destination (m, f->recipient_name))
 823     g_error ("OOM");
 824   dbus_connection_send (f->sender, m, NULL);
 825   dbus_message_unref (m);
 826
 827   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal3");
 828   if (!dbus_message_set_destination (m, f->recipient_name))
 829     g_error ("OOM");
 830   dbus_connection_send (f->sender, m, NULL);
 831   dbus_message_unref (m);
 832
 833   while (g_queue_get_length (&f->monitored) < 3)
 834     test_main_context_iterate (f->ctx, TRUE);
 835
 836   m = g_queue_pop_head (&f->monitored);
 837   assert_signal (m, f->sender_name, "/foo",
 838       "com.example.bar", "UnicastSignal1", "", f->recipient_name);
 839   dbus_message_unref (m);
 840
 841   m = g_queue_pop_head (&f->monitored);
 842   assert_signal (m, f->sender_name, "/foo",
 843       "com.example.bar", "UnicastSignal2", "", f->recipient_name);
 844   dbus_message_unref (m);
 845
 846   m = g_queue_pop_head (&f->monitored);
 847   assert_signal (m, f->sender_name, "/foo",
 848       "com.example.bar", "UnicastSignal3", "", f->recipient_name);
 849   dbus_message_unref (m);
 850
 851   m = g_queue_pop_head (&f->monitored);
 852   g_assert (m == NULL);
 853 }
 854
 855 static void
 856 test_forbidden (Fixture *f,
 857     gconstpointer context)
 858 {
 859   DBusMessage *m;
 860
 861   if (f->address == NULL)
 862     return;
 863
 864   become_monitor (f);
 865
 866   m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
 867       "UnicastSignal1");
 868   if (!dbus_message_set_destination (m, f->recipient_name))
 869     g_error ("OOM");
 870   dbus_connection_send (f->sender, m, NULL);
 871   dbus_message_unref (m);
 872
 873   m = dbus_message_new_signal ("/foo", "com.example.CannotReceive",
 874       "UnicastSignal2");
 875   if (!dbus_message_set_destination (m, f->recipient_name))
 876     g_error ("OOM");
 877   dbus_connection_send (f->sender, m, NULL);
 878   dbus_message_unref (m);
 879
 880   m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
 881       "UnicastSignal3");
 882   if (!dbus_message_set_destination (m, f->recipient_name))
 883     g_error ("OOM");
 884   dbus_connection_send (f->sender, m, NULL);
 885   dbus_message_unref (m);
 886
 887   while (g_queue_get_length (&f->monitored) < 6)
 888     test_main_context_iterate (f->ctx, TRUE);
 889
 890   m = g_queue_pop_head (&f->monitored);
 891   assert_signal (m, f->sender_name, "/foo",
 892       "com.example.CannotSend", "UnicastSignal1", "", f->recipient_name);
 893   dbus_message_unref (m);
 894
 895   m = g_queue_pop_head (&f->monitored);
 896   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 897       DBUS_ERROR_ACCESS_DENIED);
 898   dbus_message_unref (m);
 899
 900   m = g_queue_pop_head (&f->monitored);
 901   assert_signal (m, f->sender_name, "/foo",
 902       "com.example.CannotReceive", "UnicastSignal2", "", f->recipient_name);
 903   dbus_message_unref (m);
 904
 905   m = g_queue_pop_head (&f->monitored);
 906   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 907       DBUS_ERROR_ACCESS_DENIED);
 908   dbus_message_unref (m);
 909
 910   m = g_queue_pop_head (&f->monitored);
 911   assert_signal (m, f->sender_name, "/foo",
 912       "com.example.CannotSend", "UnicastSignal3", "", f->recipient_name);
 913   dbus_message_unref (m);
 914
 915   m = g_queue_pop_head (&f->monitored);
 916   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
 917       DBUS_ERROR_ACCESS_DENIED);
 918   dbus_message_unref (m);
 919
 920   m = g_queue_pop_head (&f->monitored);
 921   g_assert (m == NULL);
 922 }
 923
 924 static void
 925 test_method_call (Fixture *f,
 926     gconstpointer context)
 927 {
 928   DBusMessage *m;
 929
 930   if (f->address == NULL)
 931     return;
 932
 933   become_monitor (f);
 934
 935   /* regression test for
 936    * https://bugs.freedesktop.org/show_bug.cgi?id=90952 */
 937   m = dbus_message_new_method_call (f->recipient_name, "/foo",
 938       DBUS_INTERFACE_PEER, "Ping");
 939   dbus_connection_send (f->sender, m, NULL);
 940   dbus_message_unref (m);
 941
 942   while (g_queue_get_length (&f->monitored) < 2)
 943     test_main_context_iterate (f->ctx, TRUE);
 944
 945   m = g_queue_pop_head (&f->monitored);
 946   assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
 947       DBUS_INTERFACE_PEER, "Ping", "");
 948   dbus_message_unref (m);
 949
 950   m = g_queue_pop_head (&f->monitored);
 951   assert_method_reply (m, f->recipient_name, f->sender_name, "");
 952   dbus_message_unref (m);
 953
 954   m = g_queue_pop_head (&f->monitored);
 955   g_assert (m == NULL);
 956
 957   m = dbus_message_new_method_call (f->recipient_name, "/foo", "com.example.bar",
 958       "Call1");
 959   dbus_connection_send (f->sender, m, NULL);
 960   dbus_message_unref (m);
 961
 962   while (g_queue_get_length (&f->monitored) < 2)
 963     test_main_context_iterate (f->ctx, TRUE);
 964
 965   m = g_queue_pop_head (&f->monitored);
 966   assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
 967       "com.example.bar", "Call1", "");
 968   dbus_message_unref (m);
 969
 970   m = g_queue_pop_head (&f->monitored);
 971   assert_error_reply (m, f->recipient_name, f->sender_name,
 972       DBUS_ERROR_UNKNOWN_METHOD);
 973   dbus_message_unref (m);
 974
 975   m = g_queue_pop_head (&f->monitored);
 976   g_assert (m == NULL);
 977 }
 978
 979 static void
 980 test_forbidden_method_call (Fixture *f,
 981     gconstpointer context)
 982 {
 983   DBusMessage *m;
 984
 985   if (f->address == NULL)
 986     return;
 987
 988   become_monitor (f);
 989
 990   m = dbus_message_new_method_call (f->recipient_name, "/foo",
 991       "com.example.CannotSend", "Call1");
 992   dbus_connection_send (f->sender, m, NULL);
 993   dbus_message_unref (m);
 994
 995   while (g_queue_get_length (&f->monitored) < 2)
 996     test_main_context_iterate (f->ctx, TRUE);
 997
 998   m = g_queue_pop_head (&f->monitored);
 999   assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
1000       "com.example.CannotSend", "Call1", "");
1001   dbus_message_unref (m);
1002
1003   m = g_queue_pop_head (&f->monitored);
1004   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1005       DBUS_ERROR_ACCESS_DENIED);
1006   dbus_message_unref (m);
1007
1008   m = g_queue_pop_head (&f->monitored);
1009   g_assert (m == NULL);
1010
1011   m = dbus_message_new_method_call (f->recipient_name, "/foo",
1012       "com.example.CannotReceive", "Call2");
1013   dbus_connection_send (f->sender, m, NULL);
1014   dbus_message_unref (m);
1015
1016   while (g_queue_get_length (&f->monitored) < 2)
1017     test_main_context_iterate (f->ctx, TRUE);
1018
1019   m = g_queue_pop_head (&f->monitored);
1020   assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
1021       "com.example.CannotReceive", "Call2", "");
1022   dbus_message_unref (m);
1023
1024   m = g_queue_pop_head (&f->monitored);
1025   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1026       DBUS_ERROR_ACCESS_DENIED);
1027   dbus_message_unref (m);
1028
1029   m = g_queue_pop_head (&f->monitored);
1030   g_assert (m == NULL);
1031 }
1032
1033 static void
1034 test_dbus_daemon (Fixture *f,
1035     gconstpointer context)
1036 {
1037   DBusMessage *m;
1038   int res;
1039
1040   if (f->address == NULL)
1041     return;
1042
1043   become_monitor (f);
1044
1045   res = dbus_bus_request_name (f->sender, "com.example.Sender",
1046       DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
1047   test_assert_no_error (&f->e);
1048   g_assert_cmpint (res, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
1049
1050   res = dbus_bus_release_name (f->sender, "com.example.Sender", &f->e);
1051   test_assert_no_error (&f->e);
1052   g_assert_cmpint (res, ==, DBUS_RELEASE_NAME_REPLY_RELEASED);
1053
1054   while (g_queue_get_length (&f->monitored) < 8)
1055     test_main_context_iterate (f->ctx, TRUE);
1056
1057   m = g_queue_pop_head (&f->monitored);
1058   assert_method_call (m, f->sender_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1059       DBUS_INTERFACE_DBUS, "RequestName", "su");
1060   dbus_message_unref (m);
1061
1062   m = g_queue_pop_head (&f->monitored);
1063   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1064       "NameOwnerChanged", "sss", NULL);
1065   dbus_message_unref (m);
1066
1067   /* FIXME: should we get this? */
1068   m = g_queue_pop_head (&f->monitored);
1069   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1070       "NameAcquired", "s", f->sender_name);
1071   dbus_message_unref (m);
1072
1073   m = g_queue_pop_head (&f->monitored);
1074   assert_method_reply (m, DBUS_SERVICE_DBUS, f->sender_name, "u");
1075   dbus_message_unref (m);
1076
1077   m = g_queue_pop_head (&f->monitored);
1078   assert_method_call (m, f->sender_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1079       DBUS_INTERFACE_DBUS, "ReleaseName", "s");
1080   dbus_message_unref (m);
1081
1082   /* FIXME: should we get this? */
1083   m = g_queue_pop_head (&f->monitored);
1084   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1085       "NameLost", "s", f->sender_name);
1086   dbus_message_unref (m);
1087
1088   m = g_queue_pop_head (&f->monitored);
1089   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1090       "NameOwnerChanged", "sss", NULL);
1091   dbus_message_unref (m);
1092
1093   m = g_queue_pop_head (&f->monitored);
1094   assert_method_reply (m, DBUS_SERVICE_DBUS, f->sender_name, "u");
1095   dbus_message_unref (m);
1096
1097   m = g_queue_pop_head (&f->monitored);
1098   g_assert (m == NULL);
1099 }
1100
1101 static void
1102 test_selective (Fixture *f,
1103     gconstpointer context)
1104 {
1105   DBusMessage *m;
1106
1107   if (f->address == NULL)
1108     return;
1109
1110   /* Match rules added before becoming a monitor should be cleared:
1111    * if they weren't, this test would get Interesting twice, then Tedious,
1112    * and only see Fun after that. */
1113   dbus_bus_add_match (f->monitor,
1114       "eavesdrop='true',interface='com.example.Interesting'", &f->e);
1115   test_assert_no_error (&f->e);
1116   dbus_bus_add_match (f->monitor,
1117       "eavesdrop='true',interface='com.example.Tedious'", &f->e);
1118   test_assert_no_error (&f->e);
1119
1120   become_monitor (f);
1121
1122   m = dbus_message_new_signal ("/foo", "com.example.Interesting",
1123       "UnicastSignal1");
1124   if (!dbus_message_set_destination (m, f->recipient_name))
1125     g_error ("OOM");
1126   dbus_connection_send (f->sender, m, NULL);
1127   dbus_message_unref (m);
1128
1129   m = dbus_message_new_signal ("/foo", "com.example.Tedious",
1130       "UnicastSignal2");
1131   if (!dbus_message_set_destination (m, f->recipient_name))
1132     g_error ("OOM");
1133   dbus_connection_send (f->sender, m, NULL);
1134   dbus_message_unref (m);
1135
1136   m = dbus_message_new_signal ("/foo", "com.example.Fun",
1137       "UnicastSignal3");
1138   if (!dbus_message_set_destination (m, f->recipient_name))
1139     g_error ("OOM");
1140   dbus_connection_send (f->sender, m, NULL);
1141   dbus_message_unref (m);
1142
1143   while (g_queue_get_length (&f->monitored) < 2)
1144     test_main_context_iterate (f->ctx, TRUE);
1145
1146   /* We get the interesting signal and the fun signal, but not the tedious
1147    * signal. */
1148
1149   m = g_queue_pop_head (&f->monitored);
1150   assert_signal (m, f->sender_name, "/foo",
1151       "com.example.Interesting", "UnicastSignal1", "", f->recipient_name);
1152   dbus_message_unref (m);
1153
1154   m = g_queue_pop_head (&f->monitored);
1155   assert_signal (m, f->sender_name, "/foo",
1156       "com.example.Fun", "UnicastSignal3", "", f->recipient_name);
1157   dbus_message_unref (m);
1158
1159   m = g_queue_pop_head (&f->monitored);
1160   g_assert (m == NULL);
1161 }
1162
1163 #ifdef DBUS_UNIX
1164 /* currently only used for the systemd activation test */
1165 static void
1166 expect_new_connection (Fixture *f)
1167 {
1168   DBusMessage *m;
1169
1170   while (g_queue_get_length (&f->monitored) < 4)
1171     test_main_context_iterate (f->ctx, TRUE);
1172
1173   m = g_queue_pop_head (&f->monitored);
1174   assert_hello (m);
1175   dbus_message_unref (m);
1176
1177   m = g_queue_pop_head (&f->monitored);
1178   assert_hello_reply (m);
1179   dbus_message_unref (m);
1180
1181   m = g_queue_pop_head (&f->monitored);
1182   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1183       "NameOwnerChanged", "sss", NULL);
1184   dbus_message_unref (m);
1185
1186   m = g_queue_pop_head (&f->monitored);
1187   assert_name_acquired (m);
1188   dbus_message_unref (m);
1189 }
1190
1191 /* currently only used for the systemd activation test */
1192 static void
1193 take_well_known_name (Fixture *f,
1194     DBusConnection *connection,
1195     const char *name)
1196 {
1197   int ret;
1198
1199   ret = dbus_bus_request_name (connection, name,
1200       DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
1201   test_assert_no_error (&f->e);
1202   g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
1203 }
1204
1205 /* currently only used for the systemd activation test */
1206 static void
1207 expect_take_well_known_name (Fixture *f,
1208     DBusConnection *connection,
1209     const char *name)
1210 {
1211   DBusMessage *m;
1212   const char *connection_name = dbus_bus_get_unique_name (connection);
1213
1214   while (g_queue_get_length (&f->monitored) < 4)
1215     test_main_context_iterate (f->ctx, TRUE);
1216
1217   m = g_queue_pop_head (&f->monitored);
1218   assert_method_call (m, connection_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1219       DBUS_INTERFACE_DBUS, "RequestName", "su");
1220   dbus_message_unref (m);
1221
1222   m = g_queue_pop_head (&f->monitored);
1223   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1224       "NameOwnerChanged", "sss", NULL);
1225   dbus_message_unref (m);
1226
1227   m = g_queue_pop_head (&f->monitored);
1228   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1229       "NameAcquired", "s", connection_name);
1230   dbus_message_unref (m);
1231
1232   m = g_queue_pop_head (&f->monitored);
1233   assert_method_reply (m, DBUS_SERVICE_DBUS, connection_name, "u");
1234   dbus_message_unref (m);
1235 }
1236
1237 static void
1238 test_activation (Fixture *f,
1239     gconstpointer context)
1240 {
1241   DBusMessage *m;
1242
1243   if (f->address == NULL)
1244     return;
1245
1246   become_monitor (f);
1247
1248   /* The sender sends a message to an activatable service. */
1249   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal1");
1250   if (!dbus_message_set_destination (m, "com.example.SystemdActivatable1"))
1251     g_error ("OOM");
1252   dbus_connection_send (f->sender, m, NULL);
1253   dbus_message_unref (m);
1254
1255   /* We observe the activation request, and the message that caused it,
1256    * before systemd has even joined the bus. */
1257   while (g_queue_get_length (&f->monitored) < 2)
1258     test_main_context_iterate (f->ctx, TRUE);
1259
1260   m = g_queue_pop_head (&f->monitored);
1261   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1262       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1263       "org.freedesktop.systemd1");
1264   dbus_message_unref (m);
1265   m = g_queue_pop_head (&f->monitored);
1266   assert_signal (m, f->sender_name, "/foo",
1267       "com.example.bar", "UnicastSignal1", "",
1268       "com.example.SystemdActivatable1");
1269   dbus_message_unref (m);
1270
1271   /* The fake systemd connects to the bus. */
1272   f->systemd = test_connect_to_bus (f->ctx, f->address);
1273   if (!dbus_connection_add_filter (f->systemd, systemd_filter, f, NULL))
1274     g_error ("OOM");
1275   f->systemd_name = dbus_bus_get_unique_name (f->systemd);
1276
1277   expect_new_connection (f);
1278   take_well_known_name (f, f->systemd, "org.freedesktop.systemd1");
1279   expect_take_well_known_name (f, f->systemd, "org.freedesktop.systemd1");
1280
1281   /* It gets its activation request. */
1282   while (f->systemd_message == NULL)
1283     test_main_context_iterate (f->ctx, TRUE);
1284
1285   m = f->systemd_message;
1286   f->systemd_message = NULL;
1287   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1288       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1289       "org.freedesktop.systemd1");
1290   dbus_message_unref (m);
1291
1292   /* systemd starts the activatable service. */
1293   f->activated = test_connect_to_bus (f->ctx, f->address);
1294   if (!dbus_connection_add_filter (f->activated, activated_filter,
1295         f, NULL))
1296     g_error ("OOM");
1297   f->activated_name = dbus_bus_get_unique_name (f->activated);
1298
1299   expect_new_connection (f);
1300   take_well_known_name (f, f->activated, "com.example.SystemdActivatable1");
1301   expect_take_well_known_name (f, f->activated,
1302       "com.example.SystemdActivatable1");
1303
1304   /* The message is delivered to the activatable service. */
1305   while (f->activated_message == NULL)
1306     test_main_context_iterate (f->ctx, TRUE);
1307
1308   m = f->activated_message;
1309   f->activated_message = NULL;
1310   assert_signal (m, f->sender_name, "/foo",
1311       "com.example.bar", "UnicastSignal1", "",
1312       "com.example.SystemdActivatable1");
1313   dbus_message_unref (m);
1314
1315   /* The sender sends a message to a different activatable service. */
1316   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal2");
1317   if (!dbus_message_set_destination (m, "com.example.SystemdActivatable2"))
1318     g_error ("OOM");
1319   dbus_connection_send (f->sender, m, NULL);
1320   dbus_message_unref (m);
1321
1322   /* This time systemd is already ready for it. */
1323   while (g_queue_get_length (&f->monitored) < 2 ||
1324       f->systemd_message == NULL)
1325     test_main_context_iterate (f->ctx, TRUE);
1326
1327   m = f->systemd_message;
1328   f->systemd_message = NULL;
1329   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1330       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1331       "org.freedesktop.systemd1");
1332   dbus_message_unref (m);
1333
1334   /* The monitor sees the activation request and the signal that
1335    * prompted it.*/
1336   m = g_queue_pop_head (&f->monitored);
1337   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1338       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1339       "org.freedesktop.systemd1");
1340   dbus_message_unref (m);
1341   m = g_queue_pop_head (&f->monitored);
1342   assert_signal (m, f->sender_name, "/foo",
1343       "com.example.bar", "UnicastSignal2", "",
1344       "com.example.SystemdActivatable2");
1345   dbus_message_unref (m);
1346
1347   /* The activatable service takes its name. Here I'm faking it by using
1348    * an existing connection. */
1349   take_well_known_name (f, f->activated, "com.example.SystemdActivatable2");
1350
1351   /* The message is delivered to the activatable service.
1352    * Implementation detail: the monitor sees this happen before it even
1353    * sees that the name request happened, which is pretty odd. */
1354   while (f->activated_message == NULL)
1355     test_main_context_iterate (f->ctx, TRUE);
1356
1357   m = f->activated_message;
1358   f->activated_message = NULL;
1359   assert_signal (m, f->sender_name, "/foo",
1360       "com.example.bar", "UnicastSignal2", "",
1361       "com.example.SystemdActivatable2");
1362   dbus_message_unref (m);
1363
1364   expect_take_well_known_name (f, f->activated,
1365       "com.example.SystemdActivatable2");
1366
1367   /* A third activation. */
1368   m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal3");
1369   if (!dbus_message_set_destination (m, "com.example.SystemdActivatable3"))
1370     g_error ("OOM");
1371   dbus_connection_send (f->sender, m, NULL);
1372   dbus_message_unref (m);
1373
1374   /* Once again, we see the activation request and the reason. */
1375   while (g_queue_get_length (&f->monitored) < 2)
1376     test_main_context_iterate (f->ctx, TRUE);
1377
1378   m = g_queue_pop_head (&f->monitored);
1379   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1380       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1381       "org.freedesktop.systemd1");
1382   dbus_message_unref (m);
1383   m = g_queue_pop_head (&f->monitored);
1384   assert_signal (m, f->sender_name, "/foo",
1385       "com.example.bar", "UnicastSignal3", "",
1386       "com.example.SystemdActivatable3");
1387   dbus_message_unref (m);
1388
1389   /* systemd gets the request too. */
1390   while (f->systemd_message == NULL)
1391     test_main_context_iterate (f->ctx, TRUE);
1392
1393   m = f->systemd_message;
1394   f->systemd_message = NULL;
1395   assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1396       "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1397       "org.freedesktop.systemd1");
1398   dbus_message_unref (m);
1399
1400   /* This time activation fails */
1401   m = dbus_message_new_signal ("/org/freedesktop/systemd1",
1402       "org.freedesktop.systemd1.Activator", "ActivationFailure");
1403
1404   do
1405     {
1406       const char *unit = "dbus-com.example.SystemdActivatable3.service";
1407       const char *error_name = "com.example.Nope";
1408       const char *error_message = "Computer says no";
1409
1410       if (!dbus_message_append_args (m,
1411             DBUS_TYPE_STRING, &unit,
1412             DBUS_TYPE_STRING, &error_name,
1413             DBUS_TYPE_STRING, &error_message,
1414             DBUS_TYPE_INVALID))
1415         g_error ("OOM");
1416     }
1417   while (0);
1418
1419   if (!dbus_message_set_destination (m, "org.freedesktop.DBus"))
1420     g_error ("OOM");
1421   dbus_connection_send (f->systemd, m, NULL);
1422   dbus_message_unref (m);
1423
1424   /* The monitor sees activation fail */
1425
1426   /* Once again, we see the activation request and the reason. */
1427   while (g_queue_get_length (&f->monitored) < 1)
1428     test_main_context_iterate (f->ctx, TRUE);
1429
1430   m = g_queue_pop_head (&f->monitored);
1431   assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1432       "com.example.Nope");
1433   dbus_message_unref (m);
1434 }
1435 #endif /* DBUS_UNIX */
1436
1437 static void
1438 teardown (Fixture *f,
1439     gconstpointer context G_GNUC_UNUSED)
1440 {
1441   dbus_error_free (&f->e);
1442   g_clear_error (&f->ge);
1443
1444   if (f->monitor != NULL)
1445     {
1446       dbus_connection_remove_filter (f->monitor, monitor_filter, f);
1447       dbus_connection_close (f->monitor);
1448       dbus_connection_unref (f->monitor);
1449       f->monitor = NULL;
1450     }
1451
1452   if (f->sender != NULL)
1453     {
1454       dbus_connection_close (f->sender);
1455       dbus_connection_unref (f->sender);
1456       f->sender = NULL;
1457     }
1458
1459   if (f->recipient != NULL)
1460     {
1461       dbus_connection_remove_filter (f->recipient, recipient_filter, f);
1462       dbus_connection_close (f->recipient);
1463       dbus_connection_unref (f->recipient);
1464       f->recipient = NULL;
1465     }
1466
1467   if (f->systemd != NULL)
1468     {
1469       dbus_connection_remove_filter (f->systemd, systemd_filter, f);
1470       dbus_connection_close (f->systemd);
1471       dbus_connection_unref (f->systemd);
1472       f->systemd = NULL;
1473     }
1474
1475   if (f->activated != NULL)
1476     {
1477       dbus_connection_remove_filter (f->activated, activated_filter, f);
1478       dbus_connection_close (f->activated);
1479       dbus_connection_unref (f->activated);
1480       f->activated = NULL;
1481     }
1482
1483   test_kill_pid (f->daemon_pid);
1484   g_spawn_close_pid (f->daemon_pid);
1485
1486   test_main_context_unref (f->ctx);
1487
1488   g_queue_foreach (&f->monitored, (GFunc) dbus_message_unref, NULL);
1489   g_queue_clear (&f->monitored);
1490
1491   g_free (f->address);
1492 }
1493
1494 int
1495 main (int argc,
1496     char **argv)
1497 {
1498   test_init (&argc, &argv);
1499
1500   g_test_add ("/monitor/become", Fixture, &side_effects_config,
1501       setup, test_become_monitor, teardown);
1502   g_test_add ("/monitor/broadcast", Fixture, NULL,
1503       setup, test_broadcast, teardown);
1504   g_test_add ("/monitor/forbidden-broadcast", Fixture, &forbidding_config,
1505       setup, test_forbidden_broadcast, teardown);
1506   g_test_add ("/monitor/unicast-signal", Fixture, NULL,
1507       setup, test_unicast_signal, teardown);
1508   g_test_add ("/monitor/forbidden", Fixture, &forbidding_config,
1509       setup, test_forbidden, teardown);
1510   g_test_add ("/monitor/method-call", Fixture, NULL,
1511       setup, test_method_call, teardown);
1512   g_test_add ("/monitor/forbidden-method", Fixture, &forbidding_config,
1513       setup, test_forbidden_method_call, teardown);
1514   g_test_add ("/monitor/dbus-daemon", Fixture, NULL,
1515       setup, test_dbus_daemon, teardown);
1516   g_test_add ("/monitor/selective", Fixture, &selective_config,
1517       setup, test_selective, teardown);
1518   g_test_add ("/monitor/wildcard", Fixture, &wildcard_config,
1519       setup, test_unicast_signal, teardown);
1520   g_test_add ("/monitor/no-rule", Fixture, &no_rules_config,
1521       setup, test_unicast_signal, teardown);
1522   g_test_add ("/monitor/eavesdrop", Fixture, &eavesdrop_config,
1523       setup, test_unicast_signal, teardown);
1524   g_test_add ("/monitor/no-eavesdrop", Fixture, &no_eavesdrop_config,
1525       setup, test_unicast_signal, teardown);
1526
1527 #ifdef DBUS_UNIX
1528   /* this relies on the systemd activation code path */
1529   g_test_add ("/monitor/activation", Fixture, &fake_systemd_config,
1530       setup, test_activation, teardown);
1531 #endif
1532
1533   return g_test_run ();
1534 }