1 /* -*- mode: C; c-file-style: "gnu" -*- */

     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  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23  *

    24  */

    25 

    26 #include "dispatch.h"

    27 #include "connection.h"

    28 #include "driver.h"

    29 #include "services.h"

    30 #include "activation.h"

    31 #include "utils.h"

    32 #include "bus.h"

    33 #include "signals.h"

    34 #include "test.h"

    35 #ifndef __SYMBIAN32__

    36 #include <dbus/dbus-internals.h>

    37 #else

    38 #include "dbus-internals.h"

    39 #endif //__SYMBIAN32__

    40 #include <string.h>

    41 

    42 #ifdef __SYMBIAN32__

    43 #include "config.h"

    44 #endif //__SYMBIAN32__

    45 

    46 static dbus_bool_t

    47 send_one_message (DBusConnection *connection,

    48                   BusContext     *context,

    49                   DBusConnection *sender,

    50                   DBusConnection *addressed_recipient,

    51                   DBusMessage    *message,

    52                   BusTransaction *transaction,

    53                   DBusError      *error)

    54 {

    55   if (!bus_context_check_security_policy (context, transaction,

    56                                           sender,

    57                                           addressed_recipient,

    58                                           connection,

    59                                           message,

    60                                           NULL))

    61     return TRUE; /* silently don't send it */

    62   

    63   if (!bus_transaction_send (transaction,

    64                              connection,

    65                              message))

    66     {

    67       BUS_SET_OOM (error);

    68       return FALSE;

    69     }

    70 

    71   return TRUE;

    72 }

    73 

    74 dbus_bool_t

    75 bus_dispatch_matches (BusTransaction *transaction,

    76                       DBusConnection *sender,

    77                       DBusConnection *addressed_recipient,

    78                       DBusMessage    *message,

    79                       DBusError      *error)

    80 {

    81   DBusError tmp_error;

    82   BusConnections *connections;

    83   DBusList *recipients;

    84   BusMatchmaker *matchmaker;

    85   DBusList *link;

    86   BusContext *context;

    87 

    88   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

    89 

    90   /* sender and recipient can both be NULL for the bus driver,

    91    * or for signals with no particular recipient

    92    */

    93 

    94   _dbus_assert (sender == NULL || bus_connection_is_active (sender));

    95   _dbus_assert (dbus_message_get_sender (message) != NULL);

    96 

    97   connections = bus_transaction_get_connections (transaction);

    98   

    99   dbus_error_init (&tmp_error);

   100   context = bus_transaction_get_context (transaction);

   101   matchmaker = bus_context_get_matchmaker (context);

   102 

   103   recipients = NULL;

   104   if (!bus_matchmaker_get_recipients (matchmaker, connections,

   105                                       sender, addressed_recipient, message,

   106                                       &recipients))

   107     {

   108       BUS_SET_OOM (error);

   109       return FALSE;

   110     }

   111 

   112   link = _dbus_list_get_first_link (&recipients);

   113   while (link != NULL)

   114     {

   115       DBusConnection *dest;

   116 

   117       dest = link->data;

   118 

   119       if (!send_one_message (dest, context, sender, addressed_recipient,

   120                              message, transaction, &tmp_error))

   121         break;

   122 

   123       link = _dbus_list_get_next_link (&recipients, link);

   124     }

   125 

   126   _dbus_list_clear (&recipients);

   127   

   128   if (dbus_error_is_set (&tmp_error))

   129     {

   130       dbus_move_error (&tmp_error, error);

   131       return FALSE;

   132     }

   133   else

   134     return TRUE;

   135 }

   136 

   137 static DBusHandlerResult

   138 bus_dispatch (DBusConnection *connection,

   139               DBusMessage    *message)

   140 {

   141   const char *sender, *service_name;

   142   DBusError error;

   143   BusTransaction *transaction;

   144   BusContext *context;

   145   DBusHandlerResult result;

   146   DBusConnection *addressed_recipient;

   147   

   148   result = DBUS_HANDLER_RESULT_HANDLED;

   149   

   150   transaction = NULL;

   151   addressed_recipient = NULL;

   152   dbus_error_init (&error);

   153   

   154   context = bus_connection_get_context (connection);

   155   _dbus_assert (context != NULL);

   156   

   157   /* If we can't even allocate an OOM error, we just go to sleep

   158    * until we can.

   159    */

   160   while (!bus_connection_preallocate_oom_error (connection))

   161     _dbus_wait_for_memory ();

   162   

   163   /* Ref connection in case we disconnect it at some point in here */

   164   dbus_connection_ref (connection);

   165   

   166   service_name = dbus_message_get_destination (message);

   167 

   168 #ifdef DBUS_ENABLE_VERBOSE_MODE

   169   {

   170     const char *interface_name, *member_name, *error_name;

   171 

   172     interface_name = dbus_message_get_interface (message);

   173     member_name = dbus_message_get_member (message);

   174     error_name = dbus_message_get_error_name (message);

   175     

   176     _dbus_verbose ("DISPATCH: %s %s %s to %s\n",

   177                    interface_name ? interface_name : "(no interface)",

   178                    member_name ? member_name : "(no member)",

   179                    error_name ? error_name : "(no error name)",

   180                    service_name ? service_name : "peer");

   181   }

   182 #endif /* DBUS_ENABLE_VERBOSE_MODE */

   183   

   184   /* If service_name is NULL, if it's a signal we send it to all

   185    * connections with a match rule. If it's not a signal, there

   186    * are some special cases here but mostly we just bail out.

   187    */

   188   if (service_name == NULL)

   189     {

   190       if (dbus_message_is_signal (message,

   191                                   DBUS_INTERFACE_LOCAL,

   192                                   "Disconnected"))

   193         {

   194           bus_connection_disconnected (connection);

   195           goto out;

   196         }

   197 

   198       if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)

   199         {

   200           /* DBusConnection also handles some of these automatically, we leave

   201            * it to do so.

   202            */

   203           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

   204           goto out;

   205         }

   206     }

   207   

   208   /* Create our transaction */

   209   transaction = bus_transaction_new (context);

   210   if (transaction == NULL)

   211     {

   212       BUS_SET_OOM (&error);

   213       goto out;

   214     }

   215   

   216   /* Assign a sender to the message */

   217   if (bus_connection_is_active (connection))

   218     {

   219       sender = bus_connection_get_name (connection);

   220       _dbus_assert (sender != NULL);

   221 

   222       if (!dbus_message_set_sender (message, sender))

   223         {

   224           BUS_SET_OOM (&error);

   225           goto out;

   226         }

   227 

   228       /* We need to refetch the service name here, because

   229        * dbus_message_set_sender can cause the header to be

   230        * reallocated, and thus the service_name pointer will become

   231        * invalid.

   232        */

   233       service_name = dbus_message_get_destination (message);

   234     }

   235   

   236   if (service_name &&

   237       strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */

   238     {

   239       if (!bus_context_check_security_policy (context, transaction,

   240                                               connection, NULL, NULL, message, &error))

   241         {

   242           _dbus_verbose ("Security policy rejected message\n");

   243           goto out;

   244         }

   245 

   246       _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_DBUS);

   247       if (!bus_driver_handle_message (connection, transaction, message, &error))

   248         goto out;

   249     }

   250   else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */

   251     {

   252       _dbus_verbose ("Received message from non-registered client. Disconnecting.\n");

   253       dbus_connection_close (connection);

   254       goto out;

   255     }

   256   else if (service_name != NULL) /* route to named service */

   257     {

   258       DBusString service_string;

   259       BusService *service;

   260       BusRegistry *registry;

   261 

   262       _dbus_assert (service_name != NULL);

   263       

   264       registry = bus_connection_get_registry (connection);

   265       

   266       _dbus_string_init_const (&service_string, service_name);

   267       service = bus_registry_lookup (registry, &service_string);

   268 

   269       if (service == NULL && dbus_message_get_auto_start (message))

   270         {

   271           BusActivation *activation;

   272           /* We can't do the security policy check here, since the addressed

   273            * recipient service doesn't exist yet. We do it before sending the

   274            * message after the service has been created.

   275            */

   276           activation = bus_connection_get_activation (connection);

   277 

   278           if (!bus_activation_activate_service (activation, connection, transaction, TRUE,

   279                                                 message, service_name, &error))

   280             {

   281               _DBUS_ASSERT_ERROR_IS_SET (&error);

   282               _dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name);

   283               goto out;

   284             }

   285           

   286           goto out;

   287         }

   288       else if (service == NULL)

   289         {

   290           dbus_set_error (&error,

   291                           DBUS_ERROR_NAME_HAS_NO_OWNER,

   292                           "Name \"%s\" does not exist",

   293                           service_name);

   294           goto out;

   295         }

   296       else

   297         {

   298           addressed_recipient = bus_service_get_primary_owners_connection (service);

   299           _dbus_assert (addressed_recipient != NULL);

   300           

   301           if (!bus_context_check_security_policy (context, transaction,

   302                                                   connection, addressed_recipient,

   303                                                   addressed_recipient,

   304                                                   message, &error))

   305             goto out;

   306           

   307           /* Dispatch the message */

   308           if (!bus_transaction_send (transaction, addressed_recipient, message))

   309             {

   310               BUS_SET_OOM (&error);

   311               goto out;

   312             }

   313         }

   314     }

   315 

   316   /* Now match the messages against any match rules, which will send

   317    * out signals and such. addressed_recipient may == NULL.

   318    */

   319   if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))

   320     goto out;

   321   

   322  out:

   323   if (dbus_error_is_set (&error))

   324     {

   325       if (!dbus_connection_get_is_connected (connection))

   326         {

   327           /* If we disconnected it, we won't bother to send it any error

   328            * messages.

   329            */

   330           _dbus_verbose ("Not sending error to connection we disconnected\n");

   331         }

   332       else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

   333         {

   334           bus_connection_send_oom_error (connection, message);

   335 

   336           /* cancel transaction due to OOM */

   337           if (transaction != NULL)

   338             {

   339               bus_transaction_cancel_and_free (transaction);

   340               transaction = NULL;

   341             }

   342         }

   343       else

   344         {

   345           /* Try to send the real error, if no mem to do that, send

   346            * the OOM error

   347            */

   348           _dbus_assert (transaction != NULL);

   349           if (!bus_transaction_send_error_reply (transaction, connection,

   350                                                  &error, message))

   351             {

   352               bus_connection_send_oom_error (connection, message);

   353               

   354               /* cancel transaction due to OOM */

   355               if (transaction != NULL)

   356                 {

   357                   bus_transaction_cancel_and_free (transaction);

   358                   transaction = NULL;

   359                 }

   360             }

   361         }

   362      

   363       

   364       dbus_error_free (&error);

   365     }

   366 

   367   if (transaction != NULL)

   368     {

   369       bus_transaction_execute_and_free (transaction);

   370     }

   371 

   372   dbus_connection_unref (connection);

   373 

   374   return result;

   375 }

   376 

   377 static DBusHandlerResult

   378 bus_dispatch_message_filter (DBusConnection     *connection,

   379                              DBusMessage        *message,

   380                              void               *user_data)

   381 {

   382   return bus_dispatch (connection, message);

   383 }

   384 

   385 dbus_bool_t

   386 bus_dispatch_add_connection (DBusConnection *connection)

   387 {  

   388   if (!dbus_connection_add_filter (connection,

   389                                    bus_dispatch_message_filter,

   390                                    NULL, NULL))

   391     return FALSE;

   392   

   393   return TRUE;

   394 }

   395 

   396 void

   397 bus_dispatch_remove_connection (DBusConnection *connection)

   398 {

   399   /* Here we tell the bus driver that we want to get off. */

   400   bus_driver_remove_connection (connection);

   401 

   402   dbus_connection_remove_filter (connection,

   403                                  bus_dispatch_message_filter,

   404                                  NULL);

   405 }

   406 

   407 #ifdef DBUS_BUILD_TESTS

   408 

   409 #include <stdio.h>

   410 

   411 /* This is used to know whether we need to block in order to finish

   412  * sending a message, or whether the initial dbus_connection_send()

   413  * already flushed the queue.

   414  */

   415 #define SEND_PENDING(connection) (dbus_connection_has_messages_to_send (connection))

   416 

   417 typedef dbus_bool_t (* Check1Func) (BusContext     *context);

   418 typedef dbus_bool_t (* Check2Func) (BusContext     *context,

   419                                     DBusConnection *connection);

   420 

   421 static dbus_bool_t check_no_leftovers (BusContext *context);

   422 

   423 static void

   424 block_connection_until_message_from_bus (BusContext     *context,

   425                                          DBusConnection *connection,

   426                                          const char     *what_is_expected)

   427 {

   428   _dbus_verbose ("expecting: %s\n", what_is_expected);

   429   

   430   while (dbus_connection_get_dispatch_status (connection) ==

   431          DBUS_DISPATCH_COMPLETE &&

   432          dbus_connection_get_is_connected (connection))

   433     {

   434       #ifndef __SYMBIAN32__

   435       bus_test_run_bus_loop (context, TRUE);

   436       #else										//_dbus_loop_iterate() blocks indefinitly on setting argument to TRUE on Symbian,it must be investigated 

   437       	bus_test_run_bus_loop (context, FALSE);

   438       #endif

   439       bus_test_run_clients_loop (FALSE);

   440     }

   441 }

   442 

   443 static void

   444 spin_connection_until_authenticated (BusContext     *context,

   445                                      DBusConnection *connection)

   446 {

   447   _dbus_verbose ("Spinning to auth connection %p\n", connection);

   448   while (!dbus_connection_get_is_authenticated (connection) &&

   449          dbus_connection_get_is_connected (connection))

   450     {

   451       bus_test_run_bus_loop (context, FALSE);

   452       bus_test_run_clients_loop (FALSE);

   453     }

   454   _dbus_verbose (" ... done spinning to auth connection %p\n", connection);

   455 }

   456 

   457 /* compensate for fact that pop_message() can return #NULL due to OOM */

   458 static DBusMessage*

   459 pop_message_waiting_for_memory (DBusConnection *connection)

   460 {

   461   while (dbus_connection_get_dispatch_status (connection) ==

   462          DBUS_DISPATCH_NEED_MEMORY)

   463     _dbus_wait_for_memory ();

   464 

   465   return dbus_connection_pop_message (connection);

   466 }

   467 

   468 static DBusMessage*

   469 borrow_message_waiting_for_memory (DBusConnection *connection)

   470 {

   471   while (dbus_connection_get_dispatch_status (connection) ==

   472          DBUS_DISPATCH_NEED_MEMORY)

   473     _dbus_wait_for_memory ();

   474 

   475   return dbus_connection_borrow_message (connection);

   476 }

   477 

   478 static void

   479 warn_unexpected_real (DBusConnection *connection,

   480                       DBusMessage    *message,

   481                       const char     *expected,

   482                       const char     *function,

   483                       int             line)

   484 {

   485   if (message)

   486     _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n",

   487                 function, line,

   488                 dbus_message_get_interface (message) ?

   489                 dbus_message_get_interface (message) : "(unset)",

   490                 dbus_message_get_member (message) ?

   491                 dbus_message_get_member (message) : "(unset)",

   492                 dbus_message_get_error_name (message) ?

   493                 dbus_message_get_error_name (message) : "(unset)",

   494                 connection,

   495                 expected);

   496   else

   497     _dbus_warn ("%s:%d received no message on %p, expecting %s\n",

   498                 function, line, connection, expected);

   499 }

   500 

   501 #define warn_unexpected(connection, message, expected) \

   502   warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__)

   503 

   504 static void

   505 verbose_message_received (DBusConnection *connection,

   506                           DBusMessage    *message)

   507 {

   508   _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n",

   509                  dbus_message_get_interface (message) ?

   510                  dbus_message_get_interface (message) : "(unset)",

   511                  dbus_message_get_member (message) ?

   512                  dbus_message_get_member (message) : "(unset)",

   513                  dbus_message_get_error_name (message) ?

   514                  dbus_message_get_error_name (message) : "(unset)",

   515                  connection);

   516 }

   517 

   518 typedef enum

   519 {

   520   SERVICE_CREATED,

   521   OWNER_CHANGED,

   522   SERVICE_DELETED

   523 } ServiceInfoKind;

   524 

   525 typedef struct

   526 {

   527   ServiceInfoKind expected_kind;

   528   const char *expected_service_name;

   529   dbus_bool_t failed;

   530   DBusConnection *skip_connection;

   531 } CheckServiceOwnerChangedData;

   532 

   533 static dbus_bool_t

   534 check_service_owner_changed_foreach (DBusConnection *connection,

   535                                      void           *data)

   536 {

   537   CheckServiceOwnerChangedData *d = data;

   538   DBusMessage *message;

   539   DBusError error;

   540   const char *service_name, *old_owner, *new_owner;

   541 

   542   if (d->expected_kind == SERVICE_CREATED 

   543       && connection == d->skip_connection)

   544     return TRUE;

   545 

   546   dbus_error_init (&error);

   547   d->failed = TRUE;

   548   

   549   message = pop_message_waiting_for_memory (connection);

   550   if (message == NULL)

   551     {

   552       _dbus_warn ("Did not receive a message on %p, expecting %s\n",

   553                   connection, "NameOwnerChanged");

   554       goto out;

   555     }

   556   else if (!dbus_message_is_signal (message,

   557                                     DBUS_INTERFACE_DBUS,

   558                                     "NameOwnerChanged"))

   559     {

   560       warn_unexpected (connection, message, "NameOwnerChanged");

   561 

   562       goto out;

   563     }

   564   else

   565     {

   566     reget_service_info_data:

   567       service_name = NULL;

   568       old_owner = NULL;

   569       new_owner = NULL;

   570 

   571       dbus_message_get_args (message, &error,

   572                              DBUS_TYPE_STRING, &service_name,

   573                              DBUS_TYPE_STRING, &old_owner,

   574                              DBUS_TYPE_STRING, &new_owner,

   575                              DBUS_TYPE_INVALID);

   576 

   577       if (dbus_error_is_set (&error))

   578         {

   579           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

   580             {

   581               dbus_error_free (&error);

   582               _dbus_wait_for_memory ();              

   583               goto reget_service_info_data;

   584             }

   585           else

   586             {

   587               _dbus_warn ("Did not get the expected arguments\n");

   588               goto out;

   589             }

   590         }

   591 

   592       if ((d->expected_kind == SERVICE_CREATED    && ( old_owner[0] || !new_owner[0]))

   593           || (d->expected_kind == OWNER_CHANGED   && (!old_owner[0] || !new_owner[0]))

   594           || (d->expected_kind == SERVICE_DELETED && (!old_owner[0] ||  new_owner[0])))

   595         {

   596           _dbus_warn ("inconsistent NameOwnerChanged arguments\n");

   597           goto out;

   598         }

   599 

   600       if (strcmp (service_name, d->expected_service_name) != 0)

   601         {

   602           _dbus_warn ("expected info on service %s, got info on %s\n",

   603                       d->expected_service_name,

   604                       service_name);

   605           goto out;

   606         }

   607 

   608       if (*service_name == ':' && new_owner[0] 

   609           && strcmp (service_name, new_owner) != 0)

   610         {

   611           _dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",

   612                       service_name, old_owner, new_owner);

   613           goto out;

   614         }

   615     }

   616 

   617   d->failed = FALSE;

   618   

   619  out:

   620   dbus_error_free (&error);

   621   

   622   if (message)

   623     dbus_message_unref (message);

   624 

   625   return !d->failed;

   626 }

   627 

   628 

   629 static void

   630 kill_client_connection (BusContext     *context,

   631                         DBusConnection *connection)

   632 {

   633   char *base_service;

   634   const char *s;

   635   CheckServiceOwnerChangedData socd;

   636 

   637   _dbus_verbose ("killing connection %p\n", connection);

   638   

   639   s = dbus_bus_get_unique_name (connection);

   640   _dbus_assert (s != NULL);

   641 

   642   while ((base_service = _dbus_strdup (s)) == NULL)

   643     _dbus_wait_for_memory ();

   644 

   645   dbus_connection_ref (connection);

   646   

   647   /* kick in the disconnect handler that unrefs the connection */

   648   dbus_connection_close (connection);

   649 

   650   bus_test_run_everything (context);

   651   

   652   _dbus_assert (bus_test_client_listed (connection));

   653   

   654   /* Run disconnect handler in test.c */

   655   if (bus_connection_dispatch_one_message (connection))

   656     _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");

   657   

   658   _dbus_assert (!dbus_connection_get_is_connected (connection));

   659   dbus_connection_unref (connection);

   660   connection = NULL;

   661   _dbus_assert (!bus_test_client_listed (connection));

   662   

   663   socd.expected_kind = SERVICE_DELETED;

   664   socd.expected_service_name = base_service;

   665   socd.failed = FALSE;

   666   socd.skip_connection = NULL;

   667   

   668   bus_test_clients_foreach (check_service_owner_changed_foreach,

   669                             &socd);

   670 

   671   dbus_free (base_service);

   672   

   673   if (socd.failed)

   674     _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");

   675   

   676   if (!check_no_leftovers (context))

   677     _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");

   678 }

   679 

   680 static void

   681 kill_client_connection_unchecked (DBusConnection *connection)

   682 {

   683   /* This kills the connection without expecting it to affect

   684    * the rest of the bus.

   685    */  

   686   _dbus_verbose ("Unchecked kill of connection %p\n", connection);

   687 

   688   dbus_connection_ref (connection);

   689   dbus_connection_close (connection);

   690   /* dispatching disconnect handler will unref once */

   691   if (bus_connection_dispatch_one_message (connection))

   692     _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");

   693 

   694   _dbus_assert (!bus_test_client_listed (connection));

   695   dbus_connection_unref (connection);

   696 }

   697 

   698 typedef struct

   699 {

   700   dbus_bool_t failed;

   701 } CheckNoMessagesData;

   702 

   703 static dbus_bool_t

   704 check_no_messages_foreach (DBusConnection *connection,

   705                            void           *data)

   706 {

   707   CheckNoMessagesData *d = data;

   708   DBusMessage *message;

   709 

   710   message = pop_message_waiting_for_memory (connection);

   711   if (message != NULL)

   712     {

   713       warn_unexpected (connection, message, "no messages");

   714 

   715       d->failed = TRUE;

   716     }

   717 

   718   if (message)

   719     dbus_message_unref (message);

   720   return !d->failed;

   721 }

   722 

   723 static dbus_bool_t

   724 check_no_leftovers (BusContext *context)

   725 {

   726   CheckNoMessagesData nmd;

   727 

   728   nmd.failed = FALSE;

   729   bus_test_clients_foreach (check_no_messages_foreach,

   730                             &nmd);

   731   

   732   if (nmd.failed)

   733     {

   734       _dbus_verbose ("%s: leftover message found\n",

   735                      _DBUS_FUNCTION_NAME);

   736       return FALSE;

   737     }

   738   else

   739     return TRUE;

   740 }

   741 

   742 /* returns TRUE if the correct thing happens,

   743  * but the correct thing may include OOM errors.

   744  */

   745 static dbus_bool_t

   746 check_hello_message (BusContext     *context,

   747                      DBusConnection *connection)

   748 {

   749   DBusMessage *message;

   750   DBusMessage *name_message;

   751   dbus_uint32_t serial;

   752   dbus_bool_t retval;

   753   DBusError error;

   754   const char *name;

   755   const char *acquired;

   756 

   757   retval = FALSE;

   758   dbus_error_init (&error);

   759   name = NULL;

   760   acquired = NULL;

   761   message = NULL;

   762   name_message = NULL;

   763 

   764   _dbus_verbose ("check_hello_message for %p\n", connection);

   765   

   766   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,

   767                                           DBUS_PATH_DBUS,

   768                                           DBUS_INTERFACE_DBUS,

   769                                           "Hello");

   770 

   771   if (message == NULL)

   772     return TRUE;

   773 

   774   dbus_connection_ref (connection); /* because we may get disconnected */

   775   

   776   if (!dbus_connection_send (connection, message, &serial))

   777     {

   778       dbus_message_unref (message);

   779       dbus_connection_unref (connection);

   780       return TRUE;

   781     }

   782 

   783   _dbus_assert (dbus_message_has_signature (message, ""));

   784   

   785   dbus_message_unref (message);

   786   message = NULL;

   787 

   788   if (!dbus_connection_get_is_connected (connection))

   789     {

   790       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");

   791       

   792       dbus_connection_unref (connection);

   793       

   794       return TRUE;

   795     }

   796   

   797   /* send our message */

   798   bus_test_run_clients_loop (SEND_PENDING (connection));

   799 

   800   if (!dbus_connection_get_is_connected (connection))

   801     {

   802       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");

   803       

   804       dbus_connection_unref (connection);

   805       

   806       return TRUE;

   807     }

   808   

   809   block_connection_until_message_from_bus (context, connection, "reply to Hello");

   810 

   811   if (!dbus_connection_get_is_connected (connection))

   812     {

   813       _dbus_verbose ("connection was disconnected (presumably auth failed)\n");

   814       

   815       dbus_connection_unref (connection);

   816       

   817       return TRUE;

   818     }

   819 

   820   dbus_connection_unref (connection);

   821   

   822   message = pop_message_waiting_for_memory (connection);

   823   if (message == NULL)

   824     {

   825       _dbus_warn ("Did not receive a reply to %s %d on %p\n",

   826                   "Hello", serial, connection);

   827       goto out;

   828     }

   829 

   830   verbose_message_received (connection, message);

   831 

   832   if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))

   833     {

   834       _dbus_warn ("Message has wrong sender %s\n",

   835                   dbus_message_get_sender (message) ?

   836                   dbus_message_get_sender (message) : "(none)");

   837       goto out;

   838     }

   839   

   840   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)

   841     {

   842       if (dbus_message_is_error (message,

   843                                  DBUS_ERROR_NO_MEMORY))

   844         {

   845           ; /* good, this is a valid response */

   846         }

   847       else

   848         {

   849           warn_unexpected (connection, message, "not this error");

   850 

   851           goto out;

   852         }

   853     }

   854   else

   855     {

   856       CheckServiceOwnerChangedData socd;

   857       

   858       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)

   859         {

   860           ; /* good, expected */

   861         }

   862       else

   863         {

   864           warn_unexpected (connection, message, "method return for Hello");

   865 

   866           goto out;

   867         }

   868 

   869     retry_get_hello_name:

   870       if (!dbus_message_get_args (message, &error,

   871                                   DBUS_TYPE_STRING, &name,

   872                                   DBUS_TYPE_INVALID))

   873         {

   874           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

   875             {

   876               _dbus_verbose ("no memory to get service name arg from hello\n");

   877               dbus_error_free (&error);

   878               _dbus_wait_for_memory ();

   879               goto retry_get_hello_name;

   880             }

   881           else

   882             {

   883               _dbus_assert (dbus_error_is_set (&error));

   884               _dbus_warn ("Did not get the expected single string argument to hello\n");

   885               goto out;

   886             }

   887         }

   888 

   889       _dbus_verbose ("Got hello name: %s\n", name);

   890 

   891       while (!dbus_bus_set_unique_name (connection, name))

   892         _dbus_wait_for_memory ();

   893       

   894       socd.expected_kind = SERVICE_CREATED;

   895       socd.expected_service_name = name;

   896       socd.failed = FALSE;

   897       socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */

   898       bus_test_clients_foreach (check_service_owner_changed_foreach,

   899                                 &socd);

   900       

   901       if (socd.failed)

   902         goto out;

   903 

   904       name_message = message;

   905       /* Client should also have gotten ServiceAcquired */

   906 

   907       message = pop_message_waiting_for_memory (connection);

   908       if (message == NULL)

   909         {

   910           _dbus_warn ("Expecting %s, got nothing\n",

   911                       "NameAcquired");

   912           goto out;

   913         }

   914       if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,

   915                                     "NameAcquired"))

   916         {

   917           _dbus_warn ("Expecting %s, got smthg else\n",

   918                       "NameAcquired");

   919           goto out;

   920         }

   921       

   922     retry_get_acquired_name:

   923       if (!dbus_message_get_args (message, &error,

   924                                   DBUS_TYPE_STRING, &acquired,

   925                                   DBUS_TYPE_INVALID))

   926         {

   927           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

   928             {

   929               _dbus_verbose ("no memory to get service name arg from acquired\n");

   930               dbus_error_free (&error);

   931               _dbus_wait_for_memory ();

   932               goto retry_get_acquired_name;

   933             }

   934           else

   935             {

   936               _dbus_assert (dbus_error_is_set (&error));

   937               _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");

   938               goto out;

   939             }

   940         }

   941 

   942       _dbus_verbose ("Got acquired name: %s\n", acquired);

   943 

   944       if (strcmp (acquired, name) != 0)

   945         {

   946           _dbus_warn ("Acquired name is %s but expected %s\n",

   947                       acquired, name);

   948           goto out;

   949         }

   950       acquired = NULL;

   951     }

   952 

   953   if (!check_no_leftovers (context))

   954     goto out;

   955   

   956   retval = TRUE;

   957   

   958  out:

   959   _dbus_verbose ("ending %s retval = %d\n", _DBUS_FUNCTION_NAME, retval);

   960   

   961   dbus_error_free (&error);

   962   

   963   if (message)

   964     dbus_message_unref (message);

   965 

   966   if (name_message)

   967     dbus_message_unref (name_message);

   968   

   969   return retval;

   970 }

   971 

   972 /* returns TRUE if the correct thing happens,

   973  * but the correct thing may include OOM errors.

   974  */

   975 static dbus_bool_t

   976 check_double_hello_message (BusContext     *context,

   977                             DBusConnection *connection)

   978 {

   979   DBusMessage *message;

   980   dbus_uint32_t serial;

   981   dbus_bool_t retval;

   982   DBusError error;

   983 

   984   retval = FALSE;

   985   dbus_error_init (&error);

   986   message = NULL;

   987 

   988   _dbus_verbose ("check_double_hello_message for %p\n", connection);

   989   

   990   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,

   991                                           DBUS_PATH_DBUS,

   992                                           DBUS_INTERFACE_DBUS,

   993                                           "Hello");

   994 

   995   if (message == NULL)

   996     return TRUE;

   997   

   998   if (!dbus_connection_send (connection, message, &serial))

   999     {

  1000       dbus_message_unref (message);

  1001       return TRUE;

  1002     }

  1003 

  1004   dbus_message_unref (message);

  1005   message = NULL;

  1006 

  1007   /* send our message */

  1008   bus_test_run_clients_loop (SEND_PENDING (connection));

  1009 

  1010   dbus_connection_ref (connection); /* because we may get disconnected */

  1011   block_connection_until_message_from_bus (context, connection, "reply to Hello");

  1012 

  1013   if (!dbus_connection_get_is_connected (connection))

  1014     {

  1015       _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);

  1016       

  1017       dbus_connection_unref (connection);

  1018       

  1019       return TRUE;

  1020     }

  1021 

  1022   dbus_connection_unref (connection);

  1023   

  1024   message = pop_message_waiting_for_memory (connection);

  1025   if (message == NULL)

  1026     {

  1027       _dbus_warn ("Did not receive a reply to %s %d on %p\n",

  1028                   "Hello", serial, connection);

  1029       goto out;

  1030     }

  1031 

  1032   verbose_message_received (connection, message);

  1033 

  1034   if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))

  1035     {

  1036       _dbus_warn ("Message has wrong sender %s\n",

  1037                   dbus_message_get_sender (message) ?

  1038                   dbus_message_get_sender (message) : "(none)");

  1039       goto out;

  1040     }

  1041   

  1042   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)

  1043     {

  1044       warn_unexpected (connection, message, "method return for Hello");

  1045       goto out;

  1046     }

  1047 

  1048   if (!check_no_leftovers (context))

  1049     goto out;

  1050   

  1051   retval = TRUE;

  1052   

  1053  out:

  1054   dbus_error_free (&error);

  1055   

  1056   if (message)

  1057     dbus_message_unref (message);

  1058   

  1059   return retval;

  1060 }

  1061 

  1062 /* returns TRUE if the correct thing happens,

  1063  * but the correct thing may include OOM errors.

  1064  */

  1065 static dbus_bool_t

  1066 check_get_connection_unix_user (BusContext     *context,

  1067                                 DBusConnection *connection)

  1068 {

  1069   DBusMessage *message;

  1070   dbus_uint32_t serial;

  1071   dbus_bool_t retval;

  1072   DBusError error;

  1073   const char *base_service_name;

  1074   dbus_uint32_t uid;

  1075 

  1076   retval = FALSE;

  1077   dbus_error_init (&error);

  1078   message = NULL;

  1079 

  1080   _dbus_verbose ("check_get_connection_unix_user for %p\n", connection);

  1081   

  1082   message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,

  1083                                           DBUS_PATH_DBUS,

  1084                                           DBUS_INTERFACE_DBUS,

  1085                                           "GetConnectionUnixUser");

  1086 

  1087   if (message == NULL)

  1088     return TRUE;

  1089 

  1090   base_service_name = dbus_bus_get_unique_name (connection);

  1091 

  1092   if (!dbus_message_append_args (message, 

  1093                                  DBUS_TYPE_STRING, &base_service_name,

  1094                                  DBUS_TYPE_INVALID))

  1095     {

  1096       dbus_message_unref (message);

  1097       return TRUE;

  1098     }

  1099 

  1100   if (!dbus_connection_send (connection, message, &serial))

  1101     {

  1102       dbus_message_unref (message);

  1103       return TRUE;

  1104     }

  1105 

  1106   /* send our message */

  1107   bus_test_run_clients_loop (SEND_PENDING (connection));

  1108 

  1109   dbus_message_unref (message);

  1110   message = NULL;

  1111 

  1112   dbus_connection_ref (connection); /* because we may get disconnected */

  1113   block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixUser");

  1114 

  1115   if (!dbus_connection_get_is_connected (connection))

  1116     {

  1117       _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);

  1118       

  1119       dbus_connection_unref (connection);

  1120       

  1121       return TRUE;

  1122     }

  1123 

  1124   dbus_connection_unref (connection);

  1125 

  1126   message = pop_message_waiting_for_memory (connection);

  1127   if (message == NULL)

  1128     {

  1129       _dbus_warn ("Did not receive a reply to %s %d on %p\n",

  1130                   "GetConnectionUnixUser", serial, connection);

  1131       goto out;

  1132     }

  1133 

  1134   verbose_message_received (connection, message);

  1135