bus/dispatch.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dispatch.c  Message dispatcher
   3  *
   4  * Copyright (C) 2003  CodeFactory AB
   5  * Copyright (C) 2003, 2004, 2005  Red Hat, Inc.
   6  * Copyright (C) 2004  Imendio HB
   7  *
   8  * Licensed under the Academic Free License version 2.1
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #include <config.h>
  27 #include "dispatch.h"
  28 #include "connection.h"
  29 #include "driver.h"
  30 #include "services.h"
  31 #include "activation.h"
  32 #include "utils.h"
  33 #include "bus.h"
  34 #include "signals.h"
  35 #include "test.h"
  36 #include <dbus/dbus-internals.h>
  37 #include <string.h>
  38
  39 #ifdef HAVE_UNIX_FD_PASSING
  40 #include <dbus/dbus-sysdeps-unix.h>
  41 #include <unistd.h>
  42 #endif
  43
  44 /* This is hard-coded in the files in valid-config-files-*. We have to use
  45  * the debug-pipe transport because the tests in this file require that
  46  * dbus_connection_open_private() does not block. */
  47 #define TEST_DEBUG_PIPE "debug-pipe:name=test-server"
  48
  49 static dbus_bool_t
  50 send_one_message (DBusConnection *connection,
  51                   BusContext     *context,
  52                   DBusConnection *sender,
  53                   DBusConnection *addressed_recipient,
  54                   DBusMessage    *message,
  55                   BusTransaction *transaction,
  56                   DBusError      *error)
  57 {
  58   if (!bus_context_check_security_policy (context, transaction,
  59                                           sender,
  60                                           addressed_recipient,
  61                                           connection,
  62                                           message,
  63                                           NULL))
  64     return TRUE; /* silently don't send it */
  65
  66   if (dbus_message_contains_unix_fds(message) &&
  67       !dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD))
  68     return TRUE; /* silently don't send it */
  69
  70   if (!bus_transaction_send (transaction,
  71                              connection,
  72                              message))
  73     {
  74       BUS_SET_OOM (error);
  75       return FALSE;
  76     }
  77
  78   return TRUE;
  79 }
  80
  81 dbus_bool_t
  82 bus_dispatch_matches (BusTransaction *transaction,
  83                       DBusConnection *sender,
  84                       DBusConnection *addressed_recipient,
  85                       DBusMessage    *message,
  86                       DBusError      *error)
  87 {
  88   DBusError tmp_error;
  89   BusConnections *connections;
  90   DBusList *recipients;
  91   BusMatchmaker *matchmaker;
  92   DBusList *link;
  93   BusContext *context;
  94
  95   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  96
  97   /* sender and recipient can both be NULL for the bus driver,
  98    * or for signals with no particular recipient
  99    */
 100
 101   _dbus_assert (sender == NULL || bus_connection_is_active (sender));
 102   _dbus_assert (dbus_message_get_sender (message) != NULL);
 103
 104   context = bus_transaction_get_context (transaction);
 105
 106   /* First, send the message to the addressed_recipient, if there is one. */
 107   if (addressed_recipient != NULL)
 108     {
 109       if (!bus_context_check_security_policy (context, transaction,
 110                                               sender, addressed_recipient,
 111                                               addressed_recipient,
 112                                               message, error))
 113         return FALSE;
 114
 115       if (dbus_message_contains_unix_fds (message) &&
 116           !dbus_connection_can_send_type (addressed_recipient,
 117                                           DBUS_TYPE_UNIX_FD))
 118         {
 119           dbus_set_error (error,
 120                           DBUS_ERROR_NOT_SUPPORTED,
 121                           "Tried to send message with Unix file descriptors"
 122                           "to a client that doesn't support that.");
 123           return FALSE;
 124       }
 125
 126       /* Dispatch the message */
 127       if (!bus_transaction_send (transaction, addressed_recipient, message))
 128         {
 129           BUS_SET_OOM (error);
 130           return FALSE;
 131         }
 132     }
 133
 134   /* Now dispatch to others who look interested in this message */
 135   connections = bus_transaction_get_connections (transaction);
 136   dbus_error_init (&tmp_error);
 137   matchmaker = bus_context_get_matchmaker (context);
 138
 139   recipients = NULL;
 140   if (!bus_matchmaker_get_recipients (matchmaker, connections,
 141                                       sender, addressed_recipient, message,
 142                                       &recipients))
 143     {
 144       BUS_SET_OOM (error);
 145       return FALSE;
 146     }
 147
 148   link = _dbus_list_get_first_link (&recipients);
 149   while (link != NULL)
 150     {
 151       DBusConnection *dest;
 152
 153       dest = link->data;
 154
 155       if (!send_one_message (dest, context, sender, addressed_recipient,
 156                              message, transaction, &tmp_error))
 157         break;
 158
 159       link = _dbus_list_get_next_link (&recipients, link);
 160     }
 161
 162   _dbus_list_clear (&recipients);
 163
 164   if (dbus_error_is_set (&tmp_error))
 165     {
 166       dbus_move_error (&tmp_error, error);
 167       return FALSE;
 168     }
 169   else
 170     return TRUE;
 171 }
 172
 173 static DBusHandlerResult
 174 bus_dispatch (DBusConnection *connection,
 175               DBusMessage    *message)
 176 {
 177   const char *sender, *service_name;
 178   DBusError error;
 179   BusTransaction *transaction;
 180   BusContext *context;
 181   DBusHandlerResult result;
 182   DBusConnection *addressed_recipient;
 183
 184   result = DBUS_HANDLER_RESULT_HANDLED;
 185
 186   transaction = NULL;
 187   addressed_recipient = NULL;
 188   dbus_error_init (&error);
 189
 190   context = bus_connection_get_context (connection);
 191   _dbus_assert (context != NULL);
 192
 193   /* If we can't even allocate an OOM error, we just go to sleep
 194    * until we can.
 195    */
 196   while (!bus_connection_preallocate_oom_error (connection))
 197     _dbus_wait_for_memory ();
 198
 199   /* Ref connection in case we disconnect it at some point in here */
 200   dbus_connection_ref (connection);
 201
 202   service_name = dbus_message_get_destination (message);
 203
 204 #ifdef DBUS_ENABLE_VERBOSE_MODE
 205   {
 206     const char *interface_name, *member_name, *error_name;
 207
 208     interface_name = dbus_message_get_interface (message);
 209     member_name = dbus_message_get_member (message);
 210     error_name = dbus_message_get_error_name (message);
 211
 212     _dbus_verbose ("DISPATCH: %s %s %s to %s\n",
 213                    interface_name ? interface_name : "(no interface)",
 214                    member_name ? member_name : "(no member)",
 215                    error_name ? error_name : "(no error name)",
 216                    service_name ? service_name : "peer");
 217   }
 218 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 219
 220   /* If service_name is NULL, if it's a signal we send it to all
 221    * connections with a match rule. If it's not a signal, there
 222    * are some special cases here but mostly we just bail out.
 223    */
 224   if (service_name == NULL)
 225     {
 226       if (dbus_message_is_signal (message,
 227                                   DBUS_INTERFACE_LOCAL,
 228                                   "Disconnected"))
 229         {
 230           bus_connection_disconnected (connection);
 231           goto out;
 232         }
 233
 234       if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)
 235         {
 236           /* DBusConnection also handles some of these automatically, we leave
 237            * it to do so.
 238            */
 239           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 240           goto out;
 241         }
 242     }
 243
 244   /* Create our transaction */
 245   transaction = bus_transaction_new (context);
 246   if (transaction == NULL)
 247     {
 248       BUS_SET_OOM (&error);
 249       goto out;
 250     }
 251
 252   /* Assign a sender to the message */
 253   if (bus_connection_is_active (connection))
 254     {
 255       sender = bus_connection_get_name (connection);
 256       _dbus_assert (sender != NULL);
 257
 258       if (!dbus_message_set_sender (message, sender))
 259         {
 260           BUS_SET_OOM (&error);
 261           goto out;
 262         }
 263
 264       /* We need to refetch the service name here, because
 265        * dbus_message_set_sender can cause the header to be
 266        * reallocated, and thus the service_name pointer will become
 267        * invalid.
 268        */
 269       service_name = dbus_message_get_destination (message);
 270     }
 271
 272   if (service_name &&
 273       strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */
 274     {
 275       if (!bus_context_check_security_policy (context, transaction,
 276                                               connection, NULL, NULL, message, &error))
 277         {
 278           _dbus_verbose ("Security policy rejected message\n");
 279           goto out;
 280         }
 281
 282       _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_DBUS);
 283       if (!bus_driver_handle_message (connection, transaction, message, &error))
 284         goto out;
 285     }
 286   else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */
 287     {
 288       _dbus_verbose ("Received message from non-registered client. Disconnecting.\n");
 289       dbus_connection_close (connection);
 290       goto out;
 291     }
 292   else if (service_name != NULL) /* route to named service */
 293     {
 294       DBusString service_string;
 295       BusService *service;
 296       BusRegistry *registry;
 297
 298       _dbus_assert (service_name != NULL);
 299
 300       registry = bus_connection_get_registry (connection);
 301
 302       _dbus_string_init_const (&service_string, service_name);
 303       service = bus_registry_lookup (registry, &service_string);
 304
 305       if (service == NULL && dbus_message_get_auto_start (message))
 306         {
 307           BusActivation *activation;
 308           /* We can't do the security policy check here, since the addressed
 309            * recipient service doesn't exist yet. We do it before sending the
 310            * message after the service has been created.
 311            */
 312           activation = bus_connection_get_activation (connection);
 313
 314           if (!bus_activation_activate_service (activation, connection, transaction, TRUE,
 315                                                 message, service_name, &error))
 316             {
 317               _DBUS_ASSERT_ERROR_IS_SET (&error);
 318               _dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name);
 319               goto out;
 320             }
 321
 322           goto out;
 323         }
 324       else if (service == NULL)
 325         {
 326           dbus_set_error (&error,
 327                           DBUS_ERROR_NAME_HAS_NO_OWNER,
 328                           "Name \"%s\" does not exist",
 329                           service_name);
 330           goto out;
 331         }
 332       else
 333         {
 334           addressed_recipient = bus_service_get_primary_owners_connection (service);
 335           _dbus_assert (addressed_recipient != NULL);
 336         }
 337     }
 338
 339   /* Now send the message to its destination (or not, if
 340    * addressed_recipient == NULL), and match it against other connections'
 341    * match rules.
 342    */
 343   if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))
 344     goto out;
 345
 346  out:
 347   if (dbus_error_is_set (&error))
 348     {
 349       if (!dbus_connection_get_is_connected (connection))
 350         {
 351           /* If we disconnected it, we won't bother to send it any error
 352            * messages.
 353            */
 354           _dbus_verbose ("Not sending error to connection we disconnected\n");
 355         }
 356       else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
 357         {
 358           bus_connection_send_oom_error (connection, message);
 359
 360           /* cancel transaction due to OOM */
 361           if (transaction != NULL)
 362             {
 363               bus_transaction_cancel_and_free (transaction);
 364               transaction = NULL;
 365             }
 366         }
 367       else
 368         {
 369           /* Try to send the real error, if no mem to do that, send
 370            * the OOM error
 371            */
 372           _dbus_assert (transaction != NULL);
 373           if (!bus_transaction_send_error_reply (transaction, connection,
 374                                                  &error, message))
 375             {
 376               bus_connection_send_oom_error (connection, message);
 377
 378               /* cancel transaction due to OOM */
 379               if (transaction != NULL)
 380                 {
 381                   bus_transaction_cancel_and_free (transaction);
 382                   transaction = NULL;
 383                 }
 384             }
 385         }
 386
 387
 388       dbus_error_free (&error);
 389     }
 390
 391   if (transaction != NULL)
 392     {
 393       bus_transaction_execute_and_free (transaction);
 394     }
 395
 396   dbus_connection_unref (connection);
 397
 398   return result;
 399 }
 400
 401 static DBusHandlerResult
 402 bus_dispatch_message_filter (DBusConnection     *connection,
 403                              DBusMessage        *message,
 404                              void               *user_data)
 405 {
 406   return bus_dispatch (connection, message);
 407 }
 408
 409 dbus_bool_t
 410 bus_dispatch_add_connection (DBusConnection *connection)
 411 {
 412   if (!dbus_connection_add_filter (connection,
 413                                    bus_dispatch_message_filter,
 414                                    NULL, NULL))
 415     return FALSE;
 416
 417   return TRUE;
 418 }
 419
 420 void
 421 bus_dispatch_remove_connection (DBusConnection *connection)
 422 {
 423   /* Here we tell the bus driver that we want to get off. */
 424   bus_driver_remove_connection (connection);
 425
 426   dbus_connection_remove_filter (connection,
 427                                  bus_dispatch_message_filter,
 428                                  NULL);
 429 }
 430
 431 #ifdef DBUS_BUILD_TESTS
 432
 433 #include <stdio.h>
 434
 435 /* This is used to know whether we need to block in order to finish
 436  * sending a message, or whether the initial dbus_connection_send()
 437  * already flushed the queue.
 438  */
 439 #define SEND_PENDING(connection) (dbus_connection_has_messages_to_send (connection))
 440
 441 typedef dbus_bool_t (* Check1Func) (BusContext     *context);
 442 typedef dbus_bool_t (* Check2Func) (BusContext     *context,
 443                                     DBusConnection *connection);
 444
 445 static dbus_bool_t check_no_leftovers (BusContext *context);
 446
 447 static void
 448 block_connection_until_message_from_bus (BusContext     *context,
 449                                          DBusConnection *connection,
 450                                          const char     *what_is_expected)
 451 {
 452   _dbus_verbose ("expecting: %s\n", what_is_expected);
 453
 454   while (dbus_connection_get_dispatch_status (connection) ==
 455          DBUS_DISPATCH_COMPLETE &&
 456          dbus_connection_get_is_connected (connection))
 457     {
 458       bus_test_run_bus_loop (context, TRUE);
 459       bus_test_run_clients_loop (FALSE);
 460     }
 461 }
 462
 463 static void
 464 spin_connection_until_authenticated (BusContext     *context,
 465                                      DBusConnection *connection)
 466 {
 467   _dbus_verbose ("Spinning to auth connection %p\n", connection);
 468   while (!dbus_connection_get_is_authenticated (connection) &&
 469          dbus_connection_get_is_connected (connection))
 470     {
 471       bus_test_run_bus_loop (context, FALSE);
 472       bus_test_run_clients_loop (FALSE);
 473     }
 474   _dbus_verbose (" ... done spinning to auth connection %p\n", connection);
 475 }
 476
 477 /* compensate for fact that pop_message() can return #NULL due to OOM */
 478 static DBusMessage*
 479 pop_message_waiting_for_memory (DBusConnection *connection)
 480 {
 481   while (dbus_connection_get_dispatch_status (connection) ==
 482          DBUS_DISPATCH_NEED_MEMORY)
 483     _dbus_wait_for_memory ();
 484
 485   return dbus_connection_pop_message (connection);
 486 }
 487
 488 static DBusMessage*
 489 borrow_message_waiting_for_memory (DBusConnection *connection)
 490 {
 491   while (dbus_connection_get_dispatch_status (connection) ==
 492          DBUS_DISPATCH_NEED_MEMORY)
 493     _dbus_wait_for_memory ();
 494
 495   return dbus_connection_borrow_message (connection);
 496 }
 497
 498 static void
 499 warn_unexpected_real (DBusConnection *connection,
 500                       DBusMessage    *message,
 501                       const char     *expected,
 502                       const char     *function,
 503                       int             line)
 504 {
 505   if (message)
 506     _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n",
 507                 function, line,
 508                 dbus_message_get_interface (message) ?
 509                 dbus_message_get_interface (message) : "(unset)",
 510                 dbus_message_get_member (message) ?
 511                 dbus_message_get_member (message) : "(unset)",
 512                 dbus_message_get_error_name (message) ?
 513                 dbus_message_get_error_name (message) : "(unset)",
 514                 connection,
 515                 expected);
 516   else
 517     _dbus_warn ("%s:%d received no message on %p, expecting %s\n",
 518                 function, line, connection, expected);
 519 }
 520
 521 #define warn_unexpected(connection, message, expected) \
 522   warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__)
 523
 524 static void
 525 verbose_message_received (DBusConnection *connection,
 526                           DBusMessage    *message)
 527 {
 528   _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n",
 529                  dbus_message_get_interface (message) ?
 530                  dbus_message_get_interface (message) : "(unset)",
 531                  dbus_message_get_member (message) ?
 532                  dbus_message_get_member (message) : "(unset)",
 533                  dbus_message_get_error_name (message) ?
 534                  dbus_message_get_error_name (message) : "(unset)",
 535                  connection);
 536 }
 537
 538 typedef enum
 539 {
 540   SERVICE_CREATED,
 541   OWNER_CHANGED,
 542   SERVICE_DELETED
 543 } ServiceInfoKind;
 544
 545 typedef struct
 546 {
 547   ServiceInfoKind expected_kind;
 548   const char *expected_service_name;
 549   dbus_bool_t failed;
 550   DBusConnection *skip_connection;
 551 } CheckServiceOwnerChangedData;
 552
 553 static dbus_bool_t
 554 check_service_owner_changed_foreach (DBusConnection *connection,
 555                                      void           *data)
 556 {
 557   CheckServiceOwnerChangedData *d = data;
 558   DBusMessage *message;
 559   DBusError error;
 560   const char *service_name, *old_owner, *new_owner;
 561
 562   if (d->expected_kind == SERVICE_CREATED
 563       && connection == d->skip_connection)
 564     return TRUE;
 565
 566   dbus_error_init (&error);
 567   d->failed = TRUE;
 568
 569   message = pop_message_waiting_for_memory (connection);
 570   if (message == NULL)
 571     {
 572       _dbus_warn ("Did not receive a message on %p, expecting %s\n",
 573                   connection, "NameOwnerChanged");
 574       goto out;
 575     }
 576   else if (!dbus_message_is_signal (message,
 577                                     DBUS_INTERFACE_DBUS,
 578                                     "NameOwnerChanged"))
 579     {
 580       warn_unexpected (connection, message, "NameOwnerChanged");
 581
 582       goto out;
 583     }
 584   else
 585     {
 586     reget_service_info_data:
 587       service_name = NULL;
 588       old_owner = NULL;
 589       new_owner = NULL;
 590
 591       dbus_message_get_args (message, &error,
 592                              DBUS_TYPE_STRING, &service_name,
 593                              DBUS_TYPE_STRING, &old_owner,
 594                              DBUS_TYPE_STRING, &new_owner,
 595                              DBUS_TYPE_INVALID);
 596
 597       if (dbus_error_is_set (&error))
 598         {
 599           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
 600             {
 601               dbus_error_free (&error);
 602               _dbus_wait_for_memory ();
 603               goto reget_service_info_data;
 604             }
 605           else
 606             {
 607               _dbus_warn ("Did not get the expected arguments\n");
 608               goto out;
 609             }
 610         }
 611
 612       if ((d->expected_kind == SERVICE_CREATED    && ( old_owner[0] || !new_owner[0]))
 613           || (d->expected_kind == OWNER_CHANGED   && (!old_owner[0] || !new_owner[0]))
 614           || (d->expected_kind == SERVICE_DELETED && (!old_owner[0] ||  new_owner[0])))
 615         {
 616           _dbus_warn ("inconsistent NameOwnerChanged arguments\n");
 617           goto out;
 618         }
 619
 620       if (strcmp (service_name, d->expected_service_name) != 0)
 621         {
 622           _dbus_warn ("expected info on service %s, got info on %s\n",
 623                       d->expected_service_name,
 624                       service_name);
 625           goto out;
 626         }
 627
 628       if (*service_name == ':' && new_owner[0]
 629           && strcmp (service_name, new_owner) != 0)
 630         {
 631           _dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",
 632                       service_name, old_owner, new_owner);
 633           goto out;
 634         }
 635     }
 636
 637   d->failed = FALSE;
 638
 639  out:
 640   dbus_error_free (&error);
 641
 642   if (message)
 643     dbus_message_unref (message);
 644
 645   return !d->failed;
 646 }
 647
 648
 649 static void
 650 kill_client_connection (BusContext     *context,
 651                         DBusConnection *connection)
 652 {
 653   char *base_service;
 654   const char *s;
 655   CheckServiceOwnerChangedData socd;
 656
 657   _dbus_verbose ("killing connection %p\n", connection);
 658
 659   s = dbus_bus_get_unique_name (connection);
 660   _dbus_assert (s != NULL);
 661
 662   while ((base_service = _dbus_strdup (s)) == NULL)
 663     _dbus_wait_for_memory ();
 664
 665   dbus_connection_ref (connection);
 666
 667   /* kick in the disconnect handler that unrefs the connection */
 668   dbus_connection_close (connection);
 669
 670   bus_test_run_everything (context);
 671
 672   _dbus_assert (bus_test_client_listed (connection));
 673
 674   /* Run disconnect handler in test.c */
 675   if (bus_connection_dispatch_one_message (connection))
 676     _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
 677
 678   _dbus_assert (!dbus_connection_get_is_connected (connection));
 679   dbus_connection_unref (connection);
 680   connection = NULL;
 681   _dbus_assert (!bus_test_client_listed (connection));
 682
 683   socd.expected_kind = SERVICE_DELETED;
 684   socd.expected_service_name = base_service;
 685   socd.failed = FALSE;
 686   socd.skip_connection = NULL;
 687
 688   bus_test_clients_foreach (check_service_owner_changed_foreach,
 689                             &socd);
 690
 691   dbus_free (base_service);
 692
 693   if (socd.failed)
 694     _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");
 695
 696   if (!check_no_leftovers (context))
 697     _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
 698 }
 699
 700 static void
 701 kill_client_connection_unchecked (DBusConnection *connection)
 702 {
 703   /* This kills the connection without expecting it to affect
 704    * the rest of the bus.
 705    */
 706   _dbus_verbose ("Unchecked kill of connection %p\n", connection);
 707
 708   dbus_connection_ref (connection);
 709   dbus_connection_close (connection);
 710   /* dispatching disconnect handler will unref once */
 711   if (bus_connection_dispatch_one_message (connection))
 712     _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
 713
 714   _dbus_assert (!bus_test_client_listed (connection));
 715   dbus_connection_unref (connection);
 716 }
 717
 718 typedef struct
 719 {
 720   dbus_bool_t failed;
 721 } CheckNoMessagesData;
 722
 723 static dbus_bool_t
 724 check_no_messages_foreach (DBusConnection *connection,
 725                            void           *data)
 726 {
 727   CheckNoMessagesData *d = data;
 728   DBusMessage *message;
 729
 730   message = pop_message_waiting_for_memory (connection);
 731   if (message != NULL)
 732     {
 733       warn_unexpected (connection, message, "no messages");
 734
 735       d->failed = TRUE;
 736     }
 737
 738   if (message)
 739     dbus_message_unref (message);
 740   return !d->failed;
 741 }
 742
 743 static dbus_bool_t
 744 check_no_leftovers (BusContext *context)
 745 {
 746   CheckNoMessagesData nmd;
 747
 748   nmd.failed = FALSE;
 749   bus_test_clients_foreach (check_no_messages_foreach,
 750                             &nmd);
 751
 752   if (nmd.failed)
 753     {
 754       _dbus_verbose ("leftover message found\n");
 755       return FALSE;
 756     }
 757   else
 758     return TRUE;
 759 }
 760
 761 /* returns TRUE if the correct thing happens,
 762  * but the correct thing may include OOM errors.
 763  */
 764 static dbus_bool_t
 765 check_hello_message (BusContext     *context,
 766                      DBusConnection *connection)
 767 {
 768   DBusMessage *message;
 769   DBusMessage *name_message;
 770   dbus_uint32_t serial;
 771   dbus_bool_t retval;
 772   DBusError error;
 773   const char *name;
 774   const char *acquired;
 775
 776   retval = FALSE;
 777   dbus_error_init (&error);
 778   name = NULL;
 779   acquired = NULL;
 780   message = NULL;
 781   name_message = NULL;
 782
 783   _dbus_verbose ("check_hello_message for %p\n", connection);
 784
 785   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
 786                                           DBUS_PATH_DBUS,
 787                                           DBUS_INTERFACE_DBUS,
 788                                           "Hello");
 789
 790   if (message == NULL)
 791     return TRUE;
 792
 793   dbus_connection_ref (connection); /* because we may get disconnected */
 794
 795   if (!dbus_connection_send (connection, message, &serial))
 796     {
 797       dbus_message_unref (message);
 798       dbus_connection_unref (connection);
 799       return TRUE;
 800     }
 801
 802   _dbus_assert (dbus_message_has_signature (message, ""));
 803
 804   dbus_message_unref (message);
 805   message = NULL;
 806
 807   if (!dbus_connection_get_is_connected (connection))
 808     {
 809       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
 810
 811       dbus_connection_unref (connection);
 812
 813       return TRUE;
 814     }
 815
 816   /* send our message */
 817   bus_test_run_clients_loop (SEND_PENDING (connection));
 818
 819   if (!dbus_connection_get_is_connected (connection))
 820     {
 821       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
 822
 823       dbus_connection_unref (connection);
 824
 825       return TRUE;
 826     }
 827
 828   block_connection_until_message_from_bus (context, connection, "reply to Hello");
 829
 830   if (!dbus_connection_get_is_connected (connection))
 831     {
 832       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
 833
 834       dbus_connection_unref (connection);
 835
 836       return TRUE;
 837     }
 838
 839   dbus_connection_unref (connection);
 840
 841   message = pop_message_waiting_for_memory (connection);
 842   if (message == NULL)
 843     {
 844       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
 845                   "Hello", serial, connection);
 846       goto out;
 847     }
 848
 849   verbose_message_received (connection, message);
 850
 851   if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
 852     {
 853       _dbus_warn ("Message has wrong sender %s\n",
 854                   dbus_message_get_sender (message) ?
 855                   dbus_message_get_sender (message) : "(none)");
 856       goto out;
 857     }
 858
 859   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
 860     {
 861       if (dbus_message_is_error (message,
 862                                  DBUS_ERROR_NO_MEMORY))
 863         {
 864           ; /* good, this is a valid response */
 865         }
 866       else
 867         {
 868           warn_unexpected (connection, message, "not this error");
 869
 870           goto out;
 871         }
 872     }
 873   else
 874     {
 875       CheckServiceOwnerChangedData socd;
 876
 877       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
 878         {
 879           ; /* good, expected */
 880         }
 881       else
 882         {
 883           warn_unexpected (connection, message, "method return for Hello");
 884
 885           goto out;
 886         }
 887
 888     retry_get_hello_name:
 889       if (!dbus_message_get_args (message, &error,
 890                                   DBUS_TYPE_STRING, &name,
 891                                   DBUS_TYPE_INVALID))
 892         {
 893           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
 894             {
 895               _dbus_verbose ("no memory to get service name arg from hello\n");
 896               dbus_error_free (&error);
 897               _dbus_wait_for_memory ();
 898               goto retry_get_hello_name;
 899             }
 900           else
 901             {
 902               _dbus_assert (dbus_error_is_set (&error));
 903               _dbus_warn ("Did not get the expected single string argument to hello\n");
 904               goto out;
 905             }
 906         }
 907
 908       _dbus_verbose ("Got hello name: %s\n", name);
 909
 910       while (!dbus_bus_set_unique_name (connection, name))
 911         _dbus_wait_for_memory ();
 912
 913       socd.expected_kind = SERVICE_CREATED;
 914       socd.expected_service_name = name;
 915       socd.failed = FALSE;
 916       socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */
 917       bus_test_clients_foreach (check_service_owner_changed_foreach,
 918                                 &socd);
 919
 920       if (socd.failed)
 921         goto out;
 922
 923       name_message = message;
 924       /* Client should also have gotten ServiceAcquired */
 925
 926       message = pop_message_waiting_for_memory (connection);
 927       if (message == NULL)
 928         {
 929           _dbus_warn ("Expecting %s, got nothing\n",
 930                       "NameAcquired");
 931           goto out;
 932         }
 933       if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
 934                                     "NameAcquired"))
 935         {
 936           _dbus_warn ("Expecting %s, got smthg else\n",
 937                       "NameAcquired");
 938           goto out;
 939         }
 940
 941     retry_get_acquired_name:
 942       if (!dbus_message_get_args (message, &error,
 943                                   DBUS_TYPE_STRING, &acquired,
 944                                   DBUS_TYPE_INVALID))
 945         {
 946           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
 947             {
 948               _dbus_verbose ("no memory to get service name arg from acquired\n");
 949               dbus_error_free (&error);
 950               _dbus_wait_for_memory ();
 951               goto retry_get_acquired_name;
 952             }
 953           else
 954             {
 955               _dbus_assert (dbus_error_is_set (&error));
 956               _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");
 957               goto out;
 958             }
 959         }
 960
 961       _dbus_verbose ("Got acquired name: %s\n", acquired);
 962
 963       if (strcmp (acquired, name) != 0)
 964         {
 965           _dbus_warn ("Acquired name is %s but expected %s\n",
 966                       acquired, name);
 967           goto out;
 968         }
 969       acquired = NULL;
 970     }
 971
 972   if (!check_no_leftovers (context))
 973     goto out;
 974
 975   retval = TRUE;
 976
 977  out:
 978   _dbus_verbose ("ending - retval = %d\n", retval);
 979
 980   dbus_error_free (&error);
 981
 982   if (message)
 983     dbus_message_unref (message);
 984
 985   if (name_message)
 986     dbus_message_unref (name_message);
 987
 988   return retval;
 989 }
 990
 991 /* returns TRUE if the correct thing happens,
 992  * but the correct thing may include OOM errors.
 993  */
 994 static dbus_bool_t
 995 check_double_hello_message (BusContext     *context,
 996                             DBusConnection *connection)
 997 {
 998   DBusMessage *message;
 999   dbus_uint32_t serial;
1000   dbus_bool_t retval;
1001   DBusError error;
1002
1003   retval = FALSE;
1004   dbus_error_init (&error);
1005   message = NULL;
1006
1007   _dbus_verbose ("check_double_hello_message for %p\n", connection);
1008
1009   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1010                                           DBUS_PATH_DBUS,
1011                                           DBUS_INTERFACE_DBUS,
1012                                           "Hello");
1013
1014   if (message == NULL)
1015     return TRUE;
1016
1017   if (!dbus_connection_send (connection, message, &serial))
1018     {
1019       dbus_message_unref (message);
1020       return TRUE;
1021     }
1022
1023   dbus_message_unref (message);
1024   message = NULL;
1025
1026   /* send our message */
1027   bus_test_run_clients_loop (SEND_PENDING (connection));
1028
1029   dbus_connection_ref (connection); /* because we may get disconnected */
1030   block_connection_until_message_from_bus (context, connection, "reply to Hello");
1031
1032   if (!dbus_connection_get_is_connected (connection))
1033     {
1034       _dbus_verbose ("connection was disconnected\n");
1035
1036       dbus_connection_unref (connection);
1037
1038       return TRUE;
1039     }
1040
1041   dbus_connection_unref (connection);
1042
1043   message = pop_message_waiting_for_memory (connection);
1044   if (message == NULL)
1045     {
1046       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1047                   "Hello", serial, connection);
1048       goto out;
1049     }
1050
1051   verbose_message_received (connection, message);
1052
1053   if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1054     {
1055       _dbus_warn ("Message has wrong sender %s\n",
1056                   dbus_message_get_sender (message) ?
1057                   dbus_message_get_sender (message) : "(none)");
1058       goto out;
1059     }
1060
1061   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1062     {
1063       warn_unexpected (connection, message, "method return for Hello");
1064       goto out;
1065     }
1066
1067   if (!check_no_leftovers (context))
1068     goto out;
1069
1070   retval = TRUE;
1071
1072  out:
1073   dbus_error_free (&error);
1074
1075   if (message)
1076     dbus_message_unref (message);
1077
1078   return retval;
1079 }
1080
1081 /* returns TRUE if the correct thing happens,
1082  * but the correct thing may include OOM errors.
1083  */
1084 static dbus_bool_t
1085 check_get_connection_unix_user (BusContext     *context,
1086                                 DBusConnection *connection)
1087 {
1088   DBusMessage *message;
1089   dbus_uint32_t serial;
1090   dbus_bool_t retval;
1091   DBusError error;
1092   const char *base_service_name;
1093   dbus_uint32_t uid;
1094
1095   retval = FALSE;
1096   dbus_error_init (&error);
1097   message = NULL;
1098
1099   _dbus_verbose ("check_get_connection_unix_user for %p\n", connection);
1100
1101   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1102                                           DBUS_PATH_DBUS,
1103                                           DBUS_INTERFACE_DBUS,
1104                                           "GetConnectionUnixUser");
1105
1106   if (message == NULL)
1107     return TRUE;
1108
1109   base_service_name = dbus_bus_get_unique_name (connection);
1110
1111   if (!dbus_message_append_args (message,
1112                                  DBUS_TYPE_STRING, &base_service_name,
1113                                  DBUS_TYPE_INVALID))
1114     {
1115       dbus_message_unref (message);
1116       return TRUE;
1117     }
1118
1119   if (!dbus_connection_send (connection, message, &serial))
1120     {
1121       dbus_message_unref (message);
1122       return TRUE;
1123     }
1124
1125   /* send our message */
1126   bus_test_run_clients_loop (SEND_PENDING (connection));
1127
1128   dbus_message_unref (message);
1129   message = NULL;
1130
1131   dbus_connection_ref (connection); /* because we may get disconnected */
1132   block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixUser");
1133
1134   if (!dbus_connection_get_is_connected (connection))
1135     {
1136       _dbus_verbose ("connection was disconnected\n");
1137
1138       dbus_connection_unref (connection);
1139
1140       return TRUE;
1141     }
1142
1143   dbus_connection_unref (connection);
1144
1145   message = pop_message_waiting_for_memory (connection);
1146   if (message == NULL)
1147     {
1148       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1149                   "GetConnectionUnixUser", serial, connection);
1150       goto out;
1151     }
1152
1153   verbose_message_received (connection, message);
1154
1155   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1156     {
1157       if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
1158         {
1159           ; /* good, this is a valid response */
1160         }
1161       else
1162         {
1163           warn_unexpected (connection, message, "not this error");
1164
1165           goto out;
1166         }
1167     }
1168   else
1169     {
1170       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1171         {
1172           ; /* good, expected */
1173         }
1174       else
1175         {
1176           warn_unexpected (connection, message,
1177                            "method_return for GetConnectionUnixUser");
1178
1179           goto out;
1180         }
1181
1182     retry_get_property:
1183
1184       if (!dbus_message_get_args (message, &error,
1185                                   DBUS_TYPE_UINT32, &uid,
1186                                   DBUS_TYPE_INVALID))
1187         {
1188           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1189             {
1190               _dbus_verbose ("no memory to get uid by GetConnectionUnixUser\n");
1191               dbus_error_free (&error);
1192               _dbus_wait_for_memory ();
1193               goto retry_get_property;
1194             }
1195           else
1196             {
1197               _dbus_assert (dbus_error_is_set (&error));
1198               _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixUser\n");
1199               goto out;
1200             }
1201         }
1202     }
1203
1204   if (!check_no_leftovers (context))
1205     goto out;
1206
1207   retval = TRUE;
1208
1209  out:
1210   dbus_error_free (&error);
1211
1212   if (message)
1213     dbus_message_unref (message);
1214
1215   return retval;
1216 }
1217
1218 /* returns TRUE if the correct thing happens,
1219  * but the correct thing may include OOM errors.
1220  */
1221 static dbus_bool_t
1222 check_get_connection_unix_process_id (BusContext     *context,
1223                                       DBusConnection *connection)
1224 {
1225   DBusMessage *message;
1226   dbus_uint32_t serial;
1227   dbus_bool_t retval;
1228   DBusError error;
1229   const char *base_service_name;
1230   dbus_uint32_t pid;
1231
1232   retval = FALSE;
1233   dbus_error_init (&error);
1234   message = NULL;
1235
1236   _dbus_verbose ("check_get_connection_unix_process_id for %p\n", connection);
1237
1238   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1239                                           DBUS_PATH_DBUS,
1240                                           DBUS_INTERFACE_DBUS,
1241                                           "GetConnectionUnixProcessID");
1242
1243   if (message == NULL)
1244     return TRUE;
1245
1246   base_service_name = dbus_bus_get_unique_name (connection);
1247
1248   if (!dbus_message_append_args (message,
1249                                  DBUS_TYPE_STRING, &base_service_name,
1250                                  DBUS_TYPE_INVALID))
1251     {
1252       dbus_message_unref (message);
1253       return TRUE;
1254     }
1255
1256   if (!dbus_connection_send (connection, message, &serial))
1257     {
1258       dbus_message_unref (message);
1259       return TRUE;
1260     }
1261
1262   /* send our message */
1263   bus_test_run_clients_loop (SEND_PENDING (connection));
1264
1265   dbus_message_unref (message);
1266   message = NULL;
1267
1268   dbus_connection_ref (connection); /* because we may get disconnected */
1269   block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixProcessID");
1270
1271   if (!dbus_connection_get_is_connected (connection))
1272     {
1273       _dbus_verbose ("connection was disconnected\n");
1274
1275       dbus_connection_unref (connection);
1276
1277       return TRUE;
1278     }
1279
1280   dbus_connection_unref (connection);
1281
1282   message = pop_message_waiting_for_memory (connection);
1283   if (message == NULL)
1284     {
1285       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1286                   "GetConnectionUnixProcessID", serial, connection);
1287       goto out;
1288     }
1289
1290   verbose_message_received (connection, message);
1291
1292   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1293     {
1294       if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
1295         {
1296           ; /* good, this is a valid response */
1297         }
1298 #ifdef DBUS_WIN
1299       else if (dbus_message_is_error (message, DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN))
1300         {
1301           /* We are expecting this error, since we know in the test suite we aren't
1302            * talking to a client running on UNIX
1303            */
1304           _dbus_verbose ("Windows correctly does not support GetConnectionUnixProcessID\n");
1305         }
1306 #endif
1307       else
1308         {
1309           warn_unexpected (connection, message, "not this error");
1310
1311           goto out;
1312         }
1313     }
1314   else
1315     {
1316 #ifdef DBUS_WIN
1317       warn_unexpected (connection, message, "GetConnectionUnixProcessID to fail on Windows");
1318       goto out;
1319 #else
1320       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1321         {
1322           ; /* good, expected */
1323         }
1324       else
1325         {
1326           warn_unexpected (connection, message,
1327                            "method_return for GetConnectionUnixProcessID");
1328
1329           goto out;
1330         }
1331
1332     retry_get_property:
1333
1334       if (!dbus_message_get_args (message, &error,
1335                                   DBUS_TYPE_UINT32, &pid,
1336                                   DBUS_TYPE_INVALID))
1337         {
1338           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1339             {
1340               _dbus_verbose ("no memory to get pid by GetConnectionUnixProcessID\n");
1341               dbus_error_free (&error);
1342               _dbus_wait_for_memory ();
1343               goto retry_get_property;
1344             }
1345           else
1346             {
1347               _dbus_assert (dbus_error_is_set (&error));
1348               _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixProcessID\n");
1349               goto out;
1350             }
1351         }
1352       else
1353         {
1354           /* test if returned pid is the same as our own pid
1355            *
1356            * @todo It would probably be good to restructure the tests
1357            *       in a way so our parent is the bus that we're testing
1358            *       cause then we can test that the pid returned matches
1359            *       getppid()
1360            */
1361           if (pid != (dbus_uint32_t) _dbus_getpid ())
1362             {
1363               _dbus_assert (dbus_error_is_set (&error));
1364               _dbus_warn ("Result from GetConnectionUnixProcessID is not our own pid\n");
1365               goto out;
1366             }
1367         }
1368 #endif /* !DBUS_WIN */
1369     }
1370
1371   if (!check_no_leftovers (context))
1372     goto out;
1373
1374   retval = TRUE;
1375
1376  out:
1377   dbus_error_free (&error);
1378
1379   if (message)
1380     dbus_message_unref (message);
1381
1382   return retval;
1383 }
1384
1385 /* returns TRUE if the correct thing happens,
1386  * but the correct thing may include OOM errors.
1387  */
1388 static dbus_bool_t
1389 check_add_match_all (BusContext     *context,
1390                      DBusConnection *connection)
1391 {
1392   DBusMessage *message;
1393   dbus_bool_t retval;
1394   dbus_uint32_t serial;
1395   DBusError error;
1396   const char *empty = "";
1397
1398   retval = FALSE;
1399   dbus_error_init (&error);
1400   message = NULL;
1401
1402   _dbus_verbose ("check_add_match_all for %p\n", connection);
1403
1404   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1405                                           DBUS_PATH_DBUS,
1406                                           DBUS_INTERFACE_DBUS,
1407                                           "AddMatch");
1408
1409   if (message == NULL)
1410     return TRUE;
1411
1412   /* empty string match rule matches everything */
1413   if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &empty,
1414                                  DBUS_TYPE_INVALID))
1415     {
1416       dbus_message_unref (message);
1417       return TRUE;
1418     }
1419
1420   if (!dbus_connection_send (connection, message, &serial))
1421     {
1422       dbus_message_unref (message);
1423       return TRUE;
1424     }
1425
1426   dbus_message_unref (message);
1427   message = NULL;
1428
1429   dbus_connection_ref (connection); /* because we may get disconnected */
1430
1431   /* send our message */
1432   bus_test_run_clients_loop (SEND_PENDING (connection));
1433
1434   if (!dbus_connection_get_is_connected (connection))
1435     {
1436       _dbus_verbose ("connection was disconnected\n");
1437
1438       dbus_connection_unref (connection);
1439
1440       return TRUE;
1441     }
1442
1443   block_connection_until_message_from_bus (context, connection, "reply to AddMatch");
1444
1445   if (!dbus_connection_get_is_connected (connection))
1446     {
1447       _dbus_verbose ("connection was disconnected\n");
1448
1449       dbus_connection_unref (connection);
1450
1451       return TRUE;
1452     }
1453
1454   dbus_connection_unref (connection);
1455
1456   message = pop_message_waiting_for_memory (connection);
1457   if (message == NULL)
1458     {
1459       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1460                   "AddMatch", serial, connection);
1461       goto out;
1462     }
1463
1464   verbose_message_received (connection, message);
1465
1466   if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1467     {
1468       _dbus_warn ("Message has wrong sender %s\n",
1469                   dbus_message_get_sender (message) ?
1470                   dbus_message_get_sender (message) : "(none)");
1471       goto out;
1472     }
1473
1474   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1475     {
1476       if (dbus_message_is_error (message,
1477                                  DBUS_ERROR_NO_MEMORY))
1478         {
1479           ; /* good, this is a valid response */
1480         }
1481       else
1482         {
1483           warn_unexpected (connection, message, "not this error");
1484
1485           goto out;
1486         }
1487     }
1488   else
1489     {
1490       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1491         {
1492           ; /* good, expected */
1493           _dbus_assert (dbus_message_get_reply_serial (message) == serial);
1494         }
1495       else
1496         {
1497           warn_unexpected (connection, message, "method return for AddMatch");
1498
1499           goto out;
1500         }
1501     }
1502
1503   if (!check_no_leftovers (context))
1504     goto out;
1505
1506   retval = TRUE;
1507
1508  out:
1509   dbus_error_free (&error);
1510
1511   if (message)
1512     dbus_message_unref (message);
1513
1514   return retval;
1515 }
1516
1517 /* returns TRUE if the correct thing happens,
1518  * but the correct thing may include OOM errors.
1519  */
1520 static dbus_bool_t
1521 check_hello_connection (BusContext *context)
1522 {
1523   DBusConnection *connection;
1524   DBusError error;
1525
1526   dbus_error_init (&error);
1527
1528   connection = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
1529   if (connection == NULL)
1530     {
1531       _DBUS_ASSERT_ERROR_IS_SET (&error);
1532       dbus_error_free (&error);
1533       return TRUE;
1534     }
1535
1536   if (!bus_setup_debug_client (connection))
1537     {
1538       dbus_connection_close (connection);
1539       dbus_connection_unref (connection);
1540       return TRUE;
1541     }
1542
1543   spin_connection_until_authenticated (context, connection);
1544
1545   if (!check_hello_message (context, connection))
1546     return FALSE;
1547
1548   if (dbus_bus_get_unique_name (connection) == NULL)
1549     {
1550       /* We didn't successfully register, so we can't
1551        * do the usual kill_client_connection() checks
1552        */
1553       kill_client_connection_unchecked (connection);
1554     }
1555   else
1556     {
1557       if (!check_add_match_all (context, connection))
1558         return FALSE;
1559
1560       kill_client_connection (context, connection);
1561     }
1562
1563   return TRUE;
1564 }
1565
1566 #define NONEXISTENT_SERVICE_NAME "test.this.service.does.not.exist.ewuoiurjdfxcvn"
1567
1568 /* returns TRUE if the correct thing happens,
1569  * but the correct thing may include OOM errors.
1570  */
1571 static dbus_bool_t
1572 check_nonexistent_service_no_auto_start (BusContext     *context,
1573                                          DBusConnection *connection)
1574 {
1575   DBusMessage *message;
1576   dbus_uint32_t serial;
1577   dbus_bool_t retval;
1578   const char *nonexistent = NONEXISTENT_SERVICE_NAME;
1579   dbus_uint32_t flags;
1580
1581   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1582                                           DBUS_PATH_DBUS,
1583                                           DBUS_INTERFACE_DBUS,
1584                                           "StartServiceByName");
1585
1586   if (message == NULL)
1587     return TRUE;
1588
1589   dbus_message_set_auto_start (message, FALSE);
1590
1591   flags = 0;
1592   if (!dbus_message_append_args (message,
1593                                  DBUS_TYPE_STRING, &nonexistent,
1594                                  DBUS_TYPE_UINT32, &flags,
1595                                  DBUS_TYPE_INVALID))
1596     {
1597       dbus_message_unref (message);
1598       return TRUE;
1599     }
1600
1601   if (!dbus_connection_send (connection, message, &serial))
1602     {
1603       dbus_message_unref (message);
1604       return TRUE;
1605     }
1606
1607   dbus_message_unref (message);
1608   message = NULL;
1609
1610   bus_test_run_everything (context);
1611   block_connection_until_message_from_bus (context, connection, "reply to ActivateService on nonexistent");
1612   bus_test_run_everything (context);
1613
1614   if (!dbus_connection_get_is_connected (connection))
1615     {
1616       _dbus_verbose ("connection was disconnected\n");
1617       return TRUE;
1618     }
1619
1620   retval = FALSE;
1621
1622   message = pop_message_waiting_for_memory (connection);
1623   if (message == NULL)
1624     {
1625       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1626                   "StartServiceByName", serial, connection);
1627       goto out;
1628     }
1629
1630   verbose_message_received (connection, message);
1631
1632   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1633     {
1634       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1635         {
1636           _dbus_warn ("Message has wrong sender %s\n",
1637                       dbus_message_get_sender (message) ?
1638                       dbus_message_get_sender (message) : "(none)");
1639           goto out;
1640         }
1641
1642       if (dbus_message_is_error (message,
1643                                  DBUS_ERROR_NO_MEMORY))
1644         {
1645           ; /* good, this is a valid response */
1646         }
1647       else if (dbus_message_is_error (message,
1648                                       DBUS_ERROR_SERVICE_UNKNOWN))
1649         {
1650           ; /* good, this is expected also */
1651         }
1652       else
1653         {
1654           warn_unexpected (connection, message, "not this error");
1655           goto out;
1656         }
1657     }
1658   else
1659     {
1660       _dbus_warn ("Did not expect to successfully activate %s\n",
1661                   NONEXISTENT_SERVICE_NAME);
1662       goto out;
1663     }
1664
1665   retval = TRUE;
1666
1667  out:
1668   if (message)
1669     dbus_message_unref (message);
1670
1671   return retval;
1672 }
1673
1674 /* returns TRUE if the correct thing happens,
1675  * but the correct thing may include OOM errors.
1676  */
1677 static dbus_bool_t
1678 check_nonexistent_service_auto_start (BusContext     *context,
1679                                       DBusConnection *connection)
1680 {
1681   DBusMessage *message;
1682   dbus_uint32_t serial;
1683   dbus_bool_t retval;
1684
1685   message = dbus_message_new_method_call (NONEXISTENT_SERVICE_NAME,
1686                                           "/org/freedesktop/TestSuite",
1687                                           "org.freedesktop.TestSuite",
1688                                           "Echo");
1689
1690   if (message == NULL)
1691     return TRUE;
1692
1693   if (!dbus_connection_send (connection, message, &serial))
1694     {
1695       dbus_message_unref (message);
1696       return TRUE;
1697     }
1698
1699   dbus_message_unref (message);
1700   message = NULL;
1701
1702   bus_test_run_everything (context);
1703   block_connection_until_message_from_bus (context, connection, "reply to Echo");
1704   bus_test_run_everything (context);
1705
1706   if (!dbus_connection_get_is_connected (connection))
1707     {
1708       _dbus_verbose ("connection was disconnected\n");
1709       return TRUE;
1710     }
1711
1712   retval = FALSE;
1713
1714   message = pop_message_waiting_for_memory (connection);
1715
1716   if (message == NULL)
1717     {
1718       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1719                   "Echo message (auto activation)", serial, connection);
1720       goto out;
1721     }
1722
1723   verbose_message_received (connection, message);
1724
1725   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1726     {
1727       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1728         {
1729           _dbus_warn ("Message has wrong sender %s\n",
1730                       dbus_message_get_sender (message) ?
1731                       dbus_message_get_sender (message) : "(none)");
1732           goto out;
1733         }
1734
1735       if (dbus_message_is_error (message,
1736                                  DBUS_ERROR_NO_MEMORY))
1737         {
1738           ; /* good, this is a valid response */
1739         }
1740       else if (dbus_message_is_error (message,
1741                                       DBUS_ERROR_SERVICE_UNKNOWN))
1742         {
1743           ; /* good, this is expected also */
1744         }
1745       else
1746         {
1747           warn_unexpected (connection, message, "not this error");
1748           goto out;
1749         }
1750     }
1751   else
1752     {
1753       _dbus_warn ("Did not expect to successfully activate %s\n",
1754                   NONEXISTENT_SERVICE_NAME);
1755       goto out;
1756     }
1757
1758   retval = TRUE;
1759
1760  out:
1761   if (message)
1762     dbus_message_unref (message);
1763
1764   return retval;
1765 }
1766
1767 static dbus_bool_t
1768 check_base_service_activated (BusContext     *context,
1769                               DBusConnection *connection,
1770                               DBusMessage    *initial_message,
1771                               const char    **base_service_p)
1772 {
1773   DBusMessage *message;
1774   dbus_bool_t retval;
1775   DBusError error;
1776   const char *base_service, *base_service_from_bus, *old_owner;
1777
1778   retval = FALSE;
1779
1780   dbus_error_init (&error);
1781   base_service = NULL;
1782   old_owner = NULL;
1783   base_service_from_bus = NULL;
1784
1785   message = initial_message;
1786   dbus_message_ref (message);
1787
1788   if (dbus_message_is_signal (message,
1789                               DBUS_INTERFACE_DBUS,
1790                               "NameOwnerChanged"))
1791     {
1792       CheckServiceOwnerChangedData socd;
1793
1794     reget_service_name_arg:
1795       base_service = NULL;
1796       old_owner = NULL;
1797       base_service_from_bus = NULL;
1798
1799       if (!dbus_message_get_args (message, &error,
1800                                   DBUS_TYPE_STRING, &base_service,
1801                                   DBUS_TYPE_STRING, &old_owner,
1802                                   DBUS_TYPE_STRING, &base_service_from_bus,
1803                                   DBUS_TYPE_INVALID))
1804         {
1805           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1806             {
1807               dbus_error_free (&error);
1808               _dbus_wait_for_memory ();
1809               goto reget_service_name_arg;
1810             }
1811           else
1812             {
1813               _dbus_warn ("Message %s doesn't have a service name: %s\n",
1814                           "NameOwnerChanged (creation)",
1815                           error.message);
1816               goto out;
1817             }
1818         }
1819
1820       if (*base_service != ':')
1821         {
1822           _dbus_warn ("Expected base service activation, got \"%s\" instead\n",
1823                       base_service);
1824           goto out;
1825         }
1826
1827       if (strcmp (base_service, base_service_from_bus) != 0)
1828         {
1829           _dbus_warn ("Expected base service activation, got \"%s\" instead with owner \"%s\"\n",
1830                       base_service, base_service_from_bus);
1831           goto out;
1832         }
1833
1834       if (old_owner[0])
1835         {
1836           _dbus_warn ("Received an old_owner argument during base service activation, \"%s\"\n",
1837                       old_owner);
1838           goto out;
1839         }
1840
1841       socd.expected_kind = SERVICE_CREATED;
1842       socd.expected_service_name = base_service;
1843       socd.failed = FALSE;
1844       socd.skip_connection = connection;
1845       bus_test_clients_foreach (check_service_owner_changed_foreach,
1846                                 &socd);
1847
1848       if (socd.failed)
1849         goto out;
1850     }
1851   else
1852     {
1853       warn_unexpected (connection, message, "NameOwnerChanged (creation) for base service");
1854
1855       goto out;
1856     }
1857
1858   if (base_service_p)
1859     *base_service_p = base_service;
1860
1861   retval = TRUE;
1862
1863  out:
1864   if (message)
1865     dbus_message_unref (message);
1866   dbus_error_free (&error);
1867
1868   return retval;
1869 }
1870
1871 static dbus_bool_t
1872 check_service_activated (BusContext     *context,
1873                          DBusConnection *connection,
1874                          const char     *activated_name,
1875                          const char     *base_service_name,
1876                          DBusMessage    *initial_message)
1877 {
1878   DBusMessage *message;
1879   dbus_bool_t retval;
1880   DBusError error;
1881   dbus_uint32_t activation_result;
1882
1883   retval = FALSE;
1884
1885   dbus_error_init (&error);
1886
1887   message = initial_message;
1888   dbus_message_ref (message);
1889
1890   if (dbus_message_is_signal (message,
1891                               DBUS_INTERFACE_DBUS,
1892                               "NameOwnerChanged"))
1893     {
1894       CheckServiceOwnerChangedData socd;
1895       const char *service_name, *base_service_from_bus, *old_owner;
1896
1897     reget_service_name_arg:
1898       service_name = NULL;
1899       old_owner = NULL;
1900       base_service_from_bus = NULL;
1901
1902       if (!dbus_message_get_args (message, &error,
1903                                   DBUS_TYPE_STRING, &service_name,
1904                                    DBUS_TYPE_STRING, &old_owner,
1905                                   DBUS_TYPE_STRING, &base_service_from_bus,
1906                                   DBUS_TYPE_INVALID))
1907         {
1908           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1909             {
1910               dbus_error_free (&error);
1911               _dbus_wait_for_memory ();
1912               goto reget_service_name_arg;
1913             }
1914           else
1915             {
1916               _dbus_warn ("Message %s doesn't have a service name: %s\n",
1917                           "NameOwnerChanged (creation)",
1918                           error.message);
1919               goto out;
1920             }
1921         }
1922
1923       if (strcmp (service_name, activated_name) != 0)
1924         {
1925           _dbus_warn ("Expected to see service %s created, saw %s instead\n",
1926                       activated_name, service_name);
1927           goto out;
1928         }
1929
1930       if (strcmp (base_service_name, base_service_from_bus) != 0)
1931         {
1932           _dbus_warn ("NameOwnerChanged reports wrong base service: %s owner, expected %s instead\n",
1933                       base_service_from_bus, base_service_name);
1934           goto out;
1935         }
1936
1937       if (old_owner[0])
1938         {
1939           _dbus_warn ("expected a %s, got a %s\n",
1940                       "NameOwnerChanged (creation)",
1941                       "NameOwnerChanged (change)");
1942           goto out;
1943         }
1944
1945       socd.expected_kind = SERVICE_CREATED;
1946       socd.skip_connection = connection;
1947       socd.failed = FALSE;
1948       socd.expected_service_name = service_name;
1949       bus_test_clients_foreach (check_service_owner_changed_foreach,
1950                                 &socd);
1951
1952       if (socd.failed)
1953         goto out;
1954
1955       dbus_message_unref (message);
1956       service_name = NULL;
1957       old_owner = NULL;
1958       base_service_from_bus = NULL;
1959
1960       message = pop_message_waiting_for_memory (connection);
1961       if (message == NULL)
1962         {
1963           _dbus_warn ("Expected a reply to %s, got nothing\n",
1964                       "StartServiceByName");
1965           goto out;
1966         }
1967     }
1968   else
1969     {
1970       warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
1971
1972       goto out;
1973     }
1974
1975   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
1976     {
1977       warn_unexpected (connection, message, "reply to StartServiceByName");
1978
1979       goto out;
1980     }
1981
1982   activation_result = 0;
1983   if (!dbus_message_get_args (message, &error,
1984                               DBUS_TYPE_UINT32, &activation_result,
1985                               DBUS_TYPE_INVALID))
1986     {
1987       if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1988         {
1989           _dbus_warn ("Did not have activation result first argument to %s: %s\n",
1990                       "StartServiceByName", error.message);
1991           goto out;
1992         }
1993
1994       dbus_error_free (&error);
1995     }
1996   else
1997     {
1998       if (activation_result == DBUS_START_REPLY_SUCCESS)
1999         ; /* Good */
2000       else if (activation_result == DBUS_START_REPLY_ALREADY_RUNNING)
2001         ; /* Good also */
2002       else
2003         {
2004           _dbus_warn ("Activation result was %u, no good.\n",
2005                       activation_result);
2006           goto out;
2007         }
2008     }
2009
2010   dbus_message_unref (message);
2011   message = NULL;
2012
2013   if (!check_no_leftovers (context))
2014     {
2015       _dbus_warn ("Messages were left over after verifying existent activation results\n");
2016       goto out;
2017     }
2018
2019   retval = TRUE;
2020
2021  out:
2022   if (message)
2023     dbus_message_unref (message);
2024   dbus_error_free (&error);
2025
2026   return retval;
2027 }
2028
2029 static dbus_bool_t
2030 check_service_auto_activated (BusContext     *context,
2031                               DBusConnection *connection,
2032                               const char     *activated_name,
2033                               const char     *base_service_name,
2034                               DBusMessage    *initial_message)
2035 {
2036   DBusMessage *message;
2037   dbus_bool_t retval;
2038   DBusError error;
2039
2040   retval = FALSE;
2041
2042   dbus_error_init (&error);
2043
2044   message = initial_message;
2045   dbus_message_ref (message);
2046
2047   if (dbus_message_is_signal (message,
2048                               DBUS_INTERFACE_DBUS,
2049                               "NameOwnerChanged"))
2050     {
2051       const char *service_name;
2052       CheckServiceOwnerChangedData socd;
2053
2054     reget_service_name_arg:
2055       if (!dbus_message_get_args (message, &error,
2056                                   DBUS_TYPE_STRING, &service_name,
2057                                   DBUS_TYPE_INVALID))
2058         {
2059           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
2060             {
2061               dbus_error_free (&error);
2062               _dbus_wait_for_memory ();
2063               goto reget_service_name_arg;
2064             }
2065           else
2066             {
2067               _dbus_warn ("Message %s doesn't have a service name: %s\n",
2068                           "NameOwnerChanged",
2069                           error.message);
2070               dbus_error_free (&error);
2071               goto out;
2072             }
2073         }
2074
2075       if (strcmp (service_name, activated_name) != 0)
2076         {
2077           _dbus_warn ("Expected to see service %s created, saw %s instead\n",
2078                       activated_name, service_name);
2079           goto out;
2080         }
2081
2082       socd.expected_kind = SERVICE_CREATED;
2083       socd.expected_service_name = service_name;
2084       socd.failed = FALSE;
2085       socd.skip_connection = connection;
2086       bus_test_clients_foreach (check_service_owner_changed_foreach,
2087                                 &socd);
2088
2089       if (socd.failed)
2090         goto out;
2091
2092       /* Note that this differs from regular activation in that we don't get a
2093        * reply to ActivateService here.
2094        */
2095
2096       dbus_message_unref (message);
2097       message = NULL;
2098       service_name = NULL;
2099     }
2100   else
2101     {
2102       warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
2103
2104       goto out;
2105     }
2106
2107   retval = TRUE;
2108
2109  out:
2110   if (message)
2111     dbus_message_unref (message);
2112
2113   return retval;
2114 }
2115
2116 static dbus_bool_t
2117 check_service_deactivated (BusContext     *context,
2118                            DBusConnection *connection,
2119                            const char     *activated_name,
2120                            const char     *base_service)
2121 {
2122   dbus_bool_t retval;
2123   CheckServiceOwnerChangedData socd;
2124
2125   retval = FALSE;
2126
2127   /* Now we are expecting ServiceOwnerChanged (deletion) messages for the base
2128    * service and the activated_name.  The base service
2129    * notification is required to come last.
2130    */
2131   socd.expected_kind = SERVICE_DELETED;
2132   socd.expected_service_name = activated_name;
2133   socd.failed = FALSE;
2134   socd.skip_connection = NULL;
2135   bus_test_clients_foreach (check_service_owner_changed_foreach,
2136                             &socd);
2137
2138   if (socd.failed)
2139     goto out;
2140
2141   socd.expected_kind = SERVICE_DELETED;
2142   socd.expected_service_name = base_service;
2143   socd.failed = FALSE;
2144   socd.skip_connection = NULL;
2145   bus_test_clients_foreach (check_service_owner_changed_foreach,
2146                             &socd);
2147
2148   if (socd.failed)
2149     goto out;
2150
2151   retval = TRUE;
2152
2153  out:
2154   return retval;
2155 }
2156
2157 static dbus_bool_t
2158 check_send_exit_to_service (BusContext     *context,
2159                             DBusConnection *connection,
2160                             const char     *service_name,
2161                             const char     *base_service)
2162 {
2163   dbus_bool_t got_error;
2164   DBusMessage *message;
2165   dbus_uint32_t serial;
2166   dbus_bool_t retval;
2167
2168   _dbus_verbose ("Sending exit message to the test service\n");
2169
2170   retval = FALSE;
2171
2172   /* Kill off the test service by sending it a quit message */
2173   message = dbus_message_new_method_call (service_name,
2174                                           "/org/freedesktop/TestSuite",
2175                                           "org.freedesktop.TestSuite",
2176                                           "Exit");
2177
2178   if (message == NULL)
2179     {
2180       /* Do this again; we still need the service to exit... */
2181       if (!check_send_exit_to_service (context, connection,
2182                                        service_name, base_service))
2183         goto out;
2184
2185       return TRUE;
2186     }
2187
2188   if (!dbus_connection_send (connection, message, &serial))
2189     {
2190       dbus_message_unref (message);
2191
2192       /* Do this again; we still need the service to exit... */
2193       if (!check_send_exit_to_service (context, connection,
2194                                        service_name, base_service))
2195         goto out;
2196
2197       return TRUE;
2198     }
2199
2200   dbus_message_unref (message);
2201   message = NULL;
2202
2203   /* send message */
2204   bus_test_run_clients_loop (SEND_PENDING (connection));
2205
2206   /* read it in and write it out to test service */
2207   bus_test_run_bus_loop (context, FALSE);
2208
2209   /* see if we got an error during message bus dispatching */
2210   bus_test_run_clients_loop (FALSE);
2211   message = borrow_message_waiting_for_memory (connection);
2212   got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
2213   if (message)
2214     {
2215       dbus_connection_return_message (connection, message);
2216       message = NULL;
2217     }
2218
2219   if (!got_error)
2220     {
2221       /* If no error, wait for the test service to exit */
2222       block_connection_until_message_from_bus (context, connection, "test service to exit");
2223
2224       bus_test_run_everything (context);
2225     }
2226
2227   if (got_error)
2228     {
2229       message = pop_message_waiting_for_memory (connection);
2230       _dbus_assert (message != NULL);
2231
2232       if (dbus_message_get_reply_serial (message) != serial)
2233         {
2234           warn_unexpected (connection, message,
2235                            "error with the correct reply serial");
2236           goto out;
2237         }
2238
2239       if (!dbus_message_is_error (message,
2240                                   DBUS_ERROR_NO_MEMORY))
2241         {
2242           warn_unexpected (connection, message,
2243                            "a no memory error from asking test service to exit");
2244           goto out;
2245         }
2246
2247       _dbus_verbose ("Got error %s when asking test service to exit\n",
2248                      dbus_message_get_error_name (message));
2249
2250       /* Do this again; we still need the service to exit... */
2251       if (!check_send_exit_to_service (context, connection,
2252                                        service_name, base_service))
2253         goto out;
2254     }
2255   else
2256     {
2257       if (!check_service_deactivated (context, connection,
2258                                       service_name, base_service))
2259         goto out;
2260
2261       /* Should now have a NoReply error from the Exit() method
2262        * call; it should have come after all the deactivation
2263        * stuff.
2264        */
2265       message = pop_message_waiting_for_memory (connection);
2266
2267       if (message == NULL)
2268         {
2269           warn_unexpected (connection, NULL,
2270                            "reply to Exit() method call");
2271           goto out;
2272         }
2273       if (!dbus_message_is_error (message,
2274                                   DBUS_ERROR_NO_REPLY))
2275         {
2276           warn_unexpected (connection, message,
2277                            "NoReply error from Exit() method call");
2278           goto out;
2279         }
2280
2281       if (dbus_message_get_reply_serial (message) != serial)
2282         {
2283           warn_unexpected (connection, message,
2284                            "error with the correct reply serial");
2285           goto out;
2286         }
2287
2288       _dbus_verbose ("Got error %s after test service exited\n",
2289                      dbus_message_get_error_name (message));
2290
2291       if (!check_no_leftovers (context))
2292         {
2293           _dbus_warn ("Messages were left over after %s\n",
2294                       _DBUS_FUNCTION_NAME);
2295           goto out;
2296         }
2297     }
2298
2299   retval = TRUE;
2300
2301  out:
2302   if (message)
2303     dbus_message_unref (message);
2304
2305   return retval;
2306 }
2307
2308 static dbus_bool_t
2309 check_got_error (BusContext     *context,
2310                  DBusConnection *connection,
2311                  const char     *first_error_name,
2312                  ...)
2313 {
2314   DBusMessage *message;
2315   dbus_bool_t retval;
2316   va_list ap;
2317   dbus_bool_t error_found;
2318   const char *error_name;
2319
2320   retval = FALSE;
2321
2322   message = pop_message_waiting_for_memory (connection);
2323   if (message == NULL)
2324     {
2325       _dbus_warn ("Did not get an expected error\n");
2326       goto out;
2327     }
2328
2329   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
2330     {
2331       warn_unexpected (connection, message, "an error");
2332
2333       goto out;
2334     }
2335
2336   error_found = FALSE;
2337
2338   va_start (ap, first_error_name);
2339   error_name = first_error_name;
2340   while (error_name != NULL)
2341     {
2342       if (dbus_message_is_error (message, error_name))
2343         {
2344           error_found = TRUE;
2345           break;
2346         }
2347       error_name = va_arg (ap, char*);
2348     }
2349   va_end (ap);
2350
2351   if (!error_found)
2352     {
2353       _dbus_warn ("Expected error %s or other, got %s instead\n",
2354                   first_error_name,
2355                   dbus_message_get_error_name (message));
2356       goto out;
2357     }
2358
2359   retval = TRUE;
2360
2361  out:
2362   if (message)
2363     dbus_message_unref (message);
2364
2365   return retval;
2366 }
2367
2368 typedef enum
2369 {
2370   GOT_SERVICE_CREATED,
2371   GOT_SERVICE_DELETED,
2372   GOT_ERROR,
2373   GOT_SOMETHING_ELSE
2374 } GotServiceInfo;
2375
2376 static GotServiceInfo
2377 check_got_service_info (DBusMessage *message)
2378 {
2379   GotServiceInfo message_kind;
2380
2381   if (dbus_message_is_signal (message,
2382                               DBUS_INTERFACE_DBUS,
2383                               "NameOwnerChanged"))
2384     {
2385       DBusError error;
2386       const char *service_name, *old_owner, *new_owner;
2387       dbus_error_init (&error);
2388
2389     reget_service_info_data:
2390       service_name = NULL;
2391       old_owner = NULL;
2392       new_owner = NULL;
2393
2394       dbus_message_get_args (message, &error,
2395                              DBUS_TYPE_STRING, &service_name,
2396                              DBUS_TYPE_STRING, &old_owner,
2397                              DBUS_TYPE_STRING, &new_owner,
2398                              DBUS_TYPE_INVALID);
2399       if (dbus_error_is_set (&error))
2400         {
2401           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
2402             {
2403               dbus_error_free (&error);
2404               goto reget_service_info_data;
2405             }
2406           else
2407             {
2408               _dbus_warn ("unexpected arguments for NameOwnerChanged message\n");
2409               message_kind = GOT_SOMETHING_ELSE;
2410             }
2411         }
2412       else if (!old_owner[0])
2413         message_kind = GOT_SERVICE_CREATED;
2414       else if (!new_owner[0])
2415         message_kind = GOT_SERVICE_DELETED;
2416       else
2417         message_kind = GOT_SOMETHING_ELSE;
2418
2419       dbus_error_free (&error);
2420     }
2421   else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2422     message_kind = GOT_ERROR;
2423   else
2424     message_kind = GOT_SOMETHING_ELSE;
2425
2426   return message_kind;
2427 }
2428
2429 #define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService"
2430
2431 /* returns TRUE if the correct thing happens,
2432  * but the correct thing may include OOM errors.
2433  */
2434 static dbus_bool_t
2435 check_existent_service_no_auto_start (BusContext     *context,
2436                                       DBusConnection *connection)
2437 {
2438   DBusMessage *message;
2439   DBusMessage *base_service_message;
2440   const char *base_service;
2441   dbus_uint32_t serial;
2442   dbus_bool_t retval;
2443   const char *existent = EXISTENT_SERVICE_NAME;
2444   dbus_uint32_t flags;
2445
2446   base_service_message = NULL;
2447
2448   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2449                                           DBUS_PATH_DBUS,
2450                                           DBUS_INTERFACE_DBUS,
2451                                           "StartServiceByName");
2452
2453   if (message == NULL)
2454     return TRUE;
2455
2456   dbus_message_set_auto_start (message, FALSE);
2457
2458   flags = 0;
2459   if (!dbus_message_append_args (message,
2460                                  DBUS_TYPE_STRING, &existent,
2461                                  DBUS_TYPE_UINT32, &flags,
2462                                  DBUS_TYPE_INVALID))
2463     {
2464       dbus_message_unref (message);
2465       return TRUE;
2466     }
2467
2468   if (!dbus_connection_send (connection, message, &serial))
2469     {
2470       dbus_message_unref (message);
2471       return TRUE;
2472     }
2473
2474   dbus_message_unref (message);
2475   message = NULL;
2476
2477   bus_test_run_everything (context);
2478
2479   /* now wait for the message bus to hear back from the activated
2480    * service.
2481    */
2482   block_connection_until_message_from_bus (context, connection, "activated service to connect");
2483
2484   bus_test_run_everything (context);
2485
2486   if (!dbus_connection_get_is_connected (connection))
2487     {
2488       _dbus_verbose ("connection was disconnected\n");
2489       return TRUE;
2490     }
2491
2492   retval = FALSE;
2493
2494   message = pop_message_waiting_for_memory (connection);
2495   if (message == NULL)
2496     {
2497       _dbus_warn ("Did not receive any messages after %s %d on %p\n",
2498                   "StartServiceByName", serial, connection);
2499       goto out;
2500     }
2501
2502   verbose_message_received (connection, message);
2503   _dbus_verbose ("  (after sending %s)\n", "StartServiceByName");
2504
2505   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2506     {
2507       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2508         {
2509           _dbus_warn ("Message has wrong sender %s\n",
2510                       dbus_message_get_sender (message) ?
2511                       dbus_message_get_sender (message) : "(none)");
2512           goto out;
2513         }
2514
2515       if (dbus_message_is_error (message,
2516                                  DBUS_ERROR_NO_MEMORY))
2517         {
2518           ; /* good, this is a valid response */
2519         }
2520       else if (dbus_message_is_error (message,
2521                                       DBUS_ERROR_SPAWN_CHILD_EXITED) ||
2522                dbus_message_is_error (message,
2523                                       DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
2524                dbus_message_is_error (message,
2525                                       DBUS_ERROR_SPAWN_EXEC_FAILED))
2526         {
2527           ; /* good, this is expected also */
2528         }
2529       else
2530         {
2531           _dbus_warn ("Did not expect error %s\n",
2532                       dbus_message_get_error_name (message));
2533           goto out;
2534         }
2535     }
2536   else
2537     {
2538       GotServiceInfo message_kind;
2539
2540       if (!check_base_service_activated (context, connection,
2541                                          message, &base_service))
2542         goto out;
2543
2544       base_service_message = message;
2545       message = NULL;
2546
2547       /* We may need to block here for the test service to exit or finish up */
2548       block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
2549
2550       message = dbus_connection_borrow_message (connection);
2551       if (message == NULL)
2552         {
2553           _dbus_warn ("Did not receive any messages after base service creation notification\n");
2554           goto out;
2555         }
2556
2557       message_kind = check_got_service_info (message);
2558
2559       dbus_connection_return_message (connection, message);
2560       message = NULL;
2561
2562       switch (message_kind)
2563         {
2564         case GOT_SOMETHING_ELSE:
2565           _dbus_warn ("Unexpected message after ActivateService "
2566                       "(should be an error or a service announcement");
2567           goto out;
2568
2569         case GOT_ERROR:
2570           if (!check_got_error (context, connection,
2571                                 DBUS_ERROR_SPAWN_CHILD_EXITED,
2572                                 DBUS_ERROR_NO_MEMORY,
2573                                 NULL))
2574             goto out;
2575           /* A service deleted should be coming along now after this error.
2576            * We can also get the error *after* the service deleted.
2577            */
2578
2579           /* fall through */
2580
2581         case GOT_SERVICE_DELETED:
2582           {
2583             /* The service started up and got a base address, but then
2584              * failed to register under EXISTENT_SERVICE_NAME
2585              */
2586             CheckServiceOwnerChangedData socd;
2587
2588             socd.expected_kind = SERVICE_DELETED;
2589             socd.expected_service_name = base_service;
2590             socd.failed = FALSE;
2591             socd.skip_connection = NULL;
2592
2593             bus_test_clients_foreach (check_service_owner_changed_foreach,
2594                                       &socd);
2595
2596             if (socd.failed)
2597               goto out;
2598
2599             /* Now we should get an error about the service exiting
2600              * if we didn't get it before.
2601              */
2602             if (message_kind != GOT_ERROR)
2603               {
2604                 block_connection_until_message_from_bus (context, connection, "error about service exiting");
2605
2606                 /* and process everything again */
2607                 bus_test_run_everything (context);
2608
2609                 if (!check_got_error (context, connection,
2610                                       DBUS_ERROR_SPAWN_CHILD_EXITED,
2611                                       DBUS_ERROR_NO_MEMORY,
2612                                       NULL))
2613                   goto out;
2614               }
2615             break;
2616           }
2617
2618         case GOT_SERVICE_CREATED:
2619           message = pop_message_waiting_for_memory (connection);
2620           if (message == NULL)
2621             {
2622               _dbus_warn ("Failed to pop message we just put back! "
2623                           "should have been a NameOwnerChanged (creation)\n");
2624               goto out;
2625             }
2626
2627           if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
2628                                         base_service, message))
2629             goto out;
2630
2631           dbus_message_unref (message);
2632           message = NULL;
2633
2634           if (!check_no_leftovers (context))
2635             {
2636               _dbus_warn ("Messages were left over after successful activation\n");
2637               goto out;
2638             }
2639
2640           if (!check_send_exit_to_service (context, connection,
2641                                            EXISTENT_SERVICE_NAME, base_service))
2642             goto out;
2643
2644           break;
2645         }
2646     }
2647
2648   retval = TRUE;
2649
2650  out:
2651   if (message)
2652     dbus_message_unref (message);
2653
2654   if (base_service_message)
2655     dbus_message_unref (base_service_message);
2656
2657   return retval;
2658 }
2659
2660 #ifndef DBUS_WIN_FIXME
2661 /* returns TRUE if the correct thing happens,
2662  * but the correct thing may include OOM errors.
2663  */
2664 static dbus_bool_t
2665 check_segfault_service_no_auto_start (BusContext     *context,
2666                                       DBusConnection *connection)
2667 {
2668   DBusMessage *message;
2669   dbus_uint32_t serial;
2670   dbus_bool_t retval;
2671   const char *segv_service;
2672   dbus_uint32_t flags;
2673
2674   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2675                                           DBUS_PATH_DBUS,
2676                                           DBUS_INTERFACE_DBUS,
2677                                           "StartServiceByName");
2678
2679   if (message == NULL)
2680     return TRUE;
2681
2682   dbus_message_set_auto_start (message, FALSE);
2683
2684   segv_service = "org.freedesktop.DBus.TestSuiteSegfaultService";
2685   flags = 0;
2686   if (!dbus_message_append_args (message,
2687                                  DBUS_TYPE_STRING, &segv_service,
2688                                  DBUS_TYPE_UINT32, &flags,
2689                                  DBUS_TYPE_INVALID))
2690     {
2691       dbus_message_unref (message);
2692       return TRUE;
2693     }
2694
2695   if (!dbus_connection_send (connection, message, &serial))
2696     {
2697       dbus_message_unref (message);
2698       return TRUE;
2699     }
2700
2701   dbus_message_unref (message);
2702   message = NULL;
2703
2704   bus_test_run_everything (context);
2705   block_connection_until_message_from_bus (context, connection, "reply to activating segfault service");
2706   bus_test_run_everything (context);
2707
2708   if (!dbus_connection_get_is_connected (connection))
2709     {
2710       _dbus_verbose ("connection was disconnected\n");
2711       return TRUE;
2712     }
2713
2714   retval = FALSE;
2715
2716   message = pop_message_waiting_for_memory (connection);
2717   if (message == NULL)
2718     {
2719       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
2720                   "StartServiceByName", serial, connection);
2721       goto out;
2722     }
2723
2724   verbose_message_received (connection, message);
2725
2726   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2727     {
2728       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2729         {
2730           _dbus_warn ("Message has wrong sender %s\n",
2731                       dbus_message_get_sender (message) ?
2732                       dbus_message_get_sender (message) : "(none)");
2733           goto out;
2734         }
2735
2736       if (dbus_message_is_error (message,
2737                                  DBUS_ERROR_NO_MEMORY))
2738         {
2739           ; /* good, this is a valid response */
2740         }
2741       else if (dbus_message_is_error (message,
2742                                       DBUS_ERROR_FAILED))
2743         {
2744           const char *servicehelper;
2745           servicehelper = bus_context_get_servicehelper (context);
2746           /* make sure this only happens with the launch helper */
2747           _dbus_assert (servicehelper != NULL);
2748         }
2749       else if (dbus_message_is_error (message,
2750                                       DBUS_ERROR_SPAWN_CHILD_SIGNALED))
2751         {
2752           ; /* good, this is expected also */
2753         }
2754       else
2755         {
2756           warn_unexpected (connection, message, "not this error");
2757
2758           goto out;
2759         }
2760     }
2761   else
2762     {
2763       _dbus_warn ("Did not expect to successfully activate segfault service\n");
2764       goto out;
2765     }
2766
2767   retval = TRUE;
2768
2769  out:
2770   if (message)
2771     dbus_message_unref (message);
2772
2773   return retval;
2774 }
2775
2776
2777 /* returns TRUE if the correct thing happens,
2778  * but the correct thing may include OOM errors.
2779  */
2780 static dbus_bool_t
2781 check_segfault_service_auto_start (BusContext     *context,
2782                                    DBusConnection *connection)
2783 {
2784   DBusMessage *message;
2785   dbus_uint32_t serial;
2786   dbus_bool_t retval;
2787
2788   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteSegfaultService",
2789                                           "/org/freedesktop/TestSuite",
2790                                           "org.freedesktop.TestSuite",
2791                                           "Echo");
2792
2793   if (message == NULL)
2794     return TRUE;
2795
2796   if (!dbus_connection_send (connection, message, &serial))
2797     {
2798       dbus_message_unref (message);
2799       return TRUE;
2800     }
2801
2802   dbus_message_unref (message);
2803   message = NULL;
2804
2805   bus_test_run_everything (context);
2806   block_connection_until_message_from_bus (context, connection, "reply to Echo on segfault service");
2807   bus_test_run_everything (context);
2808
2809   if (!dbus_connection_get_is_connected (connection))
2810     {
2811       _dbus_verbose ("connection was disconnected\n");
2812       return TRUE;
2813     }
2814
2815   retval = FALSE;
2816
2817   message = pop_message_waiting_for_memory (connection);
2818   if (message == NULL)
2819     {
2820       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
2821                   "Echo message (auto activation)", serial, connection);
2822       goto out;
2823     }
2824
2825   verbose_message_received (connection, message);
2826
2827   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2828     {
2829       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2830         {
2831           _dbus_warn ("Message has wrong sender %s\n",
2832                       dbus_message_get_sender (message) ?
2833                       dbus_message_get_sender (message) : "(none)");
2834           goto out;
2835         }
2836
2837       if (dbus_message_is_error (message,
2838                                  DBUS_ERROR_NO_MEMORY))
2839         {
2840           ; /* good, this is a valid response */
2841         }
2842       else if (dbus_message_is_error (message,
2843                                       DBUS_ERROR_SPAWN_CHILD_SIGNALED))
2844         {
2845           ; /* good, this is expected also */
2846         }
2847       else
2848         {
2849           warn_unexpected (connection, message, "not this error");
2850
2851           goto out;
2852         }
2853     }
2854   else
2855     {
2856       _dbus_warn ("Did not expect to successfully activate segfault service\n");
2857       goto out;
2858     }
2859
2860   retval = TRUE;
2861
2862  out:
2863   if (message)
2864     dbus_message_unref (message);
2865
2866   return retval;
2867 }
2868 #endif
2869
2870 #define TEST_ECHO_MESSAGE "Test echo message"
2871 #define TEST_RUN_HELLO_FROM_SELF_MESSAGE "Test sending message to self"
2872
2873 /* returns TRUE if the correct thing happens,
2874  * but the correct thing may include OOM errors.
2875  */
2876 static dbus_bool_t
2877 check_existent_hello_from_self (BusContext     *context,
2878                                 DBusConnection *connection)
2879 {
2880   DBusMessage *message;
2881   dbus_uint32_t serial;
2882   const char *text;
2883
2884   message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2885                                           "/org/freedesktop/TestSuite",
2886                                           "org.freedesktop.TestSuite",
2887                                           "RunHelloFromSelf");
2888
2889   if (message == NULL)
2890     return TRUE;
2891
2892   text = TEST_RUN_HELLO_FROM_SELF_MESSAGE;
2893   if (!dbus_message_append_args (message,
2894                                  DBUS_TYPE_STRING, &text,
2895                                  DBUS_TYPE_INVALID))
2896     {
2897       dbus_message_unref (message);
2898       return TRUE;
2899     }
2900
2901   if (!dbus_connection_send (connection, message, &serial))
2902     {
2903       dbus_message_unref (message);
2904       return TRUE;
2905     }
2906
2907   dbus_message_unref (message);
2908   message = NULL;
2909
2910   bus_test_run_everything (context);
2911
2912   /* Note: if this test is run in OOM mode, it will block when the bus
2913    * doesn't send a reply due to OOM.
2914    */
2915   block_connection_until_message_from_bus (context, connection, "reply from running hello from self");
2916
2917   message = pop_message_waiting_for_memory (connection);
2918   if (message == NULL)
2919     {
2920       _dbus_warn ("Failed to pop message! Should have been reply from RunHelloFromSelf message\n");
2921       return FALSE;
2922     }
2923
2924   if (dbus_message_get_reply_serial (message) != serial)
2925     {
2926       _dbus_warn ("Wrong reply serial\n");
2927       dbus_message_unref (message);
2928       return FALSE;
2929     }
2930
2931   dbus_message_unref (message);
2932   message = NULL;
2933
2934   return TRUE;
2935 }
2936
2937 /* returns TRUE if the correct thing happens,
2938  * but the correct thing may include OOM errors.
2939  */
2940 static dbus_bool_t
2941 check_existent_ping (BusContext     *context,
2942                      DBusConnection *connection)
2943 {
2944   DBusMessage *message;
2945   dbus_uint32_t serial;
2946   message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2947                                           "/org/freedesktop/TestSuite",
2948                                           "org.freedesktop.DBus.Peer",
2949                                           "Ping");
2950
2951   if (message == NULL)
2952     return TRUE;
2953
2954   if (!dbus_connection_send (connection, message, &serial))
2955     {
2956       dbus_message_unref (message);
2957       return TRUE;
2958     }
2959
2960   dbus_message_unref (message);
2961   message = NULL;
2962
2963   bus_test_run_everything (context);
2964
2965   /* Note: if this test is run in OOM mode, it will block when the bus
2966    * doesn't send a reply due to OOM.
2967    */
2968   block_connection_until_message_from_bus (context, connection, "reply from running Ping");
2969
2970   message = pop_message_waiting_for_memory (connection);
2971   if (message == NULL)
2972     {
2973       _dbus_warn ("Failed to pop message! Should have been reply from Ping message\n");
2974       return FALSE;
2975     }
2976
2977   if (dbus_message_get_reply_serial (message) != serial)
2978     {
2979       _dbus_warn ("Wrong reply serial\n");
2980       dbus_message_unref (message);
2981       return FALSE;
2982     }
2983
2984   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
2985     {
2986       _dbus_warn ("Unexpected message return during Ping\n");
2987       dbus_message_unref (message);
2988       return FALSE;
2989     }
2990
2991   dbus_message_unref (message);
2992   message = NULL;
2993
2994   return TRUE;
2995 }
2996
2997 /* returns TRUE if the correct thing happens,
2998  * but the correct thing may include OOM errors.
2999  */
3000 static dbus_bool_t
3001 check_existent_get_machine_id (BusContext     *context,
3002                                DBusConnection *connection)
3003 {
3004   DBusMessage *message;
3005   dbus_uint32_t serial;
3006   const char *machine_id;
3007
3008   message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
3009                                           "/org/freedesktop/TestSuite",
3010                                           "org.freedesktop.DBus.Peer",
3011                                           "GetMachineId");
3012
3013   if (message == NULL)
3014     return TRUE;
3015
3016   if (!dbus_connection_send (connection, message, &serial))
3017     {
3018       dbus_message_unref (message);
3019       return TRUE;
3020     }
3021
3022   dbus_message_unref (message);
3023   message = NULL;
3024
3025   bus_test_run_everything (context);
3026
3027   /* Note: if this test is run in OOM mode, it will block when the bus
3028    * doesn't send a reply due to OOM.
3029    */
3030   block_connection_until_message_from_bus (context, connection, "reply from running GetMachineId");
3031
3032   message = pop_message_waiting_for_memory (connection);
3033   if (message == NULL)
3034     {
3035       _dbus_warn ("Failed to pop message! Should have been reply from GetMachineId message\n");
3036       return FALSE;
3037     }
3038
3039   if (dbus_message_get_reply_serial (message) != serial)
3040     {
3041       _dbus_warn ("Wrong reply serial\n");
3042       dbus_message_unref (message);
3043       return FALSE;
3044     }
3045
3046   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
3047     {
3048       _dbus_warn ("Unexpected message return during GetMachineId\n");
3049       dbus_message_unref (message);
3050       return FALSE;
3051     }
3052
3053   machine_id = NULL;
3054   if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &machine_id, DBUS_TYPE_INVALID))
3055     {
3056       _dbus_warn ("Did not get a machine ID in reply to GetMachineId\n");
3057       dbus_message_unref (message);
3058       return FALSE;
3059     }
3060
3061   if (machine_id == NULL || strlen (machine_id) != 32)
3062     {
3063       _dbus_warn ("Machine id looks bogus: '%s'\n", machine_id ? machine_id : "null");
3064       dbus_message_unref (message);
3065       return FALSE;
3066     }
3067
3068   /* We can't check that the machine id is correct because during make check it is
3069    * just made up for each process separately
3070    */
3071
3072   dbus_message_unref (message);
3073   message = NULL;
3074
3075   return TRUE;
3076 }
3077
3078 /* returns TRUE if the correct thing happens,
3079  * but the correct thing may include OOM errors.
3080  */
3081 static dbus_bool_t
3082 check_existent_service_auto_start (BusContext     *context,
3083                                    DBusConnection *connection)
3084 {
3085   DBusMessage *message;
3086   DBusMessage *base_service_message;
3087   dbus_uint32_t serial;
3088   dbus_bool_t retval;
3089   const char *base_service;
3090   const char *text;
3091
3092   base_service_message = NULL;
3093
3094   message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
3095                                           "/org/freedesktop/TestSuite",
3096                                           "org.freedesktop.TestSuite",
3097                                           "Echo");
3098
3099   if (message == NULL)
3100     return TRUE;
3101
3102   text = TEST_ECHO_MESSAGE;
3103   if (!dbus_message_append_args (message,
3104                                  DBUS_TYPE_STRING, &text,
3105                                  DBUS_TYPE_INVALID))
3106     {
3107       dbus_message_unref (message);
3108       return TRUE;
3109     }
3110
3111   if (!dbus_connection_send (connection, message, &serial))
3112     {
3113       dbus_message_unref (message);
3114       return TRUE;
3115     }
3116
3117   dbus_message_unref (message);
3118   message = NULL;
3119
3120   bus_test_run_everything (context);
3121
3122   /* now wait for the message bus to hear back from the activated
3123    * service.
3124    */
3125   block_connection_until_message_from_bus (context, connection, "reply to Echo on existent service");
3126   bus_test_run_everything (context);
3127
3128   if (!dbus_connection_get_is_connected (connection))
3129     {
3130       _dbus_verbose ("connection was disconnected\n");
3131       return TRUE;
3132     }
3133
3134   retval = FALSE;
3135
3136   message = pop_message_waiting_for_memory (connection);
3137   if (message == NULL)
3138     {
3139       _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
3140                   serial, connection);
3141       goto out;
3142     }
3143
3144   verbose_message_received (connection, message);
3145   _dbus_verbose ("  (after sending %s)\n", "auto start");
3146
3147   /* we should get zero or two ServiceOwnerChanged signals */
3148   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
3149     {
3150       GotServiceInfo message_kind;
3151
3152       if (!check_base_service_activated (context, connection,
3153                                          message, &base_service))
3154         goto out;
3155
3156       base_service_message = message;
3157       message = NULL;
3158
3159       /* We may need to block here for the test service to exit or finish up */
3160       block_connection_until_message_from_bus (context, connection, "service to exit");
3161
3162       /* Should get a service creation notification for the activated
3163        * service name, or a service deletion on the base service name
3164        */
3165       message = dbus_connection_borrow_message (connection);
3166       if (message == NULL)
3167         {
3168           _dbus_warn ("No message after auto activation "
3169                       "(should be a service announcement)\n");
3170           dbus_connection_return_message (connection, message);
3171           message = NULL;
3172           goto out;
3173         }
3174
3175       message_kind = check_got_service_info (message);
3176
3177       dbus_connection_return_message (connection, message);
3178       message = NULL;
3179
3180       switch (message_kind)
3181         {
3182         case GOT_SERVICE_CREATED:
3183           message = pop_message_waiting_for_memory (connection);
3184           if (message == NULL)
3185             {
3186               _dbus_warn ("Failed to pop message we just put back! "
3187                           "should have been a NameOwnerChanged (creation)\n");
3188               goto out;
3189             }
3190
3191           /* Check that ServiceOwnerChanged (creation) was correctly received */
3192           if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME,
3193                                              base_service, message))
3194             goto out;
3195
3196           dbus_message_unref (message);
3197           message = NULL;
3198
3199           break;
3200
3201         case GOT_SERVICE_DELETED:
3202           {
3203             /* The service started up and got a base address, but then
3204              * failed to register under EXISTENT_SERVICE_NAME
3205              */
3206             CheckServiceOwnerChangedData socd;
3207
3208             socd.expected_kind = SERVICE_DELETED;
3209             socd.expected_service_name = base_service;
3210             socd.failed = FALSE;
3211             socd.skip_connection = NULL;
3212             bus_test_clients_foreach (check_service_owner_changed_foreach,
3213                                       &socd);
3214
3215             if (socd.failed)
3216               goto out;
3217
3218             break;
3219           }
3220
3221         case GOT_ERROR:
3222         case GOT_SOMETHING_ELSE:
3223           _dbus_warn ("Unexpected message after auto activation\n");
3224           goto out;
3225         }
3226     }
3227
3228   /* OK, now we've dealt with ServiceOwnerChanged signals, now should
3229    * come the method reply (or error) from the initial method call
3230    */
3231
3232   /* Note: if this test is run in OOM mode, it will block when the bus
3233    * doesn't send a reply due to OOM.
3234    */
3235   block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3236
3237   message = pop_message_waiting_for_memory (connection);
3238   if (message == NULL)
3239     {
3240       _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
3241       goto out;
3242     }
3243
3244   if (dbus_message_get_reply_serial (message) != serial)
3245     {
3246       _dbus_warn ("Wrong reply serial\n");
3247       goto out;
3248     }
3249
3250   dbus_message_unref (message);
3251   message = NULL;
3252
3253   if (!check_existent_ping (context, connection))
3254     goto out;
3255
3256   if (!check_existent_get_machine_id (context, connection))
3257     goto out;
3258
3259   if (!check_existent_hello_from_self (context, connection))
3260     goto out;
3261
3262   if (!check_send_exit_to_service (context, connection,
3263                                    EXISTENT_SERVICE_NAME,
3264                                    base_service))
3265     goto out;
3266
3267   retval = TRUE;
3268
3269  out:
3270   if (message)
3271     dbus_message_unref (message);
3272
3273   if (base_service_message)
3274     dbus_message_unref (base_service_message);
3275
3276   return retval;
3277 }
3278
3279 #define SERVICE_FILE_MISSING_NAME "org.freedesktop.DBus.TestSuiteEchoServiceDotServiceFileDoesNotExist"
3280
3281 /* returns TRUE if the correct thing happens,
3282  * but the correct thing may include OOM errors.
3283  */
3284 static dbus_bool_t
3285 check_launch_service_file_missing (BusContext     *context,
3286                                    DBusConnection *connection)
3287 {
3288   DBusMessage *message;
3289   dbus_uint32_t serial;
3290   dbus_bool_t retval;
3291
3292   message = dbus_message_new_method_call (SERVICE_FILE_MISSING_NAME,
3293                                           "/org/freedesktop/TestSuite",
3294                                           "org.freedesktop.TestSuite",
3295                                           "Echo");
3296
3297   if (message == NULL)
3298     return TRUE;
3299
3300   if (!dbus_connection_send (connection, message, &serial))
3301     {
3302       dbus_message_unref (message);
3303       return TRUE;
3304     }
3305
3306   dbus_message_unref (message);
3307   message = NULL;
3308
3309   bus_test_run_everything (context);
3310   block_connection_until_message_from_bus (context, connection, "reply to service file missing should fail to auto-start");
3311   bus_test_run_everything (context);
3312
3313   if (!dbus_connection_get_is_connected (connection))
3314     {
3315       _dbus_verbose ("connection was disconnected\n");
3316       return TRUE;
3317     }
3318
3319   retval = FALSE;
3320
3321   message = pop_message_waiting_for_memory (connection);
3322   if (message == NULL)
3323     {
3324       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3325                   "Echo message (auto activation)", serial, connection);
3326       goto out;
3327     }
3328
3329   verbose_message_received (connection, message);
3330
3331   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3332     {
3333       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3334         {
3335           _dbus_warn ("Message has wrong sender %s\n",
3336                       dbus_message_get_sender (message) ?
3337                       dbus_message_get_sender (message) : "(none)");
3338           goto out;
3339         }
3340
3341       if (dbus_message_is_error (message,
3342                                  DBUS_ERROR_NO_MEMORY))
3343         {
3344           ; /* good, this is a valid response */
3345         }
3346       else if (dbus_message_is_error (message,
3347                                       DBUS_ERROR_SERVICE_UNKNOWN))
3348         {
3349           _dbus_verbose("got service unknown\n");
3350           ; /* good, this is expected (only valid when using launch helper) */
3351         }
3352       else
3353         {
3354           warn_unexpected (connection, message, "not this error");
3355
3356           goto out;
3357         }
3358     }
3359   else
3360     {
3361       _dbus_warn ("Did not expect to successfully auto-start missing service\n");
3362       goto out;
3363     }
3364
3365   retval = TRUE;
3366
3367  out:
3368   if (message)
3369     dbus_message_unref (message);
3370
3371   return retval;
3372 }
3373
3374 #define SERVICE_USER_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoUser"
3375
3376 /* returns TRUE if the correct thing happens,
3377  * but the correct thing may include OOM errors.
3378  */
3379 static dbus_bool_t
3380 check_launch_service_user_missing (BusContext     *context,
3381                                    DBusConnection *connection)
3382 {
3383   DBusMessage *message;
3384   dbus_uint32_t serial;
3385   dbus_bool_t retval;
3386
3387   message = dbus_message_new_method_call (SERVICE_USER_MISSING_NAME,
3388                                           "/org/freedesktop/TestSuite",
3389                                           "org.freedesktop.TestSuite",
3390                                           "Echo");
3391
3392   if (message == NULL)
3393     return TRUE;
3394
3395   if (!dbus_connection_send (connection, message, &serial))
3396     {
3397       dbus_message_unref (message);
3398       return TRUE;
3399     }
3400
3401   dbus_message_unref (message);
3402   message = NULL;
3403
3404   bus_test_run_everything (context);
3405   block_connection_until_message_from_bus (context, connection,
3406                                            "reply to service which should fail to auto-start (missing User)");
3407   bus_test_run_everything (context);
3408
3409   if (!dbus_connection_get_is_connected (connection))
3410     {
3411       _dbus_warn ("connection was disconnected\n");
3412       return TRUE;
3413     }
3414
3415   retval = FALSE;
3416
3417   message = pop_message_waiting_for_memory (connection);
3418   if (message == NULL)
3419     {
3420       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3421                   "Echo message (auto activation)", serial, connection);
3422       goto out;
3423     }
3424
3425   verbose_message_received (connection, message);
3426
3427   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3428     {
3429       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3430         {
3431           _dbus_warn ("Message has wrong sender %s\n",
3432                       dbus_message_get_sender (message) ?
3433                       dbus_message_get_sender (message) : "(none)");
3434           goto out;
3435         }
3436
3437       if (dbus_message_is_error (message,
3438                                  DBUS_ERROR_NO_MEMORY))
3439         {
3440           ; /* good, this is a valid response */
3441         }
3442       else if (dbus_message_is_error (message,
3443                                       DBUS_ERROR_SPAWN_FILE_INVALID))
3444         {
3445           _dbus_verbose("got service file invalid\n");
3446           ; /* good, this is expected (only valid when using launch helper) */
3447         }
3448       else
3449         {
3450           warn_unexpected (connection, message, "not this error");
3451
3452           goto out;
3453         }
3454     }
3455   else
3456     {
3457       _dbus_warn ("Did not expect to successfully auto-start missing service\n");
3458       goto out;
3459     }
3460
3461   retval = TRUE;
3462
3463  out:
3464   if (message)
3465     dbus_message_unref (message);
3466
3467   return retval;
3468 }
3469
3470 #define SERVICE_EXEC_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoExec"
3471
3472 /* returns TRUE if the correct thing happens,
3473  * but the correct thing may include OOM errors.
3474  */
3475 static dbus_bool_t
3476 check_launch_service_exec_missing (BusContext     *context,
3477                                    DBusConnection *connection)
3478 {
3479   DBusMessage *message;
3480   dbus_uint32_t serial;
3481   dbus_bool_t retval;
3482
3483   message = dbus_message_new_method_call (SERVICE_EXEC_MISSING_NAME,
3484                                           "/org/freedesktop/TestSuite",
3485                                           "org.freedesktop.TestSuite",
3486                                           "Echo");
3487
3488   if (message == NULL)
3489     return TRUE;
3490
3491   if (!dbus_connection_send (connection, message, &serial))
3492     {
3493       dbus_message_unref (message);
3494       return TRUE;
3495     }
3496
3497   dbus_message_unref (message);
3498   message = NULL;
3499
3500   bus_test_run_everything (context);
3501   block_connection_until_message_from_bus (context, connection,
3502                                            "reply to service which should fail to auto-start (missing Exec)");
3503   bus_test_run_everything (context);
3504
3505   if (!dbus_connection_get_is_connected (connection))
3506     {
3507       _dbus_warn ("connection was disconnected\n");
3508       return TRUE;
3509     }
3510
3511   retval = FALSE;
3512
3513   message = pop_message_waiting_for_memory (connection);
3514   if (message == NULL)
3515     {
3516       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3517                   "Echo message (auto activation)", serial, connection);
3518       goto out;
3519     }
3520
3521   verbose_message_received (connection, message);
3522
3523   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3524     {
3525       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3526         {
3527           _dbus_warn ("Message has wrong sender %s\n",
3528                       dbus_message_get_sender (message) ?
3529                       dbus_message_get_sender (message) : "(none)");
3530           goto out;
3531         }
3532
3533       if (dbus_message_is_error (message,
3534                                  DBUS_ERROR_NO_MEMORY))
3535         {
3536           ; /* good, this is a valid response */
3537         }
3538       else if (dbus_message_is_error (message,
3539                                       DBUS_ERROR_SERVICE_UNKNOWN))
3540         {
3541           _dbus_verbose("could not activate as invalid service file was not added\n");
3542           ; /* good, this is expected as we shouldn't have been added to
3543              * the activation list with a missing Exec key */
3544         }
3545       else if (dbus_message_is_error (message,
3546                                       DBUS_ERROR_SPAWN_FILE_INVALID))
3547         {
3548           _dbus_verbose("got service file invalid\n");
3549           ; /* good, this is allowed, and is the message passed back from the
3550              * launch helper */
3551         }
3552       else
3553         {
3554           warn_unexpected (connection, message, "not this error");
3555
3556           goto out;
3557         }
3558     }
3559   else
3560     {
3561       _dbus_warn ("Did not expect to successfully auto-start missing service\n");
3562       goto out;
3563     }
3564
3565   retval = TRUE;
3566
3567  out:
3568   if (message)
3569     dbus_message_unref (message);
3570
3571   return retval;
3572 }
3573
3574 #define SERVICE_SERVICE_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoService"
3575
3576 /* returns TRUE if the correct thing happens,
3577  * but the correct thing may include OOM errors.
3578  */
3579 static dbus_bool_t
3580 check_launch_service_service_missing (BusContext     *context,
3581                                       DBusConnection *connection)
3582 {
3583   DBusMessage *message;
3584   dbus_uint32_t serial;
3585   dbus_bool_t retval;
3586
3587   message = dbus_message_new_method_call (SERVICE_SERVICE_MISSING_NAME,
3588                                           "/org/freedesktop/TestSuite",
3589                                           "org.freedesktop.TestSuite",
3590                                           "Echo");
3591
3592   if (message == NULL)
3593     return TRUE;
3594
3595   if (!dbus_connection_send (connection, message, &serial))
3596     {
3597       dbus_message_unref (message);
3598       return TRUE;
3599     }
3600
3601   dbus_message_unref (message);
3602   message = NULL;
3603
3604   bus_test_run_everything (context);
3605   block_connection_until_message_from_bus (context, connection,
3606                                            "reply to service which should fail to auto-start (missing Service)");
3607   bus_test_run_everything (context);
3608
3609   if (!dbus_connection_get_is_connected (connection))
3610     {
3611       _dbus_warn ("connection was disconnected\n");
3612       return TRUE;
3613     }
3614
3615   retval = FALSE;
3616
3617   message = pop_message_waiting_for_memory (connection);
3618   if (message == NULL)
3619     {
3620       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3621                   "Echo message (auto activation)", serial, connection);
3622       goto out;
3623     }
3624
3625   verbose_message_received (connection, message);
3626
3627   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3628     {
3629       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3630         {
3631           _dbus_warn ("Message has wrong sender %s\n",
3632                       dbus_message_get_sender (message) ?
3633                       dbus_message_get_sender (message) : "(none)");
3634           goto out;
3635         }
3636
3637       if (dbus_message_is_error (message,
3638                                  DBUS_ERROR_NO_MEMORY))
3639         {
3640           ; /* good, this is a valid response */
3641         }
3642       else if (dbus_message_is_error (message,
3643                                       DBUS_ERROR_SERVICE_UNKNOWN))
3644         {
3645           _dbus_verbose("could not activate as invalid service file was not added\n");
3646           ; /* good, this is expected as we shouldn't have been added to
3647              * the activation list with a missing Exec key */
3648         }
3649       else if (dbus_message_is_error (message,
3650                                       DBUS_ERROR_SPAWN_FILE_INVALID))
3651         {
3652           _dbus_verbose("got service file invalid\n");
3653           ; /* good, this is allowed, and is the message passed back from the
3654              * launch helper */
3655         }
3656       else
3657         {
3658           warn_unexpected (connection, message, "not this error");
3659
3660           goto out;
3661         }
3662     }
3663   else
3664     {
3665       _dbus_warn ("Did not expect to successfully auto-start missing service\n");
3666       goto out;
3667     }
3668
3669   retval = TRUE;
3670
3671  out:
3672   if (message)
3673     dbus_message_unref (message);
3674
3675   return retval;
3676 }
3677
3678 #define SHELL_FAIL_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceFail"
3679
3680 /* returns TRUE if the correct thing happens,
3681  * but the correct thing may include OOM errors.
3682  */
3683 static dbus_bool_t
3684 check_shell_fail_service_auto_start (BusContext     *context,
3685                                      DBusConnection *connection)
3686 {
3687   DBusMessage *message;
3688   dbus_uint32_t serial;
3689   dbus_bool_t retval;
3690
3691   message = dbus_message_new_method_call (SHELL_FAIL_SERVICE_NAME,
3692                                           "/org/freedesktop/TestSuite",
3693                                           "org.freedesktop.TestSuite",
3694                                           "Echo");
3695
3696   if (message == NULL)
3697     return TRUE;
3698
3699   if (!dbus_connection_send (connection, message, &serial))
3700     {
3701       dbus_message_unref (message);
3702       return TRUE;
3703     }
3704
3705   dbus_message_unref (message);
3706   message = NULL;
3707
3708   bus_test_run_everything (context);
3709   block_connection_until_message_from_bus (context, connection, "reply to shell Echo on service which should fail to auto-start");
3710   bus_test_run_everything (context);
3711
3712   if (!dbus_connection_get_is_connected (connection))
3713     {
3714       _dbus_verbose ("connection was disconnected\n");
3715       return TRUE;
3716     }
3717
3718   retval = FALSE;
3719
3720   message = pop_message_waiting_for_memory (connection);
3721   if (message == NULL)
3722     {
3723       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3724                   "Echo message (auto activation)", serial, connection);
3725       goto out;
3726     }
3727
3728   verbose_message_received (connection, message);
3729
3730   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3731     {
3732       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3733         {
3734           _dbus_warn ("Message has wrong sender %s\n",
3735                       dbus_message_get_sender (message) ?
3736                       dbus_message_get_sender (message) : "(none)");
3737           goto out;
3738         }
3739
3740       if (dbus_message_is_error (message,
3741                                  DBUS_ERROR_NO_MEMORY))
3742         {
3743           ; /* good, this is a valid response */
3744         }
3745       else if (dbus_message_is_error (message,
3746                                       DBUS_ERROR_INVALID_ARGS))
3747         {
3748           _dbus_verbose("got invalid args\n");
3749           ; /* good, this is expected also */
3750         }
3751       else
3752         {
3753           warn_unexpected (connection, message, "not this error");
3754
3755           goto out;
3756         }
3757     }
3758   else
3759     {
3760       _dbus_warn ("Did not expect to successfully auto-start shell fail service\n");
3761       goto out;
3762     }
3763
3764   retval = TRUE;
3765
3766  out:
3767   if (message)
3768     dbus_message_unref (message);
3769
3770   return retval;
3771 }
3772
3773 #define SHELL_SUCCESS_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceSuccess"
3774
3775 /* returns TRUE if the correct thing happens,
3776  * but the correct thing may include OOM errors.
3777  */
3778 static dbus_bool_t
3779 check_shell_service_success_auto_start (BusContext     *context,
3780                                         DBusConnection *connection)
3781 {
3782   DBusMessage *message;
3783   DBusMessage *base_service_message;
3784   dbus_uint32_t serial;
3785   dbus_bool_t retval;
3786   const char *base_service;
3787   const char *argv[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
3788
3789   base_service_message = NULL;
3790
3791   message = dbus_message_new_method_call (SHELL_SUCCESS_SERVICE_NAME,
3792                                           "/org/freedesktop/TestSuite",
3793                                           "org.freedesktop.TestSuite",
3794                                           "Echo");
3795
3796   if (message == NULL)
3797     return TRUE;
3798
3799   if (!dbus_connection_send (connection, message, &serial))
3800     {
3801       dbus_message_unref (message);
3802       return TRUE;
3803     }
3804
3805   dbus_message_unref (message);
3806   message = NULL;
3807
3808   bus_test_run_everything (context);
3809
3810   /* now wait for the message bus to hear back from the activated
3811    * service.
3812    */
3813   block_connection_until_message_from_bus (context, connection, "reply to Echo on shell success service");
3814   bus_test_run_everything (context);
3815
3816   if (!dbus_connection_get_is_connected (connection))
3817     {
3818       _dbus_verbose ("connection was disconnected\n");
3819       return TRUE;
3820     }
3821
3822   retval = FALSE;
3823
3824   message = pop_message_waiting_for_memory (connection);
3825   if (message == NULL)
3826     {
3827       _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
3828                   serial, connection);
3829       goto out;
3830     }
3831
3832   verbose_message_received (connection, message);
3833   _dbus_verbose ("  (after sending %s)\n", "auto start");
3834
3835   /* we should get zero or two ServiceOwnerChanged signals */
3836   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
3837     {
3838       GotServiceInfo message_kind;
3839
3840       if (!check_base_service_activated (context, connection,
3841                                          message, &base_service))
3842         goto out;
3843
3844       base_service_message = message;
3845       message = NULL;
3846
3847       /* We may need to block here for the test service to exit or finish up */
3848       block_connection_until_message_from_bus (context, connection, "service to exit");
3849
3850       /* Should get a service creation notification for the activated
3851        * service name, or a service deletion on the base service name
3852        */
3853       message = dbus_connection_borrow_message (connection);
3854       if (message == NULL)
3855         {
3856           _dbus_warn ("No message after auto activation "
3857                       "(should be a service announcement)\n");
3858           dbus_connection_return_message (connection, message);
3859           message = NULL;
3860           goto out;
3861         }
3862
3863       message_kind = check_got_service_info (message);
3864
3865       dbus_connection_return_message (connection, message);
3866       message = NULL;
3867
3868       switch (message_kind)
3869         {
3870         case GOT_SERVICE_CREATED:
3871           message = pop_message_waiting_for_memory (connection);
3872           if (message == NULL)
3873             {
3874               _dbus_warn ("Failed to pop message we just put back! "
3875                           "should have been a NameOwnerChanged (creation)\n");
3876               goto out;
3877             }
3878
3879           /* Check that ServiceOwnerChanged (creation) was correctly received */
3880           if (!check_service_auto_activated (context, connection, SHELL_SUCCESS_SERVICE_NAME,
3881                                              base_service, message))
3882             goto out;
3883
3884           dbus_message_unref (message);
3885           message = NULL;
3886
3887           break;
3888
3889         case GOT_SERVICE_DELETED:
3890           {
3891             /* The service started up and got a base address, but then
3892              * failed to register under SHELL_SUCCESS_SERVICE_NAME
3893              */
3894             CheckServiceOwnerChangedData socd;
3895
3896             socd.expected_kind = SERVICE_DELETED;
3897             socd.expected_service_name = base_service;
3898             socd.failed = FALSE;
3899             socd.skip_connection = NULL;
3900             bus_test_clients_foreach (check_service_owner_changed_foreach,
3901                                       &socd);
3902
3903             if (socd.failed)
3904               goto out;
3905
3906             break;
3907           }
3908
3909         case GOT_ERROR:
3910         case GOT_SOMETHING_ELSE:
3911           _dbus_warn ("Unexpected message after auto activation\n");
3912           goto out;
3913         }
3914     }
3915
3916   /* OK, now we've dealt with ServiceOwnerChanged signals, now should
3917    * come the method reply (or error) from the initial method call
3918    */
3919
3920   /* Note: if this test is run in OOM mode, it will block when the bus
3921    * doesn't send a reply due to OOM.
3922    */
3923   block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3924
3925   message = pop_message_waiting_for_memory (connection);
3926   if (message == NULL)
3927     {
3928       _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
3929       goto out;
3930     }
3931
3932   if (dbus_message_get_reply_serial (message) != serial)
3933     {
3934       _dbus_warn ("Wrong reply serial\n");
3935       goto out;
3936     }
3937
3938   if (!dbus_message_get_args (message, NULL,
3939                                        DBUS_TYPE_STRING, &argv[0],
3940                                        DBUS_TYPE_STRING, &argv[1],
3941                                        DBUS_TYPE_STRING, &argv[2],
3942                                        DBUS_TYPE_STRING, &argv[3],
3943                                        DBUS_TYPE_STRING, &argv[4],
3944                                        DBUS_TYPE_STRING, &argv[5],
3945                                        DBUS_TYPE_STRING, &argv[6],
3946                                        DBUS_TYPE_INVALID))
3947     {
3948       _dbus_warn ("Error getting arguments from return\n");
3949       goto out;
3950     }
3951
3952    /* don't worry about arg[0] as it may be different
3953       depending on the path to the tests
3954    */
3955   if (strcmp("-test", argv[1]) != 0)
3956     {
3957       _dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n",
3958                   "-test", argv[1]);
3959       goto out;
3960     }
3961
3962   if (strcmp("that", argv[2]) != 0)
3963     {
3964       _dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n",
3965                    "that", argv[2]);
3966       goto out;
3967     }
3968
3969   if (strcmp("we get", argv[3]) != 0)
3970     {
3971       _dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n",
3972                    "we get", argv[3]);
3973       goto out;
3974     }
3975
3976   if (strcmp("back", argv[4]) != 0)
3977     {
3978       _dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n",
3979                    "back", argv[4]);
3980       goto out;
3981     }
3982
3983   if (strcmp("--what", argv[5]) != 0)
3984     {
3985       _dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n",
3986                    "--what", argv[5]);
3987       goto out;
3988     }
3989
3990   if (strcmp("we put in", argv[6]) != 0)
3991     {
3992       _dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n",
3993                    "we put in", argv[6]);
3994       goto out;
3995     }
3996
3997   dbus_message_unref (message);
3998   message = NULL;
3999
4000   if (!check_send_exit_to_service (context, connection,
4001                                    SHELL_SUCCESS_SERVICE_NAME,
4002                                    base_service))
4003     goto out;
4004
4005   retval = TRUE;
4006
4007  out:
4008   if (message)
4009     dbus_message_unref (message);
4010
4011   if (base_service_message)
4012     dbus_message_unref (base_service_message);
4013
4014   return retval;
4015 }
4016
4017 typedef struct
4018 {
4019   Check1Func func;
4020   BusContext *context;
4021 } Check1Data;
4022
4023 static dbus_bool_t
4024 check_oom_check1_func (void *data)
4025 {
4026   Check1Data *d = data;
4027
4028   if (! (* d->func) (d->context))
4029     return FALSE;
4030
4031   if (!check_no_leftovers (d->context))
4032     {
4033       _dbus_warn ("Messages were left over, should be covered by test suite\n");
4034       return FALSE;
4035     }
4036
4037   return TRUE;
4038 }
4039
4040 static void
4041 check1_try_iterations (BusContext *context,
4042                        const char *description,
4043                        Check1Func  func)
4044 {
4045   Check1Data d;
4046
4047   d.func = func;
4048   d.context = context;
4049
4050   if (!_dbus_test_oom_handling (description, check_oom_check1_func,
4051                                 &d))
4052     _dbus_assert_not_reached ("test failed");
4053 }
4054
4055 static dbus_bool_t
4056 check_get_services (BusContext     *context,
4057                     DBusConnection *connection,
4058                     const char     *method,
4059                     char         ***services,
4060                     int            *len)
4061 {
4062   DBusMessage *message;
4063   dbus_uint32_t serial;
4064   dbus_bool_t retval;
4065   DBusError error;
4066   char **srvs;
4067   int l;
4068
4069   retval = FALSE;
4070   dbus_error_init (&error);
4071   message = NULL;
4072
4073   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
4074                                           DBUS_PATH_DBUS,
4075                                           DBUS_INTERFACE_DBUS,
4076                                           method);
4077
4078   if (message == NULL)
4079     return TRUE;
4080
4081   if (!dbus_connection_send (connection, message, &serial))
4082     {
4083       dbus_message_unref (message);
4084       return TRUE;
4085     }
4086
4087   /* send our message */
4088   bus_test_run_clients_loop (SEND_PENDING (connection));
4089
4090   dbus_message_unref (message);
4091   message = NULL;
4092
4093   dbus_connection_ref (connection); /* because we may get disconnected */
4094   block_connection_until_message_from_bus (context, connection, "reply to ListActivatableNames/ListNames");
4095
4096   if (!dbus_connection_get_is_connected (connection))
4097     {
4098       _dbus_verbose ("connection was disconnected\n");
4099
4100       dbus_connection_unref (connection);
4101
4102       return TRUE;
4103     }
4104
4105   dbus_connection_unref (connection);
4106
4107   message = pop_message_waiting_for_memory (connection);
4108   if (message == NULL)
4109     {
4110       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
4111                   method, serial, connection);
4112       goto out;
4113     }
4114
4115   verbose_message_received (connection, message);
4116
4117   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
4118     {
4119       if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
4120         {
4121           ; /* good, this is a valid response */
4122         }
4123       else
4124         {
4125           warn_unexpected (connection, message, "not this error");
4126
4127           goto out;
4128         }
4129     }
4130   else
4131     {
4132       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
4133         {
4134           ; /* good, expected */
4135         }
4136       else
4137         {
4138           warn_unexpected (connection, message,
4139                            "method_return for ListActivatableNames/ListNames");
4140
4141           goto out;
4142         }
4143
4144     retry_get_property:
4145
4146       if (!dbus_message_get_args (message, &error,
4147                                   DBUS_TYPE_ARRAY,
4148                                   DBUS_TYPE_STRING,
4149                                   &srvs, &l,
4150                                   DBUS_TYPE_INVALID))
4151         {
4152           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
4153             {
4154               _dbus_verbose ("no memory to list services by %s\n", method);
4155               dbus_error_free (&error);
4156               _dbus_wait_for_memory ();
4157               goto retry_get_property;
4158             }
4159           else
4160             {
4161               _dbus_assert (dbus_error_is_set (&error));
4162               _dbus_warn ("Did not get the expected DBUS_TYPE_ARRAY from %s\n", method);
4163               goto out;
4164             }
4165         } else {
4166           *services = srvs;
4167           *len = l;
4168         }
4169     }
4170
4171   if (!check_no_leftovers (context))
4172     goto out;
4173
4174   retval = TRUE;
4175
4176  out:
4177   dbus_error_free (&error);
4178
4179   if (message)
4180     dbus_message_unref (message);
4181
4182   return retval;
4183 }
4184
4185 /* returns TRUE if the correct thing happens,
4186  * but the correct thing may include OOM errors.
4187  */
4188 static dbus_bool_t
4189 check_list_services (BusContext     *context,
4190                      DBusConnection *connection)
4191 {
4192   DBusMessage  *message;
4193   DBusMessage  *base_service_message;
4194   const char   *base_service;
4195   dbus_uint32_t serial;
4196   dbus_bool_t   retval;
4197   const char   *existent = EXISTENT_SERVICE_NAME;
4198   dbus_uint32_t flags;
4199   char        **services;
4200   int           len;
4201
4202   _dbus_verbose ("check_list_services for %p\n", connection);
4203
4204   if (!check_get_services (context, connection, "ListActivatableNames", &services, &len))
4205     {
4206       return TRUE;
4207     }
4208
4209   if (!_dbus_string_array_contains ((const char **)services, existent))
4210     {
4211       _dbus_warn ("Did not get the expected %s from ListActivatableNames\n", existent);
4212       dbus_free_string_array (services);
4213       return FALSE;
4214     }
4215
4216   dbus_free_string_array (services);
4217
4218   base_service_message = NULL;
4219
4220   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
4221                                           DBUS_PATH_DBUS,
4222                                           DBUS_INTERFACE_DBUS,
4223                                           "StartServiceByName");
4224
4225   if (message == NULL)
4226     return TRUE;
4227
4228   dbus_message_set_auto_start (message, FALSE);
4229
4230   flags = 0;
4231   if (!dbus_message_append_args (message,
4232                                  DBUS_TYPE_STRING, &existent,
4233                                  DBUS_TYPE_UINT32, &flags,
4234                                  DBUS_TYPE_INVALID))
4235     {
4236       dbus_message_unref (message);
4237       return TRUE;
4238     }
4239
4240   if (!dbus_connection_send (connection, message, &serial))
4241     {
4242       dbus_message_unref (message);
4243       return TRUE;
4244     }
4245
4246   dbus_message_unref (message);
4247   message = NULL;
4248
4249   bus_test_run_everything (context);
4250
4251   /* now wait for the message bus to hear back from the activated
4252    * service.
4253    */
4254   block_connection_until_message_from_bus (context, connection, "activated service to connect");
4255
4256   bus_test_run_everything (context);
4257
4258   if (!dbus_connection_get_is_connected (connection))
4259     {
4260       _dbus_verbose ("connection was disconnected\n");
4261       return TRUE;
4262     }
4263
4264   retval = FALSE;
4265
4266   message = pop_message_waiting_for_memory (connection);
4267   if (message == NULL)
4268     {
4269       _dbus_warn ("Did not receive any messages after %s %d on %p\n",
4270                   "StartServiceByName", serial, connection);
4271       goto out;
4272     }
4273
4274   verbose_message_received (connection, message);
4275   _dbus_verbose ("  (after sending %s)\n", "StartServiceByName");
4276
4277   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
4278     {
4279       if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
4280         {
4281           _dbus_warn ("Message has wrong sender %s\n",
4282                       dbus_message_get_sender (message) ?
4283                       dbus_message_get_sender (message) : "(none)");
4284           goto out;
4285         }
4286
4287       if (dbus_message_is_error (message,
4288                                  DBUS_ERROR_NO_MEMORY))
4289         {
4290           ; /* good, this is a valid response */
4291         }
4292       else if (dbus_message_is_error (message,
4293                                       DBUS_ERROR_SPAWN_CHILD_EXITED) ||
4294                dbus_message_is_error (message,
4295                                       DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
4296                dbus_message_is_error (message,
4297                                       DBUS_ERROR_SPAWN_EXEC_FAILED))
4298         {
4299           ; /* good, this is expected also */
4300         }
4301       else
4302         {
4303           _dbus_warn ("Did not expect error %s\n",
4304                       dbus_message_get_error_name (message));
4305           goto out;
4306         }
4307     }
4308   else
4309     {
4310       GotServiceInfo message_kind;
4311
4312       if (!check_base_service_activated (context, connection,
4313                                          message, &base_service))
4314         goto out;
4315
4316       base_service_message = message;
4317       message = NULL;
4318
4319       /* We may need to block here for the test service to exit or finish up */
4320       block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
4321
4322       message = dbus_connection_borrow_message (connection);
4323       if (message == NULL)
4324         {
4325           _dbus_warn ("Did not receive any messages after base service creation notification\n");
4326           goto out;
4327         }
4328
4329       message_kind = check_got_service_info (message);
4330
4331       dbus_connection_return_message (connection, message);
4332       message = NULL;
4333
4334       switch (message_kind)
4335         {
4336         case GOT_SOMETHING_ELSE:
4337         case GOT_ERROR:
4338         case GOT_SERVICE_DELETED:
4339           _dbus_warn ("Unexpected message after ActivateService "
4340                       "(should be an error or a service announcement)\n");
4341           goto out;
4342
4343         case GOT_SERVICE_CREATED:
4344           message = pop_message_waiting_for_memory (connection);
4345           if (message == NULL)
4346             {
4347               _dbus_warn ("Failed to pop message we just put back! "
4348                           "should have been a NameOwnerChanged (creation)\n");
4349               goto out;
4350             }
4351
4352           if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
4353                                         base_service, message))
4354             goto out;
4355
4356           dbus_message_unref (message);
4357           message = NULL;
4358
4359           if (!check_no_leftovers (context))
4360             {
4361               _dbus_warn ("Messages were left over after successful activation\n");
4362               goto out;
4363             }
4364
4365           break;
4366         }
4367     }
4368
4369   if (!check_get_services (context, connection, "ListNames", &services, &len))
4370     {
4371       return TRUE;
4372     }
4373
4374   if (!_dbus_string_array_contains ((const char **)services, existent))
4375     {
4376       _dbus_warn ("Did not get the expected %s from ListNames\n", existent);
4377       goto out;
4378     }
4379
4380   dbus_free_string_array (services);
4381
4382   if (!check_send_exit_to_service (context, connection,
4383                                    EXISTENT_SERVICE_NAME, base_service))
4384     goto out;
4385
4386   retval = TRUE;
4387
4388  out:
4389   if (message)
4390     dbus_message_unref (message);
4391
4392   if (base_service_message)
4393     dbus_message_unref (base_service_message);
4394
4395   return retval;
4396 }
4397
4398 typedef struct
4399 {
4400   Check2Func func;
4401   BusContext *context;
4402   DBusConnection *connection;
4403 } Check2Data;
4404
4405 static dbus_bool_t
4406 check_oom_check2_func (void *data)
4407 {
4408   Check2Data *d = data;
4409
4410   if (! (* d->func) (d->context, d->connection))
4411     return FALSE;
4412
4413   if (!check_no_leftovers (d->context))
4414     {
4415       _dbus_warn ("Messages were left over, should be covered by test suite\n");
4416       return FALSE;
4417     }
4418
4419   return TRUE;
4420 }
4421
4422 static void
4423 check2_try_iterations (BusContext     *context,
4424                        DBusConnection *connection,
4425                        const char     *description,
4426                        Check2Func      func)
4427 {
4428   Check2Data d;
4429
4430   d.func = func;
4431   d.context = context;
4432   d.connection = connection;
4433
4434   if (!_dbus_test_oom_handling (description, check_oom_check2_func,
4435                                 &d))
4436     {
4437       _dbus_warn ("%s failed during oom\n", description);
4438       _dbus_assert_not_reached ("test failed");
4439     }
4440 }
4441
4442 static dbus_bool_t
4443 setenv_TEST_LAUNCH_HELPER_CONFIG(const DBusString *test_data_dir,
4444                                  const char       *filename)
4445 {
4446   DBusString full;
4447   DBusString file;
4448
4449   if (!_dbus_string_init (&full))
4450     return FALSE;
4451
4452   if (!_dbus_string_copy (test_data_dir, 0, &full, 0))
4453     {
4454       _dbus_string_free (&full);
4455       return FALSE;
4456     }
4457
4458   _dbus_string_init_const (&file, filename);
4459
4460   if (!_dbus_concat_dir_and_file (&full, &file))
4461     {
4462       _dbus_string_free (&full);
4463       return FALSE;
4464     }
4465
4466   _dbus_verbose ("Setting TEST_LAUNCH_HELPER_CONFIG to '%s'\n",
4467                  _dbus_string_get_const_data (&full));
4468
4469   _dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG", _dbus_string_get_const_data (&full));
4470
4471   _dbus_string_free (&full);
4472
4473   return TRUE;
4474 }
4475
4476 static dbus_bool_t
4477 bus_dispatch_test_conf (const DBusString *test_data_dir,
4478                         const char       *filename,
4479                         dbus_bool_t       use_launcher)
4480 {
4481   BusContext *context;
4482   DBusConnection *foo;
4483   DBusConnection *bar;
4484   DBusConnection *baz;
4485   DBusError error;
4486
4487   /* save the config name for the activation helper */
4488   if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
4489     _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
4490
4491   dbus_error_init (&error);
4492
4493   context = bus_context_new_test (test_data_dir, filename);
4494   if (context == NULL)
4495     return FALSE;
4496
4497   foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4498   if (foo == NULL)
4499     _dbus_assert_not_reached ("could not alloc connection");
4500
4501   if (!bus_setup_debug_client (foo))
4502     _dbus_assert_not_reached ("could not set up connection");
4503
4504   spin_connection_until_authenticated (context, foo);
4505
4506   if (!check_hello_message (context, foo))
4507     _dbus_assert_not_reached ("hello message failed");
4508
4509   if (!check_double_hello_message (context, foo))
4510     _dbus_assert_not_reached ("double hello message failed");
4511
4512   if (!check_add_match_all (context, foo))
4513     _dbus_assert_not_reached ("AddMatch message failed");
4514
4515   bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4516   if (bar == NULL)
4517     _dbus_assert_not_reached ("could not alloc connection");
4518
4519   if (!bus_setup_debug_client (bar))
4520     _dbus_assert_not_reached ("could not set up connection");
4521
4522   spin_connection_until_authenticated (context, bar);
4523
4524   if (!check_hello_message (context, bar))
4525     _dbus_assert_not_reached ("hello message failed");
4526
4527   if (!check_add_match_all (context, bar))
4528     _dbus_assert_not_reached ("AddMatch message failed");
4529
4530   baz = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4531   if (baz == NULL)
4532     _dbus_assert_not_reached ("could not alloc connection");
4533
4534   if (!bus_setup_debug_client (baz))
4535     _dbus_assert_not_reached ("could not set up connection");
4536
4537   spin_connection_until_authenticated (context, baz);
4538
4539   if (!check_hello_message (context, baz))
4540     _dbus_assert_not_reached ("hello message failed");
4541
4542   if (!check_add_match_all (context, baz))
4543     _dbus_assert_not_reached ("AddMatch message failed");
4544
4545 #ifdef DBUS_WIN_FIXME
4546   _dbus_warn("TODO: testing of GetConnectionUnixUser message skipped for now\n");
4547   _dbus_warn("TODO: testing of GetConnectionUnixProcessID message skipped for now\n");
4548 #else
4549   if (!check_get_connection_unix_user (context, baz))
4550     _dbus_assert_not_reached ("GetConnectionUnixUser message failed");
4551
4552   if (!check_get_connection_unix_process_id (context, baz))
4553     _dbus_assert_not_reached ("GetConnectionUnixProcessID message failed");
4554 #endif
4555
4556   if (!check_list_services (context, baz))
4557     _dbus_assert_not_reached ("ListActivatableNames message failed");
4558
4559   if (!check_no_leftovers (context))
4560     {
4561       _dbus_warn ("Messages were left over after setting up initial connections\n");
4562       _dbus_assert_not_reached ("initial connection setup failed");
4563     }
4564
4565   check1_try_iterations (context, "create_and_hello",
4566                          check_hello_connection);
4567
4568   check2_try_iterations (context, foo, "nonexistent_service_no_auto_start",
4569                          check_nonexistent_service_no_auto_start);
4570
4571 #ifdef DBUS_WIN_FIXME
4572   _dbus_warn("TODO: dispatch.c segfault_service_no_auto_start test\n");
4573 #else
4574   check2_try_iterations (context, foo, "segfault_service_no_auto_start",
4575                          check_segfault_service_no_auto_start);
4576 #endif
4577
4578   check2_try_iterations (context, foo, "existent_service_no_auto_start",
4579                          check_existent_service_no_auto_start);
4580
4581   check2_try_iterations (context, foo, "nonexistent_service_auto_start",
4582                          check_nonexistent_service_auto_start);
4583
4584
4585 #ifdef DBUS_WIN_FIXME
4586   _dbus_warn("TODO: dispatch.c segfault_service_auto_start test\n");
4587 #else
4588   /* only do the segfault test if we are not using the launcher */
4589   check2_try_iterations (context, foo, "segfault_service_auto_start",
4590                          check_segfault_service_auto_start);
4591 #endif
4592
4593   /* only do the shell fail test if we are not using the launcher */
4594   check2_try_iterations (context, foo, "shell_fail_service_auto_start",
4595                          check_shell_fail_service_auto_start);
4596
4597   /* specific to launcher */
4598   if (use_launcher)
4599     if (!check_launch_service_file_missing (context, foo))
4600       _dbus_assert_not_reached ("did not get service file not found error");
4601
4602 #if 0
4603   /* Note: need to resolve some issues with the testing code in order to run
4604    * this in oom (handle that we sometimes don't get replies back from the bus
4605    * when oom happens, without blocking the test).
4606    */
4607   check2_try_iterations (context, foo, "existent_service_auto_auto_start",
4608                          check_existent_service_auto_start);
4609 #endif
4610
4611   if (!check_existent_service_auto_start (context, foo))
4612     _dbus_assert_not_reached ("existent service auto start failed");
4613
4614   if (!check_shell_service_success_auto_start (context, foo))
4615     _dbus_assert_not_reached ("shell success service auto start failed");
4616
4617   _dbus_verbose ("Disconnecting foo, bar, and baz\n");
4618
4619   kill_client_connection_unchecked (foo);
4620   kill_client_connection_unchecked (bar);
4621   kill_client_connection_unchecked (baz);
4622
4623   bus_context_unref (context);
4624
4625   return TRUE;
4626 }
4627
4628 static dbus_bool_t
4629 bus_dispatch_test_conf_fail (const DBusString *test_data_dir,
4630                              const char       *filename)
4631 {
4632   BusContext *context;
4633   DBusConnection *foo;
4634   DBusError error;
4635
4636   /* save the config name for the activation helper */
4637   if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
4638     _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
4639
4640   dbus_error_init (&error);
4641
4642   context = bus_context_new_test (test_data_dir, filename);
4643   if (context == NULL)
4644     return FALSE;
4645
4646   foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4647   if (foo == NULL)
4648     _dbus_assert_not_reached ("could not alloc connection");
4649
4650   if (!bus_setup_debug_client (foo))
4651     _dbus_assert_not_reached ("could not set up connection");
4652
4653   spin_connection_until_authenticated (context, foo);
4654
4655   if (!check_hello_message (context, foo))
4656     _dbus_assert_not_reached ("hello message failed");
4657
4658   if (!check_double_hello_message (context, foo))
4659     _dbus_assert_not_reached ("double hello message failed");
4660
4661   if (!check_add_match_all (context, foo))
4662     _dbus_assert_not_reached ("AddMatch message failed");
4663
4664   /* this only tests the activation.c user check */
4665   if (!check_launch_service_user_missing (context, foo))
4666     _dbus_assert_not_reached ("user missing did not trigger error");
4667
4668   /* this only tests the desktop.c exec check */
4669   if (!check_launch_service_exec_missing (context, foo))
4670     _dbus_assert_not_reached ("exec missing did not trigger error");
4671
4672   /* this only tests the desktop.c service check */
4673   if (!check_launch_service_service_missing (context, foo))
4674     _dbus_assert_not_reached ("service missing did not trigger error");
4675
4676   _dbus_verbose ("Disconnecting foo\n");
4677
4678   kill_client_connection_unchecked (foo);
4679
4680   bus_context_unref (context);
4681
4682   return TRUE;
4683 }
4684
4685 dbus_bool_t
4686 bus_dispatch_test (const DBusString *test_data_dir)
4687 {
4688   /* run normal activation tests */
4689   _dbus_verbose ("Normal activation tests\n");
4690   if (!bus_dispatch_test_conf (test_data_dir,
4691                                "valid-config-files/debug-allow-all.conf", FALSE))
4692     return FALSE;
4693
4694 #ifdef DBUS_WIN
4695   _dbus_warn("Info: Launch helper activation tests skipped because launch-helper is not supported yet\n");
4696 #else
4697   /* run launch-helper activation tests */
4698   _dbus_verbose ("Launch helper activation tests\n");
4699   if (!bus_dispatch_test_conf (test_data_dir,
4700                                "valid-config-files-system/debug-allow-all-pass.conf", TRUE))
4701     return FALSE;
4702
4703   /* run select launch-helper activation tests on broken service files */
4704   if (!bus_dispatch_test_conf_fail (test_data_dir,
4705                                     "valid-config-files-system/debug-allow-all-fail.conf"))
4706     return FALSE;
4707 #endif
4708
4709   return TRUE;
4710 }
4711
4712 dbus_bool_t
4713 bus_dispatch_sha1_test (const DBusString *test_data_dir)
4714 {
4715   BusContext *context;
4716   DBusConnection *foo;
4717   DBusError error;
4718
4719   dbus_error_init (&error);
4720
4721   /* Test SHA1 authentication */
4722   _dbus_verbose ("Testing SHA1 context\n");
4723
4724   context = bus_context_new_test (test_data_dir,
4725                                   "valid-config-files/debug-allow-all-sha1.conf");
4726   if (context == NULL)
4727     return FALSE;
4728
4729   foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4730   if (foo == NULL)
4731     _dbus_assert_not_reached ("could not alloc connection");
4732
4733   if (!bus_setup_debug_client (foo))
4734     _dbus_assert_not_reached ("could not set up connection");
4735
4736   spin_connection_until_authenticated (context, foo);
4737
4738   if (!check_hello_message (context, foo))
4739     _dbus_assert_not_reached ("hello message failed");
4740
4741   if (!check_add_match_all (context, foo))
4742     _dbus_assert_not_reached ("addmatch message failed");
4743
4744   if (!check_no_leftovers (context))
4745     {
4746       _dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
4747       _dbus_assert_not_reached ("initial connection setup failed");
4748     }
4749
4750   check1_try_iterations (context, "create_and_hello_sha1",
4751                          check_hello_connection);
4752
4753   kill_client_connection_unchecked (foo);
4754
4755   bus_context_unref (context);
4756
4757   return TRUE;
4758 }
4759
4760 #ifdef HAVE_UNIX_FD_PASSING
4761
4762 dbus_bool_t
4763 bus_unix_fds_passing_test(const DBusString *test_data_dir)
4764 {
4765   BusContext *context;
4766   DBusConnection *foo, *bar;
4767   DBusError error;
4768   DBusMessage *m;
4769   int one[2], two[2], x, y, z;
4770   char r;
4771
4772   dbus_error_init (&error);
4773
4774   context = bus_context_new_test (test_data_dir, "valid-config-files/debug-allow-all.conf");
4775   if (context == NULL)
4776     _dbus_assert_not_reached ("could not alloc context");
4777
4778   foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4779   if (foo == NULL)
4780     _dbus_assert_not_reached ("could not alloc connection");
4781
4782   if (!bus_setup_debug_client (foo))
4783     _dbus_assert_not_reached ("could not set up connection");
4784
4785   spin_connection_until_authenticated (context, foo);
4786
4787   if (!check_hello_message (context, foo))
4788     _dbus_assert_not_reached ("hello message failed");
4789
4790   if (!check_add_match_all (context, foo))
4791     _dbus_assert_not_reached ("AddMatch message failed");
4792
4793   bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
4794   if (bar == NULL)
4795     _dbus_assert_not_reached ("could not alloc connection");
4796
4797   if (!bus_setup_debug_client (bar))
4798     _dbus_assert_not_reached ("could not set up connection");
4799
4800   spin_connection_until_authenticated (context, bar);
4801
4802   if (!check_hello_message (context, bar))
4803     _dbus_assert_not_reached ("hello message failed");
4804
4805   if (!check_add_match_all (context, bar))
4806     _dbus_assert_not_reached ("AddMatch message failed");
4807
4808   if (!(m = dbus_message_new_signal("/", "a.b.c", "d")))
4809     _dbus_assert_not_reached ("could not alloc message");
4810
4811   if (!(_dbus_full_duplex_pipe(one, one+1, TRUE, &error)))
4812     _dbus_assert_not_reached("Failed to allocate pipe #1");
4813
4814   if (!(_dbus_full_duplex_pipe(two, two+1, TRUE, &error)))
4815     _dbus_assert_not_reached("Failed to allocate pipe #2");
4816
4817   if (!dbus_message_append_args(m,
4818                                 DBUS_TYPE_UNIX_FD, one,
4819                                 DBUS_TYPE_UNIX_FD, two,
4820                                 DBUS_TYPE_UNIX_FD, two,
4821                                 DBUS_TYPE_INVALID))
4822     _dbus_assert_not_reached("Failed to attach fds.");
4823
4824   if (!_dbus_close(one[0], &error))
4825     _dbus_assert_not_reached("Failed to close pipe #1 ");
4826   if (!_dbus_close(two[0], &error))
4827     _dbus_assert_not_reached("Failed to close pipe #2 ");
4828
4829   if (!(dbus_connection_can_send_type(foo, DBUS_TYPE_UNIX_FD)))
4830     _dbus_assert_not_reached("Connection cannot do fd passing");
4831
4832   if (!(dbus_connection_can_send_type(bar, DBUS_TYPE_UNIX_FD)))
4833     _dbus_assert_not_reached("Connection cannot do fd passing");
4834
4835   if (!dbus_connection_send (foo, m, NULL))
4836     _dbus_assert_not_reached("Failed to send fds");
4837
4838   dbus_message_unref(m);
4839
4840   bus_test_run_clients_loop (SEND_PENDING (foo));
4841
4842   bus_test_run_everything (context);
4843
4844   block_connection_until_message_from_bus (context, foo, "unix fd reception on foo");
4845
4846   if (!(m = pop_message_waiting_for_memory (foo)))
4847     _dbus_assert_not_reached("Failed to receive msg");
4848
4849   if (!dbus_message_is_signal(m, "a.b.c", "d"))
4850     _dbus_assert_not_reached("bogus message received");
4851
4852   dbus_message_unref(m);
4853
4854   block_connection_until_message_from_bus (context, bar, "unix fd reception on bar");
4855
4856   if (!(m = pop_message_waiting_for_memory (bar)))
4857     _dbus_assert_not_reached("Failed to receive msg");
4858
4859   if (!dbus_message_is_signal(m, "a.b.c", "d"))
4860     _dbus_assert_not_reached("bogus message received");
4861
4862   if (!dbus_message_get_args(m,
4863                              &error,
4864                              DBUS_TYPE_UNIX_FD, &x,
4865                              DBUS_TYPE_UNIX_FD, &y,
4866                              DBUS_TYPE_UNIX_FD, &z,
4867                              DBUS_TYPE_INVALID))
4868     _dbus_assert_not_reached("Failed to parse fds.");
4869
4870   dbus_message_unref(m);
4871
4872   if (write(x, "X", 1) != 1)
4873     _dbus_assert_not_reached("Failed to write to pipe #1");
4874   if (write(y, "Y", 1) != 1)
4875     _dbus_assert_not_reached("Failed to write to pipe #2");
4876   if (write(z, "Z", 1) != 1)
4877     _dbus_assert_not_reached("Failed to write to pipe #2/2nd fd");
4878
4879   if (!_dbus_close(x, &error))
4880     _dbus_assert_not_reached("Failed to close pipe #1/other side ");
4881   if (!_dbus_close(y, &error))
4882     _dbus_assert_not_reached("Failed to close pipe #2/other side ");
4883   if (!_dbus_close(z, &error))
4884     _dbus_assert_not_reached("Failed to close pipe #2/other size 2nd fd ");
4885
4886   if (read(one[1], &r, 1) != 1 || r != 'X')
4887     _dbus_assert_not_reached("Failed to read value from pipe.");
4888   if (read(two[1], &r, 1) != 1 || r != 'Y')
4889     _dbus_assert_not_reached("Failed to read value from pipe.");
4890   if (read(two[1], &r, 1) != 1 || r != 'Z')
4891     _dbus_assert_not_reached("Failed to read value from pipe.");
4892
4893   if (!_dbus_close(one[1], &error))
4894     _dbus_assert_not_reached("Failed to close pipe #1 ");
4895   if (!_dbus_close(two[1], &error))
4896     _dbus_assert_not_reached("Failed to close pipe #2 ");
4897
4898   _dbus_verbose ("Disconnecting foo\n");
4899   kill_client_connection_unchecked (foo);
4900
4901   _dbus_verbose ("Disconnecting bar\n");
4902   kill_client_connection_unchecked (bar);
4903
4904   bus_context_unref (context);
4905
4906   return TRUE;
4907 }
4908 #endif
4909
4910 #endif /* DBUS_BUILD_TESTS */