2003-08-19 Havoc Pennington <hp@pobox.com>
[platform/upstream/dbus.git] / bus / dispatch.c
1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dispatch.c  Message dispatcher
3  *
4  * Copyright (C) 2003  CodeFactory AB
5  * Copyright (C) 2003  Red Hat, Inc.
6  *
7  * Licensed under the Academic Free License version 1.2
8  * 
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  * 
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  *
23  */
24
25 #include "dispatch.h"
26 #include "connection.h"
27 #include "driver.h"
28 #include "services.h"
29 #include "utils.h"
30 #include "bus.h"
31 #include "test.h"
32 #include <dbus/dbus-internals.h>
33 #include <string.h>
34
35 static dbus_int32_t message_handler_slot = -1;
36
37 typedef struct
38 {
39   BusContext     *context;
40   DBusConnection *sender;
41   DBusMessage    *message;
42   BusTransaction *transaction;
43   DBusError      *error;
44 } SendMessageData;
45
46 static dbus_bool_t
47 send_one_message (DBusConnection *connection, void *data)
48 {
49   SendMessageData *d = data;
50
51   if (!bus_context_check_security_policy (d->context,
52                                           d->sender,
53                                           connection,
54                                           d->message,
55                                           NULL))
56     return TRUE; /* silently don't send it */
57   
58   if (!bus_transaction_send (d->transaction,
59                              connection,
60                              d->message))
61     {
62       BUS_SET_OOM (d->error);
63       return FALSE;
64     }
65
66   return TRUE;
67 }
68
69 dbus_bool_t
70 bus_dispatch_broadcast_message (BusTransaction *transaction,
71                                 DBusConnection *sender,
72                                 DBusMessage    *message,
73                                 DBusError      *error)
74 {
75   DBusError tmp_error;
76   SendMessageData d;
77   BusConnections *connections;
78
79   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
80   
81   _dbus_assert (dbus_message_get_sender (message) != NULL);
82
83   connections = bus_transaction_get_connections (transaction);
84   
85   dbus_error_init (&tmp_error);
86   d.sender = sender;
87   d.context = bus_transaction_get_context (transaction);
88   d.message = message;
89   d.transaction = transaction;
90   d.error = &tmp_error;
91   
92   bus_connections_foreach_active (connections, send_one_message, &d);
93
94   if (dbus_error_is_set (&tmp_error))
95     {
96       dbus_move_error (&tmp_error, error);
97       return FALSE;
98     }
99   else
100     return TRUE;
101 }
102
103 static DBusHandlerResult
104 bus_dispatch (DBusConnection *connection,
105               DBusMessage    *message)
106 {
107   const char *sender, *service_name;
108   DBusError error;
109   BusTransaction *transaction;
110   BusContext *context;
111   DBusHandlerResult result;
112
113   result = DBUS_HANDLER_RESULT_HANDLED;
114   
115   transaction = NULL;
116   dbus_error_init (&error);
117   
118   context = bus_connection_get_context (connection);
119   _dbus_assert (context != NULL);
120   
121   /* If we can't even allocate an OOM error, we just go to sleep
122    * until we can.
123    */
124   while (!bus_connection_preallocate_oom_error (connection))
125     _dbus_wait_for_memory ();
126   
127   /* Ref connection in case we disconnect it at some point in here */
128   dbus_connection_ref (connection);
129   
130   service_name = dbus_message_get_destination (message);
131
132 #ifdef DBUS_ENABLE_VERBOSE_MODE
133   {
134     const char *interface_name, *member_name, *error_name;
135
136     interface_name = dbus_message_get_interface (message);
137     member_name = dbus_message_get_member (message);
138     error_name = dbus_message_get_error_name (message);
139     
140     _dbus_verbose ("DISPATCH: %s %s %s to %s\n",
141                    interface_name ? interface_name : "(no interface)",
142                    member_name ? member_name : "(no member)",
143                    error_name ? error_name : "(no error name)",
144                    service_name ? service_name : "peer");
145   }
146 #endif /* DBUS_ENABLE_VERBOSE_MODE */
147   
148   /* If service_name is NULL, this is a message to the bus daemon, not
149    * intended to actually go "on the bus"; e.g. a peer-to-peer
150    * ping. Handle these immediately, especially disconnection
151    * messages. There are no security policy checks on these.
152    */
153   if (service_name == NULL)
154     {      
155       if (dbus_message_is_signal (message,
156                                   DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
157                                   "Disconnected"))
158         bus_connection_disconnected (connection);
159
160       /* DBusConnection also handles some of these automatically, we leave
161        * it to do so.
162        */
163       result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
164       goto out;
165     }
166
167   _dbus_assert (service_name != NULL); /* this message is intended for bus routing */
168   
169   /* Create our transaction */
170   transaction = bus_transaction_new (context);
171   if (transaction == NULL)
172     {
173       BUS_SET_OOM (&error);
174       goto out;
175     }
176   
177   /* Assign a sender to the message */
178   if (bus_connection_is_active (connection))
179     {
180       sender = bus_connection_get_name (connection);
181       _dbus_assert (sender != NULL);
182
183       if (!dbus_message_set_sender (message, sender))
184         {
185           BUS_SET_OOM (&error);
186           goto out;
187         }
188
189       /* We need to refetch the service name here, because
190        * dbus_message_set_sender can cause the header to be
191        * reallocated, and thus the service_name pointer will become
192        * invalid.
193        */
194       service_name = dbus_message_get_destination (message);
195     }
196
197   if (strcmp (service_name, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS) == 0) /* to bus driver */
198     {
199       if (!bus_context_check_security_policy (context,
200                                               connection, NULL, message, &error))
201         {
202           _dbus_verbose ("Security policy rejected message\n");
203           goto out;
204         }
205
206       _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
207       if (!bus_driver_handle_message (connection, transaction, message, &error))
208         goto out;
209     }
210   else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */
211     {
212       _dbus_verbose ("Received message from non-registered client. Disconnecting.\n");
213       dbus_connection_disconnect (connection);
214     }
215   /* FIXME what if we un-special-case this service and just have a flag
216    * on services that all service owners will get messages to it, not just
217    * the primary owner.
218    */
219   else if (strcmp (service_name, DBUS_SERVICE_ORG_FREEDESKTOP_BROADCAST) == 0) /* spam! */
220     {
221       if (!bus_dispatch_broadcast_message (transaction, connection, message, &error))
222         goto out;
223     }
224   else  /* route to named service */
225     {
226       DBusString service_string;
227       BusService *service;
228       BusRegistry *registry;
229
230       registry = bus_connection_get_registry (connection);
231       
232       _dbus_string_init_const (&service_string, service_name);
233       service = bus_registry_lookup (registry, &service_string);
234
235       if (service == NULL)
236         {
237           dbus_set_error (&error,
238                           DBUS_ERROR_SERVICE_DOES_NOT_EXIST,
239                           "Service \"%s\" does not exist",
240                           service_name);
241           goto out;
242         }
243       else
244         {
245           DBusConnection *recipient;
246           
247           recipient = bus_service_get_primary_owner (service);
248           _dbus_assert (recipient != NULL);
249           
250           if (!bus_context_check_security_policy (context,
251                                                   connection, recipient, message, &error))
252             goto out;
253           
254           /* Dispatch the message */
255           if (!bus_transaction_send (transaction, recipient, message))
256             {
257               BUS_SET_OOM (&error);
258               goto out;
259             }
260         }
261     }
262   
263  out:
264   if (dbus_error_is_set (&error))
265     {
266       if (!dbus_connection_get_is_connected (connection))
267         {
268           /* If we disconnected it, we won't bother to send it any error
269            * messages.
270            */
271           _dbus_verbose ("Not sending error to connection we disconnected\n");
272         }
273       else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
274         {
275           bus_connection_send_oom_error (connection, message);
276
277           /* cancel transaction due to OOM */
278           if (transaction != NULL)
279             {
280               bus_transaction_cancel_and_free (transaction);
281               transaction = NULL;
282             }
283         }
284       else
285         {
286           /* Try to send the real error, if no mem to do that, send
287            * the OOM error
288            */
289           _dbus_assert (transaction != NULL);
290           
291           if (!bus_transaction_send_error_reply (transaction, connection,
292                                                  &error, message))
293             {
294               bus_connection_send_oom_error (connection, message);
295               
296               /* cancel transaction due to OOM */
297               if (transaction != NULL)
298                 {
299                   bus_transaction_cancel_and_free (transaction);
300                   transaction = NULL;
301                 }
302             }
303         }
304       
305       dbus_error_free (&error);
306     }
307
308   if (transaction != NULL)
309     {
310       bus_transaction_execute_and_free (transaction);
311     }
312
313   dbus_connection_unref (connection);
314
315   return result;
316 }
317
318 static DBusHandlerResult
319 bus_dispatch_message_handler (DBusMessageHandler *handler,
320                               DBusConnection     *connection,
321                               DBusMessage        *message,
322                               void               *user_data)
323 {
324   return bus_dispatch (connection, message);
325 }
326
327 static void
328 free_message_handler (void *data)
329 {
330   DBusMessageHandler *handler = data;
331   
332   _dbus_assert (message_handler_slot >= 0);
333   
334   dbus_message_handler_unref (handler);
335   dbus_connection_free_data_slot (&message_handler_slot);
336 }
337
338 dbus_bool_t
339 bus_dispatch_add_connection (DBusConnection *connection)
340 {
341   DBusMessageHandler *handler;
342
343   if (!dbus_connection_allocate_data_slot (&message_handler_slot))
344     return FALSE;
345   
346   handler = dbus_message_handler_new (bus_dispatch_message_handler, NULL, NULL);  
347   if (handler == NULL)
348     {
349       dbus_connection_free_data_slot (&message_handler_slot);
350       return FALSE;
351     }    
352   
353   if (!dbus_connection_add_filter (connection, handler))
354     {
355       dbus_message_handler_unref (handler);
356       dbus_connection_free_data_slot (&message_handler_slot);
357       
358       return FALSE;
359     }
360
361   _dbus_assert (message_handler_slot >= 0);
362   
363   if (!dbus_connection_set_data (connection,
364                                  message_handler_slot,
365                                  handler,
366                                  free_message_handler))
367     {
368       dbus_message_handler_unref (handler);
369       dbus_connection_free_data_slot (&message_handler_slot);
370
371       return FALSE;
372     }
373
374   return TRUE;
375 }
376
377 void
378 bus_dispatch_remove_connection (DBusConnection *connection)
379 {
380   /* Here we tell the bus driver that we want to get off. */
381   bus_driver_remove_connection (connection);
382
383   dbus_connection_set_data (connection,
384                             message_handler_slot,
385                             NULL, NULL);
386 }
387
388 #ifdef DBUS_BUILD_TESTS
389
390 typedef dbus_bool_t (* Check1Func) (BusContext     *context);
391 typedef dbus_bool_t (* Check2Func) (BusContext     *context,
392                                     DBusConnection *connection);
393
394 static dbus_bool_t check_no_leftovers (BusContext *context);
395
396 static void
397 block_connection_until_message_from_bus (BusContext     *context,
398                                          DBusConnection *connection)
399 {
400   while (dbus_connection_get_dispatch_status (connection) ==
401          DBUS_DISPATCH_COMPLETE &&
402          dbus_connection_get_is_connected (connection))
403     {
404       bus_test_run_bus_loop (context, TRUE);
405       bus_test_run_clients_loop (FALSE);
406     }
407 }
408
409 /* compensate for fact that pop_message() can return #NULL due to OOM */
410 static DBusMessage*
411 pop_message_waiting_for_memory (DBusConnection *connection)
412 {
413   while (dbus_connection_get_dispatch_status (connection) ==
414          DBUS_DISPATCH_NEED_MEMORY)
415     _dbus_wait_for_memory ();
416
417   return dbus_connection_pop_message (connection);
418 }
419
420 static void
421 warn_unexpected_real (DBusConnection *connection,
422                       DBusMessage    *message,
423                       const char     *expected,
424                       const char     *function,
425                       int             line)
426 {
427   _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n",
428               function, line,
429               dbus_message_get_interface (message) ?
430               dbus_message_get_interface (message) : "(unset)",
431               dbus_message_get_member (message) ?
432               dbus_message_get_member (message) : "(unset)",
433               dbus_message_get_error_name (message) ?
434               dbus_message_get_error_name (message) : "(unset)",
435               connection,
436               expected);
437 }
438
439 #define warn_unexpected(connection, message, expected) \
440   warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__)
441
442 static void
443 verbose_message_received (DBusConnection *connection,
444                           DBusMessage    *message)
445 {
446   _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n",
447                  dbus_message_get_interface (message) ?
448                  dbus_message_get_interface (message) : "(unset)",
449                  dbus_message_get_member (message) ?
450                  dbus_message_get_member (message) : "(unset)",
451                  dbus_message_get_error_name (message) ?
452                  dbus_message_get_error_name (message) : "(unset)",
453                  connection);
454 }
455
456 typedef struct
457 {
458   const char *expected_service_name;
459   dbus_bool_t failed;
460 } CheckServiceDeletedData;
461
462 static dbus_bool_t
463 check_service_deleted_foreach (DBusConnection *connection,
464                                void           *data)
465 {
466   CheckServiceDeletedData *d = data;
467   DBusMessage *message;
468   DBusError error;
469   char *service_name;
470
471   dbus_error_init (&error);
472   d->failed = TRUE;
473   service_name = NULL;
474   
475   message = pop_message_waiting_for_memory (connection);
476   if (message == NULL)
477     {
478       _dbus_warn ("Did not receive a message on %p, expecting %s\n",
479                   connection, "ServiceDeleted");
480       goto out;
481     }
482   else if (!dbus_message_is_signal (message,
483                                     DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
484                                     "ServiceDeleted"))
485     {
486       warn_unexpected (connection, message, "ServiceDeleted");
487
488       goto out;
489     }
490   else
491     {
492       if (!dbus_message_get_args (message, &error,
493                                   DBUS_TYPE_STRING, &service_name,
494                                   DBUS_TYPE_INVALID))
495         {
496           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
497             {
498               _dbus_verbose ("no memory to get service name arg\n");
499             }
500           else
501             {
502               _dbus_assert (dbus_error_is_set (&error));
503               _dbus_warn ("Did not get the expected single string argument\n");
504               goto out;
505             }
506         }
507       else if (strcmp (service_name, d->expected_service_name) != 0)
508         {
509           _dbus_warn ("expected deletion of service %s, got deletion of %s\n",
510                       d->expected_service_name,
511                       service_name);
512           goto out;
513         }
514     }
515
516   d->failed = FALSE;
517   
518  out:
519   dbus_free (service_name);
520   dbus_error_free (&error);
521   
522   if (message)
523     dbus_message_unref (message);
524
525   return !d->failed;
526 }
527
528 static void
529 kill_client_connection (BusContext     *context,
530                         DBusConnection *connection)
531 {
532   char *base_service;
533   const char *s;
534   CheckServiceDeletedData csdd;
535
536   _dbus_verbose ("killing connection %p\n", connection);
537   
538   s = dbus_bus_get_base_service (connection);
539   _dbus_assert (s != NULL);
540
541   while ((base_service = _dbus_strdup (s)) == NULL)
542     _dbus_wait_for_memory ();
543
544   dbus_connection_ref (connection);
545   
546   /* kick in the disconnect handler that unrefs the connection */
547   dbus_connection_disconnect (connection);
548
549   bus_test_run_everything (context);
550   
551   _dbus_assert (bus_test_client_listed (connection));
552   
553   /* Run disconnect handler in test.c */
554   if (bus_connection_dispatch_one_message (connection))
555     _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
556   
557   _dbus_assert (!dbus_connection_get_is_connected (connection));
558   dbus_connection_unref (connection);
559   connection = NULL;
560   _dbus_assert (!bus_test_client_listed (connection));
561   
562   csdd.expected_service_name = base_service;
563   csdd.failed = FALSE;
564
565   bus_test_clients_foreach (check_service_deleted_foreach,
566                             &csdd);
567
568   dbus_free (base_service);
569   
570   if (csdd.failed)
571     _dbus_assert_not_reached ("didn't get the expected ServiceDeleted messages");
572   
573   if (!check_no_leftovers (context))
574     _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
575 }
576
577 static void
578 kill_client_connection_unchecked (DBusConnection *connection)
579 {
580   /* This kills the connection without expecting it to affect
581    * the rest of the bus.
582    */  
583   _dbus_verbose ("Unchecked kill of connection %p\n", connection);
584
585   dbus_connection_ref (connection);
586   dbus_connection_disconnect (connection);
587   /* dispatching disconnect handler will unref once */
588   if (bus_connection_dispatch_one_message (connection))
589     _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
590
591   _dbus_assert (!bus_test_client_listed (connection));
592   dbus_connection_unref (connection);
593 }
594
595 typedef struct
596 {
597   dbus_bool_t failed;
598 } CheckNoMessagesData;
599
600 static dbus_bool_t
601 check_no_messages_foreach (DBusConnection *connection,
602                            void           *data)
603 {
604   CheckNoMessagesData *d = data;
605   DBusMessage *message;
606
607   message = pop_message_waiting_for_memory (connection);
608   if (message != NULL)
609     {
610       warn_unexpected (connection, message, "no messages");
611
612       d->failed = TRUE;
613     }
614
615   if (message)
616     dbus_message_unref (message);
617   return !d->failed;
618 }
619
620 typedef struct
621 {
622   DBusConnection *skip_connection;
623   const char *expected_service_name;
624   dbus_bool_t failed;
625 } CheckServiceCreatedData;
626
627 static dbus_bool_t
628 check_service_created_foreach (DBusConnection *connection,
629                                void           *data)
630 {
631   CheckServiceCreatedData *d = data;
632   DBusMessage *message;
633   DBusError error;
634   char *service_name;
635
636   if (connection == d->skip_connection)
637     return TRUE;
638
639   dbus_error_init (&error);
640   d->failed = TRUE;
641   service_name = NULL;
642   
643   message = pop_message_waiting_for_memory (connection);
644   if (message == NULL)
645     {
646       _dbus_warn ("Did not receive a message on %p, expecting %s\n",
647                   connection, "ServiceCreated");
648       goto out;
649     }
650   else if (!dbus_message_is_signal (message,
651                                     DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
652                                     "ServiceCreated"))
653     {
654       warn_unexpected (connection, message, "ServiceCreated");
655       goto out;
656     }
657   else
658     {
659       if (!dbus_message_get_args (message, &error,
660                                   DBUS_TYPE_STRING, &service_name,
661                                   DBUS_TYPE_INVALID))
662         {
663           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
664             {
665               _dbus_verbose ("no memory to get service name arg\n");
666             }
667           else
668             {
669               _dbus_assert (dbus_error_is_set (&error));
670               _dbus_warn ("Did not get the expected single string argument\n");
671               goto out;
672             }
673         }
674       else if (strcmp (service_name, d->expected_service_name) != 0)
675         {
676           _dbus_warn ("expected creation of service %s, got creation of %s\n",
677                       d->expected_service_name,
678                       service_name);
679           goto out;
680         }
681     }
682
683   d->failed = FALSE;
684   
685  out:
686   dbus_free (service_name);
687   dbus_error_free (&error);
688   
689   if (message)
690     dbus_message_unref (message);
691
692   return !d->failed;
693 }
694
695 static dbus_bool_t
696 check_no_leftovers (BusContext *context)
697 {
698   CheckNoMessagesData nmd;
699
700   nmd.failed = FALSE;
701   bus_test_clients_foreach (check_no_messages_foreach,
702                             &nmd);
703   
704   if (nmd.failed)
705     return FALSE;
706   else
707     return TRUE;
708 }
709
710 /* returns TRUE if the correct thing happens,
711  * but the correct thing may include OOM errors.
712  */
713 static dbus_bool_t
714 check_hello_message (BusContext     *context,
715                      DBusConnection *connection)
716 {
717   DBusMessage *message;
718   dbus_int32_t serial;
719   dbus_bool_t retval;
720   DBusError error;
721   char *name;
722   char *acquired;
723
724   retval = FALSE;
725   dbus_error_init (&error);
726   name = NULL;
727   acquired = NULL;
728   message = NULL;
729   
730   message = dbus_message_new_method_call (DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
731                                           "Hello",
732                                           DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
733
734   if (message == NULL)
735     return TRUE;
736
737   if (!dbus_connection_send (connection, message, &serial))
738     {
739       dbus_message_unref (message);
740       return TRUE;
741     }
742
743   dbus_message_unref (message);
744   message = NULL;
745
746   /* send our message */
747   bus_test_run_clients_loop (TRUE);
748
749   dbus_connection_ref (connection); /* because we may get disconnected */
750   block_connection_until_message_from_bus (context, connection);
751
752   if (!dbus_connection_get_is_connected (connection))
753     {
754       _dbus_verbose ("connection was disconnected\n");
755       
756       dbus_connection_unref (connection);
757       
758       return TRUE;
759     }
760
761   dbus_connection_unref (connection);
762   
763   message = pop_message_waiting_for_memory (connection);
764   if (message == NULL)
765     {
766       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
767                   "Hello", serial, connection);
768       goto out;
769     }
770
771   verbose_message_received (connection, message);
772
773   if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
774     {
775       _dbus_warn ("Message has wrong sender %s\n",
776                   dbus_message_get_sender (message) ?
777                   dbus_message_get_sender (message) : "(none)");
778       goto out;
779     }
780   
781   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
782     {
783       if (dbus_message_is_error (message,
784                                  DBUS_ERROR_NO_MEMORY))
785         {
786           ; /* good, this is a valid response */
787         }
788       else
789         {
790           warn_unexpected (connection, message, "not this error");
791
792           goto out;
793         }
794     }
795   else
796     {
797       CheckServiceCreatedData scd;
798       
799       if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
800         {
801           ; /* good, expected */
802         }
803       else
804         {
805           warn_unexpected (connection, message, "method return for Hello");
806
807           goto out;
808         }
809
810     retry_get_hello_name:
811       if (!dbus_message_get_args (message, &error,
812                                   DBUS_TYPE_STRING, &name,
813                                   DBUS_TYPE_INVALID))
814         {
815           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
816             {
817               _dbus_verbose ("no memory to get service name arg from hello\n");
818               dbus_error_free (&error);
819               _dbus_wait_for_memory ();
820               goto retry_get_hello_name;
821             }
822           else
823             {
824               _dbus_assert (dbus_error_is_set (&error));
825               _dbus_warn ("Did not get the expected single string argument to hello\n");
826               goto out;
827             }
828         }
829
830       _dbus_verbose ("Got hello name: %s\n", name);
831
832       while (!dbus_bus_set_base_service (connection, name))
833         _dbus_wait_for_memory ();
834       
835       scd.skip_connection = NULL;
836       scd.failed = FALSE;
837       scd.expected_service_name = name;
838       bus_test_clients_foreach (check_service_created_foreach,
839                                 &scd);
840       
841       if (scd.failed)
842         goto out;
843       
844       /* Client should also have gotten ServiceAcquired */
845       dbus_message_unref (message);
846       message = pop_message_waiting_for_memory (connection);
847       if (message == NULL)
848         {
849           _dbus_warn ("Expecting %s, got nothing\n",
850                       "ServiceAcquired");
851           goto out;
852         }
853       
854     retry_get_acquired_name:
855       if (!dbus_message_get_args (message, &error,
856                                   DBUS_TYPE_STRING, &acquired,
857                                   DBUS_TYPE_INVALID))
858         {
859           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
860             {
861               _dbus_verbose ("no memory to get service name arg from acquired\n");
862               dbus_error_free (&error);
863               _dbus_wait_for_memory ();
864               goto retry_get_acquired_name;
865             }
866           else
867             {
868               _dbus_assert (dbus_error_is_set (&error));
869               _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");
870               goto out;
871             }
872         }
873
874       _dbus_verbose ("Got acquired name: %s\n", acquired);
875
876       if (strcmp (acquired, name) != 0)
877         {
878           _dbus_warn ("Acquired name is %s but expected %s\n",
879                       acquired, name);
880           goto out;
881         }
882     }
883
884   if (!check_no_leftovers (context))
885     goto out;
886   
887   retval = TRUE;
888   
889  out:
890   dbus_error_free (&error);
891   
892   dbus_free (name);
893   dbus_free (acquired);
894   
895   if (message)
896     dbus_message_unref (message);
897   
898   return retval;
899 }
900
901 /* returns TRUE if the correct thing happens,
902  * but the correct thing may include OOM errors.
903  */
904 static dbus_bool_t
905 check_hello_connection (BusContext *context)
906 {
907   DBusConnection *connection;
908   DBusError error;
909
910   dbus_error_init (&error);
911
912   connection = dbus_connection_open ("debug-pipe:name=test-server", &error);
913   if (connection == NULL)
914     {
915       _DBUS_ASSERT_ERROR_IS_SET (&error);
916       dbus_error_free (&error);
917       return TRUE;
918     }
919
920   if (!bus_setup_debug_client (connection))
921     {
922       dbus_connection_disconnect (connection);
923       dbus_connection_unref (connection);
924       return TRUE;
925     }
926
927   if (!check_hello_message (context, connection))
928     return FALSE;
929
930   if (dbus_bus_get_base_service (connection) == NULL)
931     {
932       /* We didn't successfully register, so we can't
933        * do the usual kill_client_connection() checks
934        */
935       kill_client_connection_unchecked (connection);
936     }
937   else
938     {
939       kill_client_connection (context, connection);
940     }
941
942   return TRUE;
943 }
944
945 #define NONEXISTENT_SERVICE_NAME "test.this.service.does.not.exist.ewuoiurjdfxcvn"
946
947 /* returns TRUE if the correct thing happens,
948  * but the correct thing may include OOM errors.
949  */
950 static dbus_bool_t
951 check_nonexistent_service_activation (BusContext     *context,
952                                       DBusConnection *connection)
953 {
954   DBusMessage *message;
955   dbus_int32_t serial;
956   dbus_bool_t retval;
957   DBusError error;
958   
959   dbus_error_init (&error);
960   
961   message = dbus_message_new_method_call (DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
962                                           "ActivateService",
963                                           DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
964
965   if (message == NULL)
966     return TRUE;
967
968   if (!dbus_message_append_args (message,
969                                  DBUS_TYPE_STRING, NONEXISTENT_SERVICE_NAME,
970                                  DBUS_TYPE_UINT32, 0,
971                                  DBUS_TYPE_INVALID))
972     {
973       dbus_message_unref (message);
974       return TRUE;
975     }
976   
977   if (!dbus_connection_send (connection, message, &serial))
978     {
979       dbus_message_unref (message);
980       return TRUE;
981     }
982
983   dbus_message_unref (message);
984   message = NULL;
985
986   bus_test_run_everything (context);
987   block_connection_until_message_from_bus (context, connection);
988   bus_test_run_everything (context);
989
990   if (!dbus_connection_get_is_connected (connection))
991     {
992       _dbus_verbose ("connection was disconnected\n");
993       return TRUE;
994     }
995   
996   retval = FALSE;
997   
998   message = pop_message_waiting_for_memory (connection);
999   if (message == NULL)
1000     {
1001       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1002                   "ActivateService", serial, connection);
1003       goto out;
1004     }
1005
1006   verbose_message_received (connection, message);
1007
1008   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1009     {
1010       if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
1011         {
1012           _dbus_warn ("Message has wrong sender %s\n",
1013                       dbus_message_get_sender (message) ?
1014                       dbus_message_get_sender (message) : "(none)");
1015           goto out;
1016         }
1017       
1018       if (dbus_message_is_error (message,
1019                                  DBUS_ERROR_NO_MEMORY))
1020         {
1021           ; /* good, this is a valid response */
1022         }
1023       else if (dbus_message_is_error (message,
1024                                       DBUS_ERROR_ACTIVATE_SERVICE_NOT_FOUND))
1025         {
1026           ; /* good, this is expected also */
1027         }
1028       else
1029         {
1030           warn_unexpected (connection, message, "not this error");
1031           goto out;
1032         }
1033     }
1034   else
1035     {
1036       _dbus_warn ("Did not expect to successfully activate %s\n",
1037                   NONEXISTENT_SERVICE_NAME);
1038       goto out;
1039     }
1040
1041   retval = TRUE;
1042   
1043  out:
1044   if (message)
1045     dbus_message_unref (message);
1046   
1047   return retval;
1048 }
1049
1050 static dbus_bool_t
1051 check_base_service_activated (BusContext     *context,
1052                               DBusConnection *connection,
1053                               DBusMessage    *initial_message,
1054                               char          **base_service_p)
1055 {
1056   DBusMessage *message;
1057   dbus_bool_t retval;
1058   DBusError error;
1059   char *base_service;
1060   
1061   base_service = NULL;
1062   retval = FALSE;
1063   
1064   dbus_error_init (&error);
1065
1066   message = initial_message;
1067   dbus_message_ref (message);  
1068
1069   if (dbus_message_is_signal (message,
1070                               DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1071                               "ServiceCreated"))
1072     {
1073       char *service_name;
1074       CheckServiceCreatedData scd;
1075
1076     reget_service_name_arg:
1077       if (!dbus_message_get_args (message, &error,
1078                                   DBUS_TYPE_STRING, &service_name,
1079                                   DBUS_TYPE_INVALID))
1080         {
1081           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1082             {
1083               dbus_error_free (&error);
1084               _dbus_wait_for_memory ();
1085               goto reget_service_name_arg;
1086             }
1087           else
1088             {
1089               _dbus_warn ("Message %s doesn't have a service name: %s\n",
1090                           "ServiceCreated",
1091                           error.message);
1092               dbus_error_free (&error);
1093               goto out;
1094             }
1095         }
1096
1097       if (*service_name != ':')
1098         {
1099           _dbus_warn ("Expected base service activation, got \"%s\" instead\n",
1100                       service_name);
1101           goto out;
1102         }
1103               
1104       base_service = service_name;
1105       service_name = NULL;
1106       
1107       scd.skip_connection = connection;
1108       scd.failed = FALSE;
1109       scd.expected_service_name = base_service;
1110       bus_test_clients_foreach (check_service_created_foreach,
1111                                 &scd);
1112       
1113       if (scd.failed)
1114         goto out;
1115     }
1116   else
1117     {
1118       warn_unexpected (connection, message, "ServiceCreated for base service");
1119
1120       goto out;
1121     }
1122
1123   retval = TRUE;
1124
1125   if (base_service_p)
1126     {
1127       *base_service_p = base_service;
1128       base_service = NULL;
1129     }
1130   
1131  out:
1132   if (message)
1133     dbus_message_unref (message);
1134
1135   if (base_service)
1136     dbus_free (base_service);
1137   
1138   return retval;
1139 }
1140
1141 static dbus_bool_t
1142 check_service_activated (BusContext     *context,
1143                          DBusConnection *connection,
1144                          const char     *activated_name,
1145                          const char     *base_service_name,
1146                          DBusMessage    *initial_message)
1147 {
1148   DBusMessage *message;
1149   dbus_bool_t retval;
1150   DBusError error;
1151   dbus_uint32_t activation_result;
1152   
1153   retval = FALSE;
1154   
1155   dbus_error_init (&error);
1156
1157   message = initial_message;
1158   dbus_message_ref (message);
1159
1160   if (dbus_message_is_signal (message,
1161                               DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1162                               "ServiceCreated"))
1163     {
1164       char *service_name;
1165       CheckServiceCreatedData scd;
1166
1167     reget_service_name_arg:
1168       if (!dbus_message_get_args (message, &error,
1169                                   DBUS_TYPE_STRING, &service_name,
1170                                   DBUS_TYPE_INVALID))
1171         {
1172           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1173             {
1174               dbus_error_free (&error);
1175               _dbus_wait_for_memory ();
1176               goto reget_service_name_arg;
1177             }
1178           else
1179             {
1180               _dbus_warn ("Message %s doesn't have a service name: %s\n",
1181                           "ServiceCreated",
1182                           error.message);
1183               dbus_error_free (&error);
1184               goto out;
1185             }
1186         }
1187
1188       if (strcmp (service_name, activated_name) != 0)
1189         {
1190           _dbus_warn ("Expected to see service %s created, saw %s instead\n",
1191                       activated_name, service_name);
1192           dbus_free (service_name);
1193           goto out;
1194         }
1195       
1196       scd.skip_connection = connection;
1197       scd.failed = FALSE;
1198       scd.expected_service_name = service_name;
1199       bus_test_clients_foreach (check_service_created_foreach,
1200                                 &scd);
1201           
1202       dbus_free (service_name);
1203
1204       if (scd.failed)
1205         goto out;
1206           
1207       dbus_message_unref (message);
1208       message = pop_message_waiting_for_memory (connection);
1209       if (message == NULL)
1210         {
1211           _dbus_warn ("Expected a reply to %s, got nothing\n",
1212                       "ActivateService");
1213           goto out;
1214         }
1215     }
1216   else
1217     {
1218       warn_unexpected (connection, message, "ServiceCreated for the activated name");
1219       
1220       goto out;
1221     }
1222   
1223   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
1224     {
1225       warn_unexpected (connection, message, "reply to ActivateService");
1226
1227       goto out;
1228     }
1229
1230   activation_result = 0;
1231   if (!dbus_message_get_args (message, &error,
1232                               DBUS_TYPE_UINT32, &activation_result,
1233                               DBUS_TYPE_INVALID))
1234     {
1235       if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1236         {
1237           _dbus_warn ("Did not have activation result first argument to %s: %s\n",
1238                       "ActivateService", error.message);
1239           dbus_error_free (&error);
1240           goto out;
1241         }
1242
1243       dbus_error_free (&error);
1244     }
1245   else
1246     {
1247       if (activation_result == DBUS_ACTIVATION_REPLY_ACTIVATED)
1248         ; /* Good */
1249       else if (activation_result == DBUS_ACTIVATION_REPLY_ALREADY_ACTIVE)
1250         ; /* Good also */
1251       else
1252         {
1253           _dbus_warn ("Activation result was 0x%x, no good.\n",
1254                       activation_result);
1255           goto out;
1256         }
1257     }
1258
1259   dbus_message_unref (message);
1260   message = NULL;
1261       
1262   if (!check_no_leftovers (context))
1263     {
1264       _dbus_warn ("Messages were left over after verifying existent activation results\n");
1265       goto out;
1266     }
1267
1268   retval = TRUE;
1269   
1270  out:
1271   if (message)
1272     dbus_message_unref (message);
1273   
1274   return retval;
1275 }
1276
1277 static dbus_bool_t
1278 check_service_deactivated (BusContext     *context,
1279                            DBusConnection *connection,
1280                            const char     *activated_name,
1281                            const char     *base_service)
1282 {
1283   DBusMessage *message;
1284   dbus_bool_t retval;
1285   DBusError error;
1286   CheckServiceDeletedData csdd;
1287
1288   message = NULL;
1289   retval = FALSE;
1290   
1291   dbus_error_init (&error);
1292
1293   /* Now we are expecting ServiceDeleted messages for the base
1294    * service and the activated_name.  The base service
1295    * notification is required to come last.
1296    */
1297   csdd.expected_service_name = activated_name;
1298   csdd.failed = FALSE;
1299   bus_test_clients_foreach (check_service_deleted_foreach,
1300                             &csdd);      
1301
1302   if (csdd.failed)
1303     goto out;
1304       
1305   csdd.expected_service_name = base_service;
1306   csdd.failed = FALSE;
1307   bus_test_clients_foreach (check_service_deleted_foreach,
1308                             &csdd);
1309
1310   if (csdd.failed)
1311     goto out;
1312       
1313   if (!check_no_leftovers (context))
1314     {
1315       _dbus_warn ("Messages were left over after verifying results of service exiting\n");
1316       goto out;
1317     }
1318
1319   retval = TRUE;
1320   
1321  out:
1322   if (message)
1323     dbus_message_unref (message);
1324   
1325   return retval;
1326 }
1327
1328 static dbus_bool_t
1329 check_send_exit_to_service (BusContext     *context,
1330                             DBusConnection *connection,
1331                             const char     *service_name,
1332                             const char     *base_service)
1333 {
1334   dbus_bool_t got_error;
1335   DBusMessage *message;
1336   dbus_int32_t serial;
1337   dbus_bool_t retval;
1338   
1339   _dbus_verbose ("Sending exit message to the test service\n");
1340
1341   retval = FALSE;
1342   
1343   /* Kill off the test service by sending it a quit message */
1344   message = dbus_message_new_method_call ("org.freedesktop.TestSuite",
1345                                           "Exit",
1346                                           service_name);
1347       
1348   if (message == NULL)
1349     {
1350       /* Do this again; we still need the service to exit... */
1351       if (!check_send_exit_to_service (context, connection,
1352                                        service_name, base_service))
1353         goto out;
1354       
1355       return TRUE;
1356     }
1357       
1358   if (!dbus_connection_send (connection, message, &serial))
1359     {
1360       dbus_message_unref (message);
1361
1362       /* Do this again; we still need the service to exit... */
1363       if (!check_send_exit_to_service (context, connection,
1364                                        service_name, base_service))
1365         goto out;
1366       
1367       return TRUE;
1368     }
1369
1370   dbus_message_unref (message);
1371   message = NULL;
1372
1373   /* send message */
1374   bus_test_run_clients_loop (TRUE);
1375
1376   /* read it in and write it out to test service */
1377   bus_test_run_bus_loop (context, FALSE);
1378
1379   /* see if we got an error during message bus dispatching */
1380   bus_test_run_clients_loop (FALSE);
1381   message = dbus_connection_borrow_message (connection);
1382   got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
1383   if (message)
1384     {
1385       dbus_connection_return_message (connection, message);
1386       message = NULL;
1387     }
1388           
1389   if (!got_error)
1390     {
1391       /* If no error, wait for the test service to exit */
1392       block_connection_until_message_from_bus (context, connection);
1393               
1394       bus_test_run_everything (context);
1395     }
1396
1397   if (got_error)
1398     {
1399       message = pop_message_waiting_for_memory (connection);
1400       _dbus_assert (message != NULL);
1401
1402       if (!dbus_message_is_error (message,
1403                                   DBUS_ERROR_NO_MEMORY))
1404         {
1405           warn_unexpected (connection, message,
1406                            "a no memory error from asking test service to exit");
1407           goto out;
1408         }
1409
1410       _dbus_verbose ("Got error %s when asking test service to exit\n",
1411                      dbus_message_get_error_name (message));
1412
1413       /* Do this again; we still need the service to exit... */
1414       if (!check_send_exit_to_service (context, connection,
1415                                        service_name, base_service))
1416         goto out;
1417     }
1418   else
1419     {
1420       if (!check_service_deactivated (context, connection,
1421                                       service_name, base_service))
1422         goto out;
1423     }
1424
1425   retval = TRUE;
1426   
1427  out:
1428   if (message)
1429     dbus_message_unref (message);
1430   
1431   return retval;
1432 }
1433
1434 static dbus_bool_t
1435 check_got_error (BusContext     *context,
1436                  DBusConnection *connection,
1437                  const char     *first_error_name,
1438                  ...)
1439 {
1440   DBusMessage *message;
1441   dbus_bool_t retval;
1442   va_list ap;
1443   dbus_bool_t error_found;
1444   const char *error_name;
1445   
1446   retval = FALSE;
1447   
1448   message = pop_message_waiting_for_memory (connection);
1449   if (message == NULL)
1450     {
1451       _dbus_warn ("Did not get an expected error\n");
1452       goto out;
1453     }
1454
1455   if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1456     {
1457       warn_unexpected (connection, message, "an error");
1458
1459       goto out;
1460     }
1461
1462   error_found = FALSE;
1463
1464   va_start (ap, first_error_name);
1465   error_name = first_error_name;
1466   while (error_name != NULL)
1467     {
1468       if (dbus_message_is_error (message, error_name))
1469         {
1470           error_found = TRUE;
1471           break;
1472         }
1473       error_name = va_arg (ap, char*);
1474     }
1475   va_end (ap);
1476
1477   if (!error_found)
1478     {
1479       _dbus_warn ("Expected error %s or other, got %s instead\n",
1480                   first_error_name,
1481                   dbus_message_get_error_name (message));
1482       goto out;
1483     }
1484
1485   retval = TRUE;
1486   
1487  out:
1488   if (message)
1489     dbus_message_unref (message);
1490   
1491   return retval;
1492 }
1493           
1494 #define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService"
1495
1496 /* returns TRUE if the correct thing happens,
1497  * but the correct thing may include OOM errors.
1498  */
1499 static dbus_bool_t
1500 check_existent_service_activation (BusContext     *context,
1501                                    DBusConnection *connection)
1502 {
1503   DBusMessage *message;
1504   dbus_int32_t serial;
1505   dbus_bool_t retval;
1506   DBusError error;
1507   char *base_service;
1508
1509   base_service = NULL;
1510   
1511   dbus_error_init (&error);
1512   
1513   message = dbus_message_new_method_call (DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1514                                           "ActivateService",
1515                                           DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
1516
1517   if (message == NULL)
1518     return TRUE;
1519
1520   if (!dbus_message_append_args (message,
1521                                  DBUS_TYPE_STRING, EXISTENT_SERVICE_NAME,
1522                                  DBUS_TYPE_UINT32, 0,
1523                                  DBUS_TYPE_INVALID))
1524     {
1525       dbus_message_unref (message);
1526       return TRUE;
1527     }
1528   
1529   if (!dbus_connection_send (connection, message, &serial))
1530     {
1531       dbus_message_unref (message);
1532       return TRUE;
1533     }
1534
1535   dbus_message_unref (message);
1536   message = NULL;
1537
1538   bus_test_run_everything (context);
1539
1540   /* now wait for the message bus to hear back from the activated
1541    * service.
1542    */
1543   block_connection_until_message_from_bus (context, connection);
1544
1545   bus_test_run_everything (context);
1546
1547   if (!dbus_connection_get_is_connected (connection))
1548     {
1549       _dbus_verbose ("connection was disconnected\n");
1550       return TRUE;
1551     }
1552   
1553   retval = FALSE;
1554   
1555   message = pop_message_waiting_for_memory (connection);
1556   if (message == NULL)
1557     {
1558       _dbus_warn ("Did not receive any messages after %s %d on %p\n",
1559                   "ActivateService", serial, connection);
1560       goto out;
1561     }
1562
1563   verbose_message_received (connection, message);
1564   _dbus_verbose ("  (after sending %s)\n", "ActivateService");
1565
1566   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1567     {
1568       if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
1569         {
1570           _dbus_warn ("Message has wrong sender %s\n",
1571                       dbus_message_get_sender (message) ?
1572                       dbus_message_get_sender (message) : "(none)");
1573           goto out;
1574         }
1575       
1576       if (dbus_message_is_error (message,
1577                                  DBUS_ERROR_NO_MEMORY))
1578         {
1579           ; /* good, this is a valid response */
1580         }
1581       else if (dbus_message_is_error (message,
1582                                       DBUS_ERROR_SPAWN_CHILD_EXITED))
1583         {
1584           ; /* good, this is expected also */
1585         }
1586       else
1587         {
1588           _dbus_warn ("Did not expect error %s\n",
1589                       dbus_message_get_error_name (message));
1590           goto out;
1591         }
1592     }
1593   else
1594     {
1595       dbus_bool_t got_service_deleted;
1596       dbus_bool_t got_error;
1597       
1598       if (!check_base_service_activated (context, connection,
1599                                          message, &base_service))
1600         goto out;
1601
1602       dbus_message_unref (message);
1603       message = NULL;
1604
1605       /* We may need to block here for the test service to exit or finish up */
1606       block_connection_until_message_from_bus (context, connection);
1607       
1608       message = dbus_connection_borrow_message (connection);
1609       if (message == NULL)
1610         {
1611           _dbus_warn ("Did not receive any messages after base service creation notification\n");
1612           goto out;
1613         }
1614
1615       got_service_deleted = dbus_message_is_signal (message,
1616                                                     DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1617                                                     "ServiceDeleted");
1618       got_error = dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
1619       
1620       dbus_connection_return_message (connection, message);
1621       message = NULL;
1622
1623       if (got_error)
1624         {
1625           if (!check_got_error (context, connection,
1626                                 DBUS_ERROR_SPAWN_CHILD_EXITED,
1627                                 DBUS_ERROR_NO_MEMORY,
1628                                 NULL))
1629             goto out;
1630
1631           /* A service deleted should be coming along now after this error.
1632            * We can also get the error *after* the service deleted.
1633            */
1634           got_service_deleted = TRUE;
1635         }
1636       
1637       if (got_service_deleted)
1638         {
1639           /* The service started up and got a base address, but then
1640            * failed to register under EXISTENT_SERVICE_NAME
1641            */
1642           CheckServiceDeletedData csdd;
1643           
1644           csdd.expected_service_name = base_service;
1645           csdd.failed = FALSE;
1646           bus_test_clients_foreach (check_service_deleted_foreach,
1647                                     &csdd);
1648
1649           if (csdd.failed)
1650             goto out;
1651
1652           /* Now we should get an error about the service exiting
1653            * if we didn't get it before.
1654            */
1655           if (!got_error)
1656             {
1657               block_connection_until_message_from_bus (context, connection);
1658               
1659               /* and process everything again */
1660               bus_test_run_everything (context);
1661               
1662               if (!check_got_error (context, connection,
1663                                     DBUS_ERROR_SPAWN_CHILD_EXITED,
1664                                     NULL))
1665                 goto out;
1666             }
1667         }
1668       else
1669         {
1670           message = pop_message_waiting_for_memory (connection);
1671           if (message == NULL)
1672             {
1673               _dbus_warn ("Failed to pop message we just put back! should have been a ServiceCreated\n");
1674               goto out;
1675             }
1676           
1677           if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
1678                                         base_service, message))
1679             goto out;
1680           
1681           dbus_message_unref (message);
1682           message = NULL;
1683
1684
1685           if (!check_no_leftovers (context))
1686             {
1687               _dbus_warn ("Messages were left over after successful activation\n");
1688               goto out;
1689             }
1690
1691           if (!check_send_exit_to_service (context, connection,
1692                                            EXISTENT_SERVICE_NAME, base_service))
1693             goto out;
1694         }
1695     }
1696   
1697   retval = TRUE;
1698   
1699  out:
1700   if (message)
1701     dbus_message_unref (message);
1702
1703   if (base_service)
1704     dbus_free (base_service);
1705   
1706   return retval;
1707 }
1708
1709 /* returns TRUE if the correct thing happens,
1710  * but the correct thing may include OOM errors.
1711  */
1712 static dbus_bool_t
1713 check_segfault_service_activation (BusContext     *context,
1714                                    DBusConnection *connection)
1715 {
1716   DBusMessage *message;
1717   dbus_int32_t serial;
1718   dbus_bool_t retval;
1719   DBusError error;
1720   
1721   dbus_error_init (&error);
1722   
1723   message = dbus_message_new_method_call (DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
1724                                           "ActivateService",
1725                                           DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
1726
1727   if (message == NULL)
1728     return TRUE;
1729
1730   if (!dbus_message_append_args (message,
1731                                  DBUS_TYPE_STRING,
1732                                  "org.freedesktop.DBus.TestSuiteSegfaultService",
1733                                  DBUS_TYPE_UINT32, 0,
1734                                  DBUS_TYPE_INVALID))
1735     {
1736       dbus_message_unref (message);
1737       return TRUE;
1738     }
1739   
1740   if (!dbus_connection_send (connection, message, &serial))
1741     {
1742       dbus_message_unref (message);
1743       return TRUE;
1744     }
1745
1746   dbus_message_unref (message);
1747   message = NULL;
1748
1749   bus_test_run_everything (context);
1750   block_connection_until_message_from_bus (context, connection);
1751   bus_test_run_everything (context);
1752
1753   if (!dbus_connection_get_is_connected (connection))
1754     {
1755       _dbus_verbose ("connection was disconnected\n");
1756       return TRUE;
1757     }
1758   
1759   retval = FALSE;
1760   
1761   message = pop_message_waiting_for_memory (connection);
1762   if (message == NULL)
1763     {
1764       _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1765                   "ActivateService", serial, connection);
1766       goto out;
1767     }
1768
1769   verbose_message_received (connection, message);
1770
1771   if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1772     {
1773       if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
1774         {
1775           _dbus_warn ("Message has wrong sender %s\n",
1776                       dbus_message_get_sender (message) ?
1777                       dbus_message_get_sender (message) : "(none)");
1778           goto out;
1779         }
1780       
1781       if (dbus_message_is_error (message,
1782                                  DBUS_ERROR_NO_MEMORY))
1783         {
1784           ; /* good, this is a valid response */
1785         }
1786       else if (dbus_message_is_error (message,
1787                                       DBUS_ERROR_SPAWN_CHILD_SIGNALED))
1788         {
1789           ; /* good, this is expected also */
1790         }
1791       else
1792         {
1793           warn_unexpected (connection, message, "not this error");
1794
1795           goto out;
1796         }
1797     }
1798   else
1799     {
1800       _dbus_warn ("Did not expect to successfully activate segfault service\n");
1801       goto out;
1802     }
1803
1804   retval = TRUE;
1805   
1806  out:
1807   if (message)
1808     dbus_message_unref (message);
1809   
1810   return retval;
1811 }
1812
1813 typedef struct
1814 {
1815   Check1Func func;
1816   BusContext *context;
1817 } Check1Data;
1818
1819 static dbus_bool_t
1820 check_oom_check1_func (void *data)
1821 {
1822   Check1Data *d = data;
1823
1824   if (! (* d->func) (d->context))
1825     return FALSE;
1826   
1827   if (!check_no_leftovers (d->context))
1828     {
1829       _dbus_warn ("Messages were left over, should be covered by test suite\n");
1830       return FALSE;
1831     }
1832
1833   return TRUE;
1834 }
1835
1836 static void
1837 check1_try_iterations (BusContext *context,
1838                        const char *description,
1839                        Check1Func  func)
1840 {
1841   Check1Data d;
1842
1843   d.func = func;
1844   d.context = context;
1845
1846   if (!_dbus_test_oom_handling (description, check_oom_check1_func,
1847                                 &d))
1848     _dbus_assert_not_reached ("test failed");
1849 }
1850
1851 typedef struct
1852 {
1853   Check2Func func;
1854   BusContext *context;
1855   DBusConnection *connection;
1856 } Check2Data;
1857
1858 static dbus_bool_t
1859 check_oom_check2_func (void *data)
1860 {
1861   Check2Data *d = data;
1862
1863   if (! (* d->func) (d->context, d->connection))
1864     return FALSE;
1865   
1866   if (!check_no_leftovers (d->context))
1867     {
1868       _dbus_warn ("Messages were left over, should be covered by test suite");
1869       return FALSE;
1870     }
1871
1872   return TRUE;
1873 }
1874
1875 static void
1876 check2_try_iterations (BusContext     *context,
1877                        DBusConnection *connection,
1878                        const char     *description,
1879                        Check2Func      func)
1880 {
1881   Check2Data d;
1882
1883   d.func = func;
1884   d.context = context;
1885   d.connection = connection;
1886   
1887   if (!_dbus_test_oom_handling (description, check_oom_check2_func,
1888                                 &d))
1889     _dbus_assert_not_reached ("test failed");
1890 }
1891
1892 dbus_bool_t
1893 bus_dispatch_test (const DBusString *test_data_dir)
1894 {
1895   BusContext *context;
1896   DBusConnection *foo;
1897   DBusConnection *bar;
1898   DBusConnection *baz;
1899   DBusError error;
1900
1901   dbus_error_init (&error);
1902   
1903   context = bus_context_new_test (test_data_dir,
1904                                   "valid-config-files/debug-allow-all.conf");
1905   if (context == NULL)
1906     return FALSE;
1907   
1908   foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
1909   if (foo == NULL)
1910     _dbus_assert_not_reached ("could not alloc connection");
1911
1912   if (!bus_setup_debug_client (foo))
1913     _dbus_assert_not_reached ("could not set up connection");
1914
1915   if (!check_hello_message (context, foo))
1916     _dbus_assert_not_reached ("hello message failed");
1917   
1918   bar = dbus_connection_open ("debug-pipe:name=test-server", &error);
1919   if (bar == NULL)
1920     _dbus_assert_not_reached ("could not alloc connection");
1921
1922   if (!bus_setup_debug_client (bar))
1923     _dbus_assert_not_reached ("could not set up connection");
1924
1925   if (!check_hello_message (context, bar))
1926     _dbus_assert_not_reached ("hello message failed");
1927   
1928   baz = dbus_connection_open ("debug-pipe:name=test-server", &error);
1929   if (baz == NULL)
1930     _dbus_assert_not_reached ("could not alloc connection");
1931
1932   if (!bus_setup_debug_client (baz))
1933     _dbus_assert_not_reached ("could not set up connection");
1934
1935   if (!check_hello_message (context, baz))
1936     _dbus_assert_not_reached ("hello message failed");
1937
1938   if (!check_no_leftovers (context))
1939     {
1940       _dbus_warn ("Messages were left over after setting up initial connections");
1941       _dbus_assert_not_reached ("initial connection setup failed");
1942     }
1943   
1944   check1_try_iterations (context, "create_and_hello",
1945                          check_hello_connection);
1946   
1947   check2_try_iterations (context, foo, "nonexistent_service_activation",
1948                          check_nonexistent_service_activation);
1949
1950   check2_try_iterations (context, foo, "segfault_service_activation",
1951                          check_segfault_service_activation);
1952   
1953   check2_try_iterations (context, foo, "existent_service_activation",
1954                          check_existent_service_activation);
1955   
1956   _dbus_verbose ("Disconnecting foo, bar, and baz\n");
1957
1958   kill_client_connection_unchecked (foo);
1959   kill_client_connection_unchecked (bar);
1960   kill_client_connection_unchecked (baz);
1961
1962   bus_context_unref (context);
1963   
1964   return TRUE;
1965 }
1966
1967 dbus_bool_t
1968 bus_dispatch_sha1_test (const DBusString *test_data_dir)
1969 {
1970   BusContext *context;
1971   DBusConnection *foo;
1972   DBusError error;
1973
1974   dbus_error_init (&error);
1975   
1976   /* Test SHA1 authentication */
1977   _dbus_verbose ("Testing SHA1 context\n");
1978   
1979   context = bus_context_new_test (test_data_dir,
1980                                   "valid-config-files/debug-allow-all-sha1.conf");
1981   if (context == NULL)
1982     return FALSE;
1983
1984   foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
1985   if (foo == NULL)
1986     _dbus_assert_not_reached ("could not alloc connection");
1987
1988   if (!bus_setup_debug_client (foo))
1989     _dbus_assert_not_reached ("could not set up connection");
1990
1991   if (!check_hello_message (context, foo))
1992     _dbus_assert_not_reached ("hello message failed");
1993
1994   if (!check_no_leftovers (context))
1995     {
1996       _dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
1997       _dbus_assert_not_reached ("initial connection setup failed");
1998     }
1999   
2000   check1_try_iterations (context, "create_and_hello_sha1",
2001                          check_hello_connection);
2002
2003   kill_client_connection_unchecked (foo);
2004
2005   bus_context_unref (context);
2006
2007   return TRUE;
2008 }
2009
2010 #endif /* DBUS_BUILD_TESTS */