1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dispatch.c Message dispatcher
4 * Copyright (C) 2003 CodeFactory AB
5 * Copyright (C) 2003, 2004, 2005 Red Hat, Inc.
6 * Copyright (C) 2004 Imendio HB
8 * Licensed under the Academic Free License version 2.1
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.
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.
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
27 #include "connection.h"
30 #include "activation.h"
35 #include <dbus/dbus-internals.h>
39 send_one_message (DBusConnection *connection,
41 DBusConnection *sender,
42 DBusConnection *addressed_recipient,
44 BusTransaction *transaction,
47 if (!bus_context_check_security_policy (context, transaction,
53 return TRUE; /* silently don't send it */
55 if (!bus_transaction_send (transaction,
67 bus_dispatch_matches (BusTransaction *transaction,
68 DBusConnection *sender,
69 DBusConnection *addressed_recipient,
74 BusConnections *connections;
76 BusMatchmaker *matchmaker;
80 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
82 /* sender and recipient can both be NULL for the bus driver,
83 * or for signals with no particular recipient
86 _dbus_assert (sender == NULL || bus_connection_is_active (sender));
87 _dbus_assert (dbus_message_get_sender (message) != NULL);
89 connections = bus_transaction_get_connections (transaction);
91 dbus_error_init (&tmp_error);
92 context = bus_transaction_get_context (transaction);
93 matchmaker = bus_context_get_matchmaker (context);
96 if (!bus_matchmaker_get_recipients (matchmaker, connections,
97 sender, addressed_recipient, message,
104 link = _dbus_list_get_first_link (&recipients);
107 DBusConnection *dest;
111 if (!send_one_message (dest, context, sender, addressed_recipient,
112 message, transaction, &tmp_error))
115 link = _dbus_list_get_next_link (&recipients, link);
118 _dbus_list_clear (&recipients);
120 if (dbus_error_is_set (&tmp_error))
122 dbus_move_error (&tmp_error, error);
129 static DBusHandlerResult
130 bus_dispatch (DBusConnection *connection,
131 DBusMessage *message)
133 const char *sender, *service_name;
135 BusTransaction *transaction;
137 DBusHandlerResult result;
138 DBusConnection *addressed_recipient;
140 result = DBUS_HANDLER_RESULT_HANDLED;
143 addressed_recipient = NULL;
144 dbus_error_init (&error);
146 context = bus_connection_get_context (connection);
147 _dbus_assert (context != NULL);
149 /* If we can't even allocate an OOM error, we just go to sleep
152 while (!bus_connection_preallocate_oom_error (connection))
153 _dbus_wait_for_memory ();
155 /* Ref connection in case we disconnect it at some point in here */
156 dbus_connection_ref (connection);
158 service_name = dbus_message_get_destination (message);
160 #ifdef DBUS_ENABLE_VERBOSE_MODE
162 const char *interface_name, *member_name, *error_name;
164 interface_name = dbus_message_get_interface (message);
165 member_name = dbus_message_get_member (message);
166 error_name = dbus_message_get_error_name (message);
168 _dbus_verbose ("DISPATCH: %s %s %s to %s\n",
169 interface_name ? interface_name : "(no interface)",
170 member_name ? member_name : "(no member)",
171 error_name ? error_name : "(no error name)",
172 service_name ? service_name : "peer");
174 #endif /* DBUS_ENABLE_VERBOSE_MODE */
176 /* If service_name is NULL, if it's a signal we send it to all
177 * connections with a match rule. If it's not a signal, there
178 * are some special cases here but mostly we just bail out.
180 if (service_name == NULL)
182 if (dbus_message_is_signal (message,
183 DBUS_INTERFACE_LOCAL,
186 bus_connection_disconnected (connection);
190 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)
192 /* DBusConnection also handles some of these automatically, we leave
195 result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
200 /* Create our transaction */
201 transaction = bus_transaction_new (context);
202 if (transaction == NULL)
204 BUS_SET_OOM (&error);
208 /* Assign a sender to the message */
209 if (bus_connection_is_active (connection))
211 sender = bus_connection_get_name (connection);
212 _dbus_assert (sender != NULL);
214 if (!dbus_message_set_sender (message, sender))
216 BUS_SET_OOM (&error);
220 /* We need to refetch the service name here, because
221 * dbus_message_set_sender can cause the header to be
222 * reallocated, and thus the service_name pointer will become
225 service_name = dbus_message_get_destination (message);
229 strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */
231 if (!bus_context_check_security_policy (context, transaction,
232 connection, NULL, NULL, message, &error))
234 _dbus_verbose ("Security policy rejected message\n");
238 _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_DBUS);
239 if (!bus_driver_handle_message (connection, transaction, message, &error))
242 else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */
244 _dbus_verbose ("Received message from non-registered client. Disconnecting.\n");
245 dbus_connection_close (connection);
248 else if (service_name != NULL) /* route to named service */
250 DBusString service_string;
252 BusRegistry *registry;
254 _dbus_assert (service_name != NULL);
256 registry = bus_connection_get_registry (connection);
258 _dbus_string_init_const (&service_string, service_name);
259 service = bus_registry_lookup (registry, &service_string);
261 if (service == NULL && dbus_message_get_auto_start (message))
263 BusActivation *activation;
264 /* We can't do the security policy check here, since the addressed
265 * recipient service doesn't exist yet. We do it before sending the
266 * message after the service has been created.
268 activation = bus_connection_get_activation (connection);
270 if (!bus_activation_activate_service (activation, connection, transaction, TRUE,
271 message, service_name, &error))
273 _DBUS_ASSERT_ERROR_IS_SET (&error);
274 _dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name);
280 else if (service == NULL)
282 dbus_set_error (&error,
283 DBUS_ERROR_NAME_HAS_NO_OWNER,
284 "Name \"%s\" does not exist",
290 addressed_recipient = bus_service_get_primary_owners_connection (service);
291 _dbus_assert (addressed_recipient != NULL);
293 if (!bus_context_check_security_policy (context, transaction,
294 connection, addressed_recipient,
299 /* Dispatch the message */
300 if (!bus_transaction_send (transaction, addressed_recipient, message))
302 BUS_SET_OOM (&error);
308 /* Now match the messages against any match rules, which will send
309 * out signals and such. addressed_recipient may == NULL.
311 if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))
315 if (dbus_error_is_set (&error))
317 if (!dbus_connection_get_is_connected (connection))
319 /* If we disconnected it, we won't bother to send it any error
322 _dbus_verbose ("Not sending error to connection we disconnected\n");
324 else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
326 bus_connection_send_oom_error (connection, message);
328 /* cancel transaction due to OOM */
329 if (transaction != NULL)
331 bus_transaction_cancel_and_free (transaction);
337 /* Try to send the real error, if no mem to do that, send
340 _dbus_assert (transaction != NULL);
341 if (!bus_transaction_send_error_reply (transaction, connection,
344 bus_connection_send_oom_error (connection, message);
346 /* cancel transaction due to OOM */
347 if (transaction != NULL)
349 bus_transaction_cancel_and_free (transaction);
356 dbus_error_free (&error);
359 if (transaction != NULL)
361 bus_transaction_execute_and_free (transaction);
364 dbus_connection_unref (connection);
369 static DBusHandlerResult
370 bus_dispatch_message_filter (DBusConnection *connection,
371 DBusMessage *message,
374 return bus_dispatch (connection, message);
378 bus_dispatch_add_connection (DBusConnection *connection)
380 if (!dbus_connection_add_filter (connection,
381 bus_dispatch_message_filter,
389 bus_dispatch_remove_connection (DBusConnection *connection)
391 /* Here we tell the bus driver that we want to get off. */
392 bus_driver_remove_connection (connection);
394 dbus_connection_remove_filter (connection,
395 bus_dispatch_message_filter,
399 #ifdef DBUS_BUILD_TESTS
403 /* This is used to know whether we need to block in order to finish
404 * sending a message, or whether the initial dbus_connection_send()
405 * already flushed the queue.
407 #define SEND_PENDING(connection) (dbus_connection_has_messages_to_send (connection))
409 typedef dbus_bool_t (* Check1Func) (BusContext *context);
410 typedef dbus_bool_t (* Check2Func) (BusContext *context,
411 DBusConnection *connection);
413 static dbus_bool_t check_no_leftovers (BusContext *context);
416 block_connection_until_message_from_bus (BusContext *context,
417 DBusConnection *connection,
418 const char *what_is_expected)
420 _dbus_verbose ("expecting: %s\n", what_is_expected);
422 while (dbus_connection_get_dispatch_status (connection) ==
423 DBUS_DISPATCH_COMPLETE &&
424 dbus_connection_get_is_connected (connection))
426 bus_test_run_bus_loop (context, TRUE);
427 bus_test_run_clients_loop (FALSE);
432 spin_connection_until_authenticated (BusContext *context,
433 DBusConnection *connection)
435 _dbus_verbose ("Spinning to auth connection %p\n", connection);
436 while (!dbus_connection_get_is_authenticated (connection) &&
437 dbus_connection_get_is_connected (connection))
439 bus_test_run_bus_loop (context, FALSE);
440 bus_test_run_clients_loop (FALSE);
442 _dbus_verbose (" ... done spinning to auth connection %p\n", connection);
445 /* compensate for fact that pop_message() can return #NULL due to OOM */
447 pop_message_waiting_for_memory (DBusConnection *connection)
449 while (dbus_connection_get_dispatch_status (connection) ==
450 DBUS_DISPATCH_NEED_MEMORY)
451 _dbus_wait_for_memory ();
453 return dbus_connection_pop_message (connection);
457 borrow_message_waiting_for_memory (DBusConnection *connection)
459 while (dbus_connection_get_dispatch_status (connection) ==
460 DBUS_DISPATCH_NEED_MEMORY)
461 _dbus_wait_for_memory ();
463 return dbus_connection_borrow_message (connection);
467 warn_unexpected_real (DBusConnection *connection,
468 DBusMessage *message,
469 const char *expected,
470 const char *function,
474 _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n",
476 dbus_message_get_interface (message) ?
477 dbus_message_get_interface (message) : "(unset)",
478 dbus_message_get_member (message) ?
479 dbus_message_get_member (message) : "(unset)",
480 dbus_message_get_error_name (message) ?
481 dbus_message_get_error_name (message) : "(unset)",
485 _dbus_warn ("%s:%d received no message on %p, expecting %s\n",
486 function, line, connection, expected);
489 #define warn_unexpected(connection, message, expected) \
490 warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__)
493 verbose_message_received (DBusConnection *connection,
494 DBusMessage *message)
496 _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n",
497 dbus_message_get_interface (message) ?
498 dbus_message_get_interface (message) : "(unset)",
499 dbus_message_get_member (message) ?
500 dbus_message_get_member (message) : "(unset)",
501 dbus_message_get_error_name (message) ?
502 dbus_message_get_error_name (message) : "(unset)",
515 ServiceInfoKind expected_kind;
516 const char *expected_service_name;
518 DBusConnection *skip_connection;
519 } CheckServiceOwnerChangedData;
522 check_service_owner_changed_foreach (DBusConnection *connection,
525 CheckServiceOwnerChangedData *d = data;
526 DBusMessage *message;
528 const char *service_name, *old_owner, *new_owner;
530 if (d->expected_kind == SERVICE_CREATED
531 && connection == d->skip_connection)
534 dbus_error_init (&error);
537 message = pop_message_waiting_for_memory (connection);
540 _dbus_warn ("Did not receive a message on %p, expecting %s\n",
541 connection, "NameOwnerChanged");
544 else if (!dbus_message_is_signal (message,
548 warn_unexpected (connection, message, "NameOwnerChanged");
554 reget_service_info_data:
559 dbus_message_get_args (message, &error,
560 DBUS_TYPE_STRING, &service_name,
561 DBUS_TYPE_STRING, &old_owner,
562 DBUS_TYPE_STRING, &new_owner,
565 if (dbus_error_is_set (&error))
567 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
569 dbus_error_free (&error);
570 _dbus_wait_for_memory ();
571 goto reget_service_info_data;
575 _dbus_warn ("Did not get the expected arguments\n");
580 if ((d->expected_kind == SERVICE_CREATED && ( old_owner[0] || !new_owner[0]))
581 || (d->expected_kind == OWNER_CHANGED && (!old_owner[0] || !new_owner[0]))
582 || (d->expected_kind == SERVICE_DELETED && (!old_owner[0] || new_owner[0])))
584 _dbus_warn ("inconsistent NameOwnerChanged arguments\n");
588 if (strcmp (service_name, d->expected_service_name) != 0)
590 _dbus_warn ("expected info on service %s, got info on %s\n",
591 d->expected_service_name,
596 if (*service_name == ':' && new_owner[0]
597 && strcmp (service_name, new_owner) != 0)
599 _dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",
600 service_name, old_owner, new_owner);
608 dbus_error_free (&error);
611 dbus_message_unref (message);
618 kill_client_connection (BusContext *context,
619 DBusConnection *connection)
623 CheckServiceOwnerChangedData socd;
625 _dbus_verbose ("killing connection %p\n", connection);
627 s = dbus_bus_get_unique_name (connection);
628 _dbus_assert (s != NULL);
630 while ((base_service = _dbus_strdup (s)) == NULL)
631 _dbus_wait_for_memory ();
633 dbus_connection_ref (connection);
635 /* kick in the disconnect handler that unrefs the connection */
636 dbus_connection_close (connection);
638 bus_test_run_everything (context);
640 _dbus_assert (bus_test_client_listed (connection));
642 /* Run disconnect handler in test.c */
643 if (bus_connection_dispatch_one_message (connection))
644 _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
646 _dbus_assert (!dbus_connection_get_is_connected (connection));
647 dbus_connection_unref (connection);
649 _dbus_assert (!bus_test_client_listed (connection));
651 socd.expected_kind = SERVICE_DELETED;
652 socd.expected_service_name = base_service;
654 socd.skip_connection = NULL;
656 bus_test_clients_foreach (check_service_owner_changed_foreach,
659 dbus_free (base_service);
662 _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");
664 if (!check_no_leftovers (context))
665 _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
669 kill_client_connection_unchecked (DBusConnection *connection)
671 /* This kills the connection without expecting it to affect
672 * the rest of the bus.
674 _dbus_verbose ("Unchecked kill of connection %p\n", connection);
676 dbus_connection_ref (connection);
677 dbus_connection_close (connection);
678 /* dispatching disconnect handler will unref once */
679 if (bus_connection_dispatch_one_message (connection))
680 _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
682 _dbus_assert (!bus_test_client_listed (connection));
683 dbus_connection_unref (connection);
689 } CheckNoMessagesData;
692 check_no_messages_foreach (DBusConnection *connection,
695 CheckNoMessagesData *d = data;
696 DBusMessage *message;
698 message = pop_message_waiting_for_memory (connection);
701 warn_unexpected (connection, message, "no messages");
707 dbus_message_unref (message);
712 check_no_leftovers (BusContext *context)
714 CheckNoMessagesData nmd;
717 bus_test_clients_foreach (check_no_messages_foreach,
722 _dbus_verbose ("%s: leftover message found\n",
723 _DBUS_FUNCTION_NAME);
730 /* returns TRUE if the correct thing happens,
731 * but the correct thing may include OOM errors.
734 check_hello_message (BusContext *context,
735 DBusConnection *connection)
737 DBusMessage *message;
738 DBusMessage *name_message;
739 dbus_uint32_t serial;
743 const char *acquired;
746 dbus_error_init (&error);
752 _dbus_verbose ("check_hello_message for %p\n", connection);
754 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
762 dbus_connection_ref (connection); /* because we may get disconnected */
764 if (!dbus_connection_send (connection, message, &serial))
766 dbus_message_unref (message);
767 dbus_connection_unref (connection);
771 _dbus_assert (dbus_message_has_signature (message, ""));
773 dbus_message_unref (message);
776 if (!dbus_connection_get_is_connected (connection))
778 _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
780 dbus_connection_unref (connection);
785 /* send our message */
786 bus_test_run_clients_loop (SEND_PENDING (connection));
788 if (!dbus_connection_get_is_connected (connection))
790 _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
792 dbus_connection_unref (connection);
797 block_connection_until_message_from_bus (context, connection, "reply to Hello");
799 if (!dbus_connection_get_is_connected (connection))
801 _dbus_verbose ("connection was disconnected (presumably auth failed)\n");
803 dbus_connection_unref (connection);
808 dbus_connection_unref (connection);
810 message = pop_message_waiting_for_memory (connection);
813 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
814 "Hello", serial, connection);
818 verbose_message_received (connection, message);
820 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
822 _dbus_warn ("Message has wrong sender %s\n",
823 dbus_message_get_sender (message) ?
824 dbus_message_get_sender (message) : "(none)");
828 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
830 if (dbus_message_is_error (message,
831 DBUS_ERROR_NO_MEMORY))
833 ; /* good, this is a valid response */
837 warn_unexpected (connection, message, "not this error");
844 CheckServiceOwnerChangedData socd;
846 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
848 ; /* good, expected */
852 warn_unexpected (connection, message, "method return for Hello");
857 retry_get_hello_name:
858 if (!dbus_message_get_args (message, &error,
859 DBUS_TYPE_STRING, &name,
862 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
864 _dbus_verbose ("no memory to get service name arg from hello\n");
865 dbus_error_free (&error);
866 _dbus_wait_for_memory ();
867 goto retry_get_hello_name;
871 _dbus_assert (dbus_error_is_set (&error));
872 _dbus_warn ("Did not get the expected single string argument to hello\n");
877 _dbus_verbose ("Got hello name: %s\n", name);
879 while (!dbus_bus_set_unique_name (connection, name))
880 _dbus_wait_for_memory ();
882 socd.expected_kind = SERVICE_CREATED;
883 socd.expected_service_name = name;
885 socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */
886 bus_test_clients_foreach (check_service_owner_changed_foreach,
892 name_message = message;
893 /* Client should also have gotten ServiceAcquired */
895 message = pop_message_waiting_for_memory (connection);
898 _dbus_warn ("Expecting %s, got nothing\n",
902 if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
905 _dbus_warn ("Expecting %s, got smthg else\n",
910 retry_get_acquired_name:
911 if (!dbus_message_get_args (message, &error,
912 DBUS_TYPE_STRING, &acquired,
915 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
917 _dbus_verbose ("no memory to get service name arg from acquired\n");
918 dbus_error_free (&error);
919 _dbus_wait_for_memory ();
920 goto retry_get_acquired_name;
924 _dbus_assert (dbus_error_is_set (&error));
925 _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");
930 _dbus_verbose ("Got acquired name: %s\n", acquired);
932 if (strcmp (acquired, name) != 0)
934 _dbus_warn ("Acquired name is %s but expected %s\n",
941 if (!check_no_leftovers (context))
947 _dbus_verbose ("ending %s retval = %d\n", _DBUS_FUNCTION_NAME, retval);
949 dbus_error_free (&error);
952 dbus_message_unref (message);
955 dbus_message_unref (name_message);
960 /* returns TRUE if the correct thing happens,
961 * but the correct thing may include OOM errors.
964 check_double_hello_message (BusContext *context,
965 DBusConnection *connection)
967 DBusMessage *message;
968 dbus_uint32_t serial;
973 dbus_error_init (&error);
976 _dbus_verbose ("check_double_hello_message for %p\n", connection);
978 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
986 if (!dbus_connection_send (connection, message, &serial))
988 dbus_message_unref (message);
992 dbus_message_unref (message);
995 /* send our message */
996 bus_test_run_clients_loop (SEND_PENDING (connection));
998 dbus_connection_ref (connection); /* because we may get disconnected */
999 block_connection_until_message_from_bus (context, connection, "reply to Hello");
1001 if (!dbus_connection_get_is_connected (connection))
1003 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1005 dbus_connection_unref (connection);
1010 dbus_connection_unref (connection);
1012 message = pop_message_waiting_for_memory (connection);
1013 if (message == NULL)
1015 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1016 "Hello", serial, connection);
1020 verbose_message_received (connection, message);
1022 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1024 _dbus_warn ("Message has wrong sender %s\n",
1025 dbus_message_get_sender (message) ?
1026 dbus_message_get_sender (message) : "(none)");
1030 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1032 warn_unexpected (connection, message, "method return for Hello");
1036 if (!check_no_leftovers (context))
1042 dbus_error_free (&error);
1045 dbus_message_unref (message);
1050 /* returns TRUE if the correct thing happens,
1051 * but the correct thing may include OOM errors.
1054 check_get_connection_unix_user (BusContext *context,
1055 DBusConnection *connection)
1057 DBusMessage *message;
1058 dbus_uint32_t serial;
1061 const char *base_service_name;
1065 dbus_error_init (&error);
1068 _dbus_verbose ("check_get_connection_unix_user for %p\n", connection);
1070 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1072 DBUS_INTERFACE_DBUS,
1073 "GetConnectionUnixUser");
1075 if (message == NULL)
1078 base_service_name = dbus_bus_get_unique_name (connection);
1080 if (!dbus_message_append_args (message,
1081 DBUS_TYPE_STRING, &base_service_name,
1084 dbus_message_unref (message);
1088 if (!dbus_connection_send (connection, message, &serial))
1090 dbus_message_unref (message);
1094 /* send our message */
1095 bus_test_run_clients_loop (SEND_PENDING (connection));
1097 dbus_message_unref (message);
1100 dbus_connection_ref (connection); /* because we may get disconnected */
1101 block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixUser");
1103 if (!dbus_connection_get_is_connected (connection))
1105 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1107 dbus_connection_unref (connection);
1112 dbus_connection_unref (connection);
1114 message = pop_message_waiting_for_memory (connection);
1115 if (message == NULL)
1117 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1118 "GetConnectionUnixUser", serial, connection);
1122 verbose_message_received (connection, message);
1124 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1126 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
1128 ; /* good, this is a valid response */
1132 warn_unexpected (connection, message, "not this error");
1139 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1141 ; /* good, expected */
1145 warn_unexpected (connection, message,
1146 "method_return for GetConnectionUnixUser");
1153 if (!dbus_message_get_args (message, &error,
1154 DBUS_TYPE_UINT32, &uid,
1157 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1159 _dbus_verbose ("no memory to get uid by GetConnectionUnixUser\n");
1160 dbus_error_free (&error);
1161 _dbus_wait_for_memory ();
1162 goto retry_get_property;
1166 _dbus_assert (dbus_error_is_set (&error));
1167 _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixUser\n");
1173 if (!check_no_leftovers (context))
1179 dbus_error_free (&error);
1182 dbus_message_unref (message);
1187 /* returns TRUE if the correct thing happens,
1188 * but the correct thing may include OOM errors.
1191 check_get_connection_unix_process_id (BusContext *context,
1192 DBusConnection *connection)
1194 DBusMessage *message;
1195 dbus_uint32_t serial;
1198 const char *base_service_name;
1202 dbus_error_init (&error);
1205 _dbus_verbose ("check_get_connection_unix_process_id for %p\n", connection);
1207 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1209 DBUS_INTERFACE_DBUS,
1210 "GetConnectionUnixProcessID");
1212 if (message == NULL)
1215 base_service_name = dbus_bus_get_unique_name (connection);
1217 if (!dbus_message_append_args (message,
1218 DBUS_TYPE_STRING, &base_service_name,
1221 dbus_message_unref (message);
1225 if (!dbus_connection_send (connection, message, &serial))
1227 dbus_message_unref (message);
1231 /* send our message */
1232 bus_test_run_clients_loop (SEND_PENDING (connection));
1234 dbus_message_unref (message);
1237 dbus_connection_ref (connection); /* because we may get disconnected */
1238 block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixProcessID");
1240 if (!dbus_connection_get_is_connected (connection))
1242 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1244 dbus_connection_unref (connection);
1249 dbus_connection_unref (connection);
1251 message = pop_message_waiting_for_memory (connection);
1252 if (message == NULL)
1254 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1255 "GetConnectionUnixProcessID", serial, connection);
1259 verbose_message_received (connection, message);
1261 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1263 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
1265 ; /* good, this is a valid response */
1269 warn_unexpected (connection, message, "not this error");
1276 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1278 ; /* good, expected */
1282 warn_unexpected (connection, message,
1283 "method_return for GetConnectionUnixProcessID");
1290 if (!dbus_message_get_args (message, &error,
1291 DBUS_TYPE_UINT32, &pid,
1294 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1296 _dbus_verbose ("no memory to get pid by GetConnectionUnixProcessID\n");
1297 dbus_error_free (&error);
1298 _dbus_wait_for_memory ();
1299 goto retry_get_property;
1303 _dbus_assert (dbus_error_is_set (&error));
1304 _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixProcessID\n");
1309 /* test if returned pid is the same as our own pid
1311 * @todo It would probably be good to restructure the tests
1312 * in a way so our parent is the bus that we're testing
1313 * cause then we can test that the pid returned matches
1316 if (pid != (dbus_uint32_t) _dbus_getpid ())
1318 _dbus_assert (dbus_error_is_set (&error));
1319 _dbus_warn ("Result from GetConnectionUnixProcessID is not our own pid\n");
1325 if (!check_no_leftovers (context))
1331 dbus_error_free (&error);
1334 dbus_message_unref (message);
1339 /* returns TRUE if the correct thing happens,
1340 * but the correct thing may include OOM errors.
1343 check_add_match_all (BusContext *context,
1344 DBusConnection *connection)
1346 DBusMessage *message;
1348 dbus_uint32_t serial;
1350 const char *empty = "";
1353 dbus_error_init (&error);
1356 _dbus_verbose ("check_add_match_all for %p\n", connection);
1358 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1360 DBUS_INTERFACE_DBUS,
1363 if (message == NULL)
1366 /* empty string match rule matches everything */
1367 if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &empty,
1370 dbus_message_unref (message);
1374 if (!dbus_connection_send (connection, message, &serial))
1376 dbus_message_unref (message);
1380 dbus_message_unref (message);
1383 dbus_connection_ref (connection); /* because we may get disconnected */
1385 /* send our message */
1386 bus_test_run_clients_loop (SEND_PENDING (connection));
1388 if (!dbus_connection_get_is_connected (connection))
1390 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1392 dbus_connection_unref (connection);
1397 block_connection_until_message_from_bus (context, connection, "reply to AddMatch");
1399 if (!dbus_connection_get_is_connected (connection))
1401 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1403 dbus_connection_unref (connection);
1408 dbus_connection_unref (connection);
1410 message = pop_message_waiting_for_memory (connection);
1411 if (message == NULL)
1413 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1414 "AddMatch", serial, connection);
1418 verbose_message_received (connection, message);
1420 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1422 _dbus_warn ("Message has wrong sender %s\n",
1423 dbus_message_get_sender (message) ?
1424 dbus_message_get_sender (message) : "(none)");
1428 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1430 if (dbus_message_is_error (message,
1431 DBUS_ERROR_NO_MEMORY))
1433 ; /* good, this is a valid response */
1437 warn_unexpected (connection, message, "not this error");
1444 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1446 ; /* good, expected */
1447 _dbus_assert (dbus_message_get_reply_serial (message) == serial);
1451 warn_unexpected (connection, message, "method return for AddMatch");
1457 if (!check_no_leftovers (context))
1463 dbus_error_free (&error);
1466 dbus_message_unref (message);
1471 /* returns TRUE if the correct thing happens,
1472 * but the correct thing may include OOM errors.
1475 check_hello_connection (BusContext *context)
1477 DBusConnection *connection;
1480 dbus_error_init (&error);
1482 connection = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
1483 if (connection == NULL)
1485 _DBUS_ASSERT_ERROR_IS_SET (&error);
1486 dbus_error_free (&error);
1490 if (!bus_setup_debug_client (connection))
1492 dbus_connection_close (connection);
1493 dbus_connection_unref (connection);
1497 spin_connection_until_authenticated (context, connection);
1499 if (!check_hello_message (context, connection))
1502 if (dbus_bus_get_unique_name (connection) == NULL)
1504 /* We didn't successfully register, so we can't
1505 * do the usual kill_client_connection() checks
1507 kill_client_connection_unchecked (connection);
1511 if (!check_add_match_all (context, connection))
1514 kill_client_connection (context, connection);
1520 #define NONEXISTENT_SERVICE_NAME "test.this.service.does.not.exist.ewuoiurjdfxcvn"
1522 /* returns TRUE if the correct thing happens,
1523 * but the correct thing may include OOM errors.
1526 check_nonexistent_service_no_auto_start (BusContext *context,
1527 DBusConnection *connection)
1529 DBusMessage *message;
1530 dbus_uint32_t serial;
1532 const char *nonexistent = NONEXISTENT_SERVICE_NAME;
1533 dbus_uint32_t flags;
1535 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1537 DBUS_INTERFACE_DBUS,
1538 "StartServiceByName");
1540 if (message == NULL)
1543 dbus_message_set_auto_start (message, FALSE);
1546 if (!dbus_message_append_args (message,
1547 DBUS_TYPE_STRING, &nonexistent,
1548 DBUS_TYPE_UINT32, &flags,
1551 dbus_message_unref (message);
1555 if (!dbus_connection_send (connection, message, &serial))
1557 dbus_message_unref (message);
1561 dbus_message_unref (message);
1564 bus_test_run_everything (context);
1565 block_connection_until_message_from_bus (context, connection, "reply to ActivateService on nonexistent");
1566 bus_test_run_everything (context);
1568 if (!dbus_connection_get_is_connected (connection))
1570 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1576 message = pop_message_waiting_for_memory (connection);
1577 if (message == NULL)
1579 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1580 "StartServiceByName", serial, connection);
1584 verbose_message_received (connection, message);
1586 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1588 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1590 _dbus_warn ("Message has wrong sender %s\n",
1591 dbus_message_get_sender (message) ?
1592 dbus_message_get_sender (message) : "(none)");
1596 if (dbus_message_is_error (message,
1597 DBUS_ERROR_NO_MEMORY))
1599 ; /* good, this is a valid response */
1601 else if (dbus_message_is_error (message,
1602 DBUS_ERROR_SERVICE_UNKNOWN))
1604 ; /* good, this is expected also */
1608 warn_unexpected (connection, message, "not this error");
1614 _dbus_warn ("Did not expect to successfully activate %s\n",
1615 NONEXISTENT_SERVICE_NAME);
1623 dbus_message_unref (message);
1628 /* returns TRUE if the correct thing happens,
1629 * but the correct thing may include OOM errors.
1632 check_nonexistent_service_auto_start (BusContext *context,
1633 DBusConnection *connection)
1635 DBusMessage *message;
1636 dbus_uint32_t serial;
1639 message = dbus_message_new_method_call (NONEXISTENT_SERVICE_NAME,
1640 "/org/freedesktop/TestSuite",
1641 "org.freedesktop.TestSuite",
1644 if (message == NULL)
1647 if (!dbus_connection_send (connection, message, &serial))
1649 dbus_message_unref (message);
1653 dbus_message_unref (message);
1656 bus_test_run_everything (context);
1657 block_connection_until_message_from_bus (context, connection, "reply to Echo");
1658 bus_test_run_everything (context);
1660 if (!dbus_connection_get_is_connected (connection))
1662 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1668 message = pop_message_waiting_for_memory (connection);
1670 if (message == NULL)
1672 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1673 "Echo message (auto activation)", serial, connection);
1677 verbose_message_received (connection, message);
1679 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1681 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
1683 _dbus_warn ("Message has wrong sender %s\n",
1684 dbus_message_get_sender (message) ?
1685 dbus_message_get_sender (message) : "(none)");
1689 if (dbus_message_is_error (message,
1690 DBUS_ERROR_NO_MEMORY))
1692 ; /* good, this is a valid response */
1694 else if (dbus_message_is_error (message,
1695 DBUS_ERROR_SERVICE_UNKNOWN))
1697 ; /* good, this is expected also */
1701 warn_unexpected (connection, message, "not this error");
1707 _dbus_warn ("Did not expect to successfully activate %s\n",
1708 NONEXISTENT_SERVICE_NAME);
1716 dbus_message_unref (message);
1722 check_base_service_activated (BusContext *context,
1723 DBusConnection *connection,
1724 DBusMessage *initial_message,
1725 const char **base_service_p)
1727 DBusMessage *message;
1730 const char *base_service, *base_service_from_bus, *old_owner;
1734 dbus_error_init (&error);
1735 base_service = NULL;
1737 base_service_from_bus = NULL;
1739 message = initial_message;
1740 dbus_message_ref (message);
1742 if (dbus_message_is_signal (message,
1743 DBUS_INTERFACE_DBUS,
1744 "NameOwnerChanged"))
1746 CheckServiceOwnerChangedData socd;
1748 reget_service_name_arg:
1749 base_service = NULL;
1751 base_service_from_bus = NULL;
1753 if (!dbus_message_get_args (message, &error,
1754 DBUS_TYPE_STRING, &base_service,
1755 DBUS_TYPE_STRING, &old_owner,
1756 DBUS_TYPE_STRING, &base_service_from_bus,
1759 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1761 dbus_error_free (&error);
1762 _dbus_wait_for_memory ();
1763 goto reget_service_name_arg;
1767 _dbus_warn ("Message %s doesn't have a service name: %s\n",
1768 "NameOwnerChanged (creation)",
1774 if (*base_service != ':')
1776 _dbus_warn ("Expected base service activation, got \"%s\" instead\n",
1781 if (strcmp (base_service, base_service_from_bus) != 0)
1783 _dbus_warn ("Expected base service activation, got \"%s\" instead with owner \"%s\"\n",
1784 base_service, base_service_from_bus);
1790 _dbus_warn ("Received an old_owner argument during base service activation, \"%s\"\n",
1795 socd.expected_kind = SERVICE_CREATED;
1796 socd.expected_service_name = base_service;
1797 socd.failed = FALSE;
1798 socd.skip_connection = connection;
1799 bus_test_clients_foreach (check_service_owner_changed_foreach,
1807 warn_unexpected (connection, message, "NameOwnerChanged (creation) for base service");
1813 *base_service_p = base_service;
1819 dbus_message_unref (message);
1820 dbus_error_free (&error);
1826 check_service_activated (BusContext *context,
1827 DBusConnection *connection,
1828 const char *activated_name,
1829 const char *base_service_name,
1830 DBusMessage *initial_message)
1832 DBusMessage *message;
1835 dbus_uint32_t activation_result;
1839 dbus_error_init (&error);
1841 message = initial_message;
1842 dbus_message_ref (message);
1844 if (dbus_message_is_signal (message,
1845 DBUS_INTERFACE_DBUS,
1846 "NameOwnerChanged"))
1848 CheckServiceOwnerChangedData socd;
1849 const char *service_name, *base_service_from_bus, *old_owner;
1851 reget_service_name_arg:
1852 service_name = NULL;
1854 base_service_from_bus = NULL;
1856 if (!dbus_message_get_args (message, &error,
1857 DBUS_TYPE_STRING, &service_name,
1858 DBUS_TYPE_STRING, &old_owner,
1859 DBUS_TYPE_STRING, &base_service_from_bus,
1862 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1864 dbus_error_free (&error);
1865 _dbus_wait_for_memory ();
1866 goto reget_service_name_arg;
1870 _dbus_warn ("Message %s doesn't have a service name: %s\n",
1871 "NameOwnerChanged (creation)",
1877 if (strcmp (service_name, activated_name) != 0)
1879 _dbus_warn ("Expected to see service %s created, saw %s instead\n",
1880 activated_name, service_name);
1884 if (strcmp (base_service_name, base_service_from_bus) != 0)
1886 _dbus_warn ("NameOwnerChanged reports wrong base service: %s owner, expected %s instead\n",
1887 base_service_from_bus, base_service_name);
1893 _dbus_warn ("expected a %s, got a %s\n",
1894 "NameOwnerChanged (creation)",
1895 "NameOwnerChanged (change)");
1899 socd.expected_kind = SERVICE_CREATED;
1900 socd.skip_connection = connection;
1901 socd.failed = FALSE;
1902 socd.expected_service_name = service_name;
1903 bus_test_clients_foreach (check_service_owner_changed_foreach,
1909 dbus_message_unref (message);
1910 service_name = NULL;
1912 base_service_from_bus = NULL;
1914 message = pop_message_waiting_for_memory (connection);
1915 if (message == NULL)
1917 _dbus_warn ("Expected a reply to %s, got nothing\n",
1918 "StartServiceByName");
1924 warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
1929 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
1931 warn_unexpected (connection, message, "reply to StartServiceByName");
1936 activation_result = 0;
1937 if (!dbus_message_get_args (message, &error,
1938 DBUS_TYPE_UINT32, &activation_result,
1941 if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1943 _dbus_warn ("Did not have activation result first argument to %s: %s\n",
1944 "StartServiceByName", error.message);
1948 dbus_error_free (&error);
1952 if (activation_result == DBUS_START_REPLY_SUCCESS)
1954 else if (activation_result == DBUS_START_REPLY_ALREADY_RUNNING)
1958 _dbus_warn ("Activation result was %u, no good.\n",
1964 dbus_message_unref (message);
1967 if (!check_no_leftovers (context))
1969 _dbus_warn ("Messages were left over after verifying existent activation results\n");
1977 dbus_message_unref (message);
1978 dbus_error_free (&error);
1984 check_service_auto_activated (BusContext *context,
1985 DBusConnection *connection,
1986 const char *activated_name,
1987 const char *base_service_name,
1988 DBusMessage *initial_message)
1990 DBusMessage *message;
1996 dbus_error_init (&error);
1998 message = initial_message;
1999 dbus_message_ref (message);
2001 if (dbus_message_is_signal (message,
2002 DBUS_INTERFACE_DBUS,
2003 "NameOwnerChanged"))
2005 const char *service_name;
2006 CheckServiceOwnerChangedData socd;
2008 reget_service_name_arg:
2009 if (!dbus_message_get_args (message, &error,
2010 DBUS_TYPE_STRING, &service_name,
2013 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
2015 dbus_error_free (&error);
2016 _dbus_wait_for_memory ();
2017 goto reget_service_name_arg;
2021 _dbus_warn ("Message %s doesn't have a service name: %s\n",
2024 dbus_error_free (&error);
2029 if (strcmp (service_name, activated_name) != 0)
2031 _dbus_warn ("Expected to see service %s created, saw %s instead\n",
2032 activated_name, service_name);
2036 socd.expected_kind = SERVICE_CREATED;
2037 socd.expected_service_name = service_name;
2038 socd.failed = FALSE;
2039 socd.skip_connection = connection;
2040 bus_test_clients_foreach (check_service_owner_changed_foreach,
2046 /* Note that this differs from regular activation in that we don't get a
2047 * reply to ActivateService here.
2050 dbus_message_unref (message);
2052 service_name = NULL;
2056 warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
2065 dbus_message_unref (message);
2071 check_service_deactivated (BusContext *context,
2072 DBusConnection *connection,
2073 const char *activated_name,
2074 const char *base_service)
2077 CheckServiceOwnerChangedData socd;
2081 /* Now we are expecting ServiceOwnerChanged (deletion) messages for the base
2082 * service and the activated_name. The base service
2083 * notification is required to come last.
2085 socd.expected_kind = SERVICE_DELETED;
2086 socd.expected_service_name = activated_name;
2087 socd.failed = FALSE;
2088 socd.skip_connection = NULL;
2089 bus_test_clients_foreach (check_service_owner_changed_foreach,
2095 socd.expected_kind = SERVICE_DELETED;
2096 socd.expected_service_name = base_service;
2097 socd.failed = FALSE;
2098 socd.skip_connection = NULL;
2099 bus_test_clients_foreach (check_service_owner_changed_foreach,
2112 check_send_exit_to_service (BusContext *context,
2113 DBusConnection *connection,
2114 const char *service_name,
2115 const char *base_service)
2117 dbus_bool_t got_error;
2118 DBusMessage *message;
2119 dbus_uint32_t serial;
2122 _dbus_verbose ("Sending exit message to the test service\n");
2126 /* Kill off the test service by sending it a quit message */
2127 message = dbus_message_new_method_call (service_name,
2128 "/org/freedesktop/TestSuite",
2129 "org.freedesktop.TestSuite",
2132 if (message == NULL)
2134 /* Do this again; we still need the service to exit... */
2135 if (!check_send_exit_to_service (context, connection,
2136 service_name, base_service))
2142 if (!dbus_connection_send (connection, message, &serial))
2144 dbus_message_unref (message);
2146 /* Do this again; we still need the service to exit... */
2147 if (!check_send_exit_to_service (context, connection,
2148 service_name, base_service))
2154 dbus_message_unref (message);
2158 bus_test_run_clients_loop (SEND_PENDING (connection));
2160 /* read it in and write it out to test service */
2161 bus_test_run_bus_loop (context, FALSE);
2163 /* see if we got an error during message bus dispatching */
2164 bus_test_run_clients_loop (FALSE);
2165 message = borrow_message_waiting_for_memory (connection);
2166 got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
2169 dbus_connection_return_message (connection, message);
2175 /* If no error, wait for the test service to exit */
2176 block_connection_until_message_from_bus (context, connection, "test service to exit");
2178 bus_test_run_everything (context);
2183 message = pop_message_waiting_for_memory (connection);
2184 _dbus_assert (message != NULL);
2186 if (dbus_message_get_reply_serial (message) != serial)
2188 warn_unexpected (connection, message,
2189 "error with the correct reply serial");
2193 if (!dbus_message_is_error (message,
2194 DBUS_ERROR_NO_MEMORY))
2196 warn_unexpected (connection, message,
2197 "a no memory error from asking test service to exit");
2201 _dbus_verbose ("Got error %s when asking test service to exit\n",
2202 dbus_message_get_error_name (message));
2204 /* Do this again; we still need the service to exit... */
2205 if (!check_send_exit_to_service (context, connection,
2206 service_name, base_service))
2211 if (!check_service_deactivated (context, connection,
2212 service_name, base_service))
2215 /* Should now have a NoReply error from the Exit() method
2216 * call; it should have come after all the deactivation
2219 message = pop_message_waiting_for_memory (connection);
2221 if (message == NULL)
2223 warn_unexpected (connection, NULL,
2224 "reply to Exit() method call");
2227 if (!dbus_message_is_error (message,
2228 DBUS_ERROR_NO_REPLY))
2230 warn_unexpected (connection, message,
2231 "NoReply error from Exit() method call");
2235 if (dbus_message_get_reply_serial (message) != serial)
2237 warn_unexpected (connection, message,
2238 "error with the correct reply serial");
2242 _dbus_verbose ("Got error %s after test service exited\n",
2243 dbus_message_get_error_name (message));
2245 if (!check_no_leftovers (context))
2247 _dbus_warn ("Messages were left over after %s\n",
2248 _DBUS_FUNCTION_NAME);
2257 dbus_message_unref (message);
2263 check_got_error (BusContext *context,
2264 DBusConnection *connection,
2265 const char *first_error_name,
2268 DBusMessage *message;
2271 dbus_bool_t error_found;
2272 const char *error_name;
2276 message = pop_message_waiting_for_memory (connection);
2277 if (message == NULL)
2279 _dbus_warn ("Did not get an expected error\n");
2283 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
2285 warn_unexpected (connection, message, "an error");
2290 error_found = FALSE;
2292 va_start (ap, first_error_name);
2293 error_name = first_error_name;
2294 while (error_name != NULL)
2296 if (dbus_message_is_error (message, error_name))
2301 error_name = va_arg (ap, char*);
2307 _dbus_warn ("Expected error %s or other, got %s instead\n",
2309 dbus_message_get_error_name (message));
2317 dbus_message_unref (message);
2324 GOT_SERVICE_CREATED,
2325 GOT_SERVICE_DELETED,
2330 static GotServiceInfo
2331 check_got_service_info (DBusMessage *message)
2333 GotServiceInfo message_kind;
2335 if (dbus_message_is_signal (message,
2336 DBUS_INTERFACE_DBUS,
2337 "NameOwnerChanged"))
2340 const char *service_name, *old_owner, *new_owner;
2341 dbus_error_init (&error);
2343 reget_service_info_data:
2344 service_name = NULL;
2348 dbus_message_get_args (message, &error,
2349 DBUS_TYPE_STRING, &service_name,
2350 DBUS_TYPE_STRING, &old_owner,
2351 DBUS_TYPE_STRING, &new_owner,
2353 if (dbus_error_is_set (&error))
2355 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
2357 dbus_error_free (&error);
2358 goto reget_service_info_data;
2362 _dbus_warn ("unexpected arguments for NameOwnerChanged message\n");
2363 message_kind = GOT_SOMETHING_ELSE;
2366 else if (!old_owner[0])
2367 message_kind = GOT_SERVICE_CREATED;
2368 else if (!new_owner[0])
2369 message_kind = GOT_SERVICE_DELETED;
2371 message_kind = GOT_SOMETHING_ELSE;
2373 dbus_error_free (&error);
2375 else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2376 message_kind = GOT_ERROR;
2378 message_kind = GOT_SOMETHING_ELSE;
2380 return message_kind;
2383 #define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService"
2385 /* returns TRUE if the correct thing happens,
2386 * but the correct thing may include OOM errors.
2389 check_existent_service_no_auto_start (BusContext *context,
2390 DBusConnection *connection)
2392 DBusMessage *message;
2393 DBusMessage *base_service_message;
2394 const char *base_service;
2395 dbus_uint32_t serial;
2397 const char *existent = EXISTENT_SERVICE_NAME;
2398 dbus_uint32_t flags;
2400 base_service_message = NULL;
2402 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2404 DBUS_INTERFACE_DBUS,
2405 "StartServiceByName");
2407 if (message == NULL)
2410 dbus_message_set_auto_start (message, FALSE);
2413 if (!dbus_message_append_args (message,
2414 DBUS_TYPE_STRING, &existent,
2415 DBUS_TYPE_UINT32, &flags,
2418 dbus_message_unref (message);
2422 if (!dbus_connection_send (connection, message, &serial))
2424 dbus_message_unref (message);
2428 dbus_message_unref (message);
2431 bus_test_run_everything (context);
2433 /* now wait for the message bus to hear back from the activated
2436 block_connection_until_message_from_bus (context, connection, "activated service to connect");
2438 bus_test_run_everything (context);
2440 if (!dbus_connection_get_is_connected (connection))
2442 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2448 message = pop_message_waiting_for_memory (connection);
2449 if (message == NULL)
2451 _dbus_warn ("Did not receive any messages after %s %d on %p\n",
2452 "StartServiceByName", serial, connection);
2456 verbose_message_received (connection, message);
2457 _dbus_verbose (" (after sending %s)\n", "StartServiceByName");
2459 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2461 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2463 _dbus_warn ("Message has wrong sender %s\n",
2464 dbus_message_get_sender (message) ?
2465 dbus_message_get_sender (message) : "(none)");
2469 if (dbus_message_is_error (message,
2470 DBUS_ERROR_NO_MEMORY))
2472 ; /* good, this is a valid response */
2474 else if (dbus_message_is_error (message,
2475 DBUS_ERROR_SPAWN_CHILD_EXITED) ||
2476 dbus_message_is_error (message,
2477 DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
2478 dbus_message_is_error (message,
2479 DBUS_ERROR_SPAWN_EXEC_FAILED))
2481 ; /* good, this is expected also */
2485 _dbus_warn ("Did not expect error %s\n",
2486 dbus_message_get_error_name (message));
2492 GotServiceInfo message_kind;
2494 if (!check_base_service_activated (context, connection,
2495 message, &base_service))
2498 base_service_message = message;
2501 /* We may need to block here for the test service to exit or finish up */
2502 block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
2504 message = dbus_connection_borrow_message (connection);
2505 if (message == NULL)
2507 _dbus_warn ("Did not receive any messages after base service creation notification\n");
2511 message_kind = check_got_service_info (message);
2513 dbus_connection_return_message (connection, message);
2516 switch (message_kind)
2518 case GOT_SOMETHING_ELSE:
2519 _dbus_warn ("Unexpected message after ActivateService "
2520 "(should be an error or a service announcement");
2524 if (!check_got_error (context, connection,
2525 DBUS_ERROR_SPAWN_CHILD_EXITED,
2526 DBUS_ERROR_NO_MEMORY,
2529 /* A service deleted should be coming along now after this error.
2530 * We can also get the error *after* the service deleted.
2535 case GOT_SERVICE_DELETED:
2537 /* The service started up and got a base address, but then
2538 * failed to register under EXISTENT_SERVICE_NAME
2540 CheckServiceOwnerChangedData socd;
2542 socd.expected_kind = SERVICE_DELETED;
2543 socd.expected_service_name = base_service;
2544 socd.failed = FALSE;
2545 socd.skip_connection = NULL;
2547 bus_test_clients_foreach (check_service_owner_changed_foreach,
2553 /* Now we should get an error about the service exiting
2554 * if we didn't get it before.
2556 if (message_kind != GOT_ERROR)
2558 block_connection_until_message_from_bus (context, connection, "error about service exiting");
2560 /* and process everything again */
2561 bus_test_run_everything (context);
2563 if (!check_got_error (context, connection,
2564 DBUS_ERROR_SPAWN_CHILD_EXITED,
2565 DBUS_ERROR_NO_MEMORY,
2572 case GOT_SERVICE_CREATED:
2573 message = pop_message_waiting_for_memory (connection);
2574 if (message == NULL)
2576 _dbus_warn ("Failed to pop message we just put back! "
2577 "should have been a NameOwnerChanged (creation)\n");
2581 if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
2582 base_service, message))
2585 dbus_message_unref (message);
2588 if (!check_no_leftovers (context))
2590 _dbus_warn ("Messages were left over after successful activation\n");
2594 if (!check_send_exit_to_service (context, connection,
2595 EXISTENT_SERVICE_NAME, base_service))
2606 dbus_message_unref (message);
2608 if (base_service_message)
2609 dbus_message_unref (base_service_message);
2614 #ifndef DBUS_WIN_FIXME
2615 /* returns TRUE if the correct thing happens,
2616 * but the correct thing may include OOM errors.
2619 check_segfault_service_no_auto_start (BusContext *context,
2620 DBusConnection *connection)
2622 DBusMessage *message;
2623 dbus_uint32_t serial;
2625 const char *segv_service;
2626 dbus_uint32_t flags;
2628 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2630 DBUS_INTERFACE_DBUS,
2631 "StartServiceByName");
2633 if (message == NULL)
2636 dbus_message_set_auto_start (message, FALSE);
2638 segv_service = "org.freedesktop.DBus.TestSuiteSegfaultService";
2640 if (!dbus_message_append_args (message,
2641 DBUS_TYPE_STRING, &segv_service,
2642 DBUS_TYPE_UINT32, &flags,
2645 dbus_message_unref (message);
2649 if (!dbus_connection_send (connection, message, &serial))
2651 dbus_message_unref (message);
2655 dbus_message_unref (message);
2658 bus_test_run_everything (context);
2659 block_connection_until_message_from_bus (context, connection, "reply to activating segfault service");
2660 bus_test_run_everything (context);
2662 if (!dbus_connection_get_is_connected (connection))
2664 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2670 message = pop_message_waiting_for_memory (connection);
2671 if (message == NULL)
2673 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
2674 "StartServiceByName", serial, connection);
2678 verbose_message_received (connection, message);
2680 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2682 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2684 _dbus_warn ("Message has wrong sender %s\n",
2685 dbus_message_get_sender (message) ?
2686 dbus_message_get_sender (message) : "(none)");
2690 if (dbus_message_is_error (message,
2691 DBUS_ERROR_NO_MEMORY))
2693 ; /* good, this is a valid response */
2695 else if (dbus_message_is_error (message,
2696 DBUS_ERROR_SPAWN_CHILD_SIGNALED))
2698 ; /* good, this is expected also */
2702 warn_unexpected (connection, message, "not this error");
2709 _dbus_warn ("Did not expect to successfully activate segfault service\n");
2717 dbus_message_unref (message);
2723 /* returns TRUE if the correct thing happens,
2724 * but the correct thing may include OOM errors.
2727 check_segfault_service_auto_start (BusContext *context,
2728 DBusConnection *connection)
2730 DBusMessage *message;
2731 dbus_uint32_t serial;
2734 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteSegfaultService",
2735 "/org/freedesktop/TestSuite",
2736 "org.freedesktop.TestSuite",
2739 if (message == NULL)
2742 if (!dbus_connection_send (connection, message, &serial))
2744 dbus_message_unref (message);
2748 dbus_message_unref (message);
2751 bus_test_run_everything (context);
2752 block_connection_until_message_from_bus (context, connection, "reply to Echo on segfault service");
2753 bus_test_run_everything (context);
2755 if (!dbus_connection_get_is_connected (connection))
2757 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2763 message = pop_message_waiting_for_memory (connection);
2764 if (message == NULL)
2766 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
2767 "Echo message (auto activation)", serial, connection);
2771 verbose_message_received (connection, message);
2773 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
2775 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
2777 _dbus_warn ("Message has wrong sender %s\n",
2778 dbus_message_get_sender (message) ?
2779 dbus_message_get_sender (message) : "(none)");
2783 if (dbus_message_is_error (message,
2784 DBUS_ERROR_NO_MEMORY))
2786 ; /* good, this is a valid response */
2788 else if (dbus_message_is_error (message,
2789 DBUS_ERROR_SPAWN_CHILD_SIGNALED))
2791 ; /* good, this is expected also */
2795 warn_unexpected (connection, message, "not this error");
2802 _dbus_warn ("Did not expect to successfully activate segfault service\n");
2810 dbus_message_unref (message);
2816 #define TEST_ECHO_MESSAGE "Test echo message"
2817 #define TEST_RUN_HELLO_FROM_SELF_MESSAGE "Test sending message to self"
2819 /* returns TRUE if the correct thing happens,
2820 * but the correct thing may include OOM errors.
2823 check_existent_hello_from_self (BusContext *context,
2824 DBusConnection *connection)
2826 DBusMessage *message;
2827 dbus_uint32_t serial;
2830 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2831 "/org/freedesktop/TestSuite",
2832 "org.freedesktop.TestSuite",
2833 "RunHelloFromSelf");
2835 if (message == NULL)
2838 text = TEST_RUN_HELLO_FROM_SELF_MESSAGE;
2839 if (!dbus_message_append_args (message,
2840 DBUS_TYPE_STRING, &text,
2843 dbus_message_unref (message);
2847 if (!dbus_connection_send (connection, message, &serial))
2849 dbus_message_unref (message);
2853 dbus_message_unref (message);
2856 bus_test_run_everything (context);
2858 /* Note: if this test is run in OOM mode, it will block when the bus
2859 * doesn't send a reply due to OOM.
2861 block_connection_until_message_from_bus (context, connection, "reply from running hello from self");
2863 message = pop_message_waiting_for_memory (connection);
2864 if (message == NULL)
2866 _dbus_warn ("Failed to pop message! Should have been reply from RunHelloFromSelf message\n");
2870 if (dbus_message_get_reply_serial (message) != serial)
2872 _dbus_warn ("Wrong reply serial\n");
2873 dbus_message_unref (message);
2877 dbus_message_unref (message);
2883 /* returns TRUE if the correct thing happens,
2884 * but the correct thing may include OOM errors.
2887 check_existent_ping (BusContext *context,
2888 DBusConnection *connection)
2890 DBusMessage *message;
2891 dbus_uint32_t serial;
2892 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2893 "/org/freedesktop/TestSuite",
2894 "org.freedesktop.DBus.Peer",
2897 if (message == NULL)
2900 if (!dbus_connection_send (connection, message, &serial))
2902 dbus_message_unref (message);
2906 dbus_message_unref (message);
2909 bus_test_run_everything (context);
2911 /* Note: if this test is run in OOM mode, it will block when the bus
2912 * doesn't send a reply due to OOM.
2914 block_connection_until_message_from_bus (context, connection, "reply from running Ping");
2916 message = pop_message_waiting_for_memory (connection);
2917 if (message == NULL)
2919 _dbus_warn ("Failed to pop message! Should have been reply from Ping message\n");
2923 if (dbus_message_get_reply_serial (message) != serial)
2925 _dbus_warn ("Wrong reply serial\n");
2926 dbus_message_unref (message);
2930 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
2932 _dbus_warn ("Unexpected message return during Ping\n");
2933 dbus_message_unref (message);
2937 dbus_message_unref (message);
2943 /* returns TRUE if the correct thing happens,
2944 * but the correct thing may include OOM errors.
2947 check_existent_get_machine_id (BusContext *context,
2948 DBusConnection *connection)
2950 DBusMessage *message;
2951 dbus_uint32_t serial;
2952 const char *machine_id;
2954 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2955 "/org/freedesktop/TestSuite",
2956 "org.freedesktop.DBus.Peer",
2959 if (message == NULL)
2962 if (!dbus_connection_send (connection, message, &serial))
2964 dbus_message_unref (message);
2968 dbus_message_unref (message);
2971 bus_test_run_everything (context);
2973 /* Note: if this test is run in OOM mode, it will block when the bus
2974 * doesn't send a reply due to OOM.
2976 block_connection_until_message_from_bus (context, connection, "reply from running GetMachineId");
2978 message = pop_message_waiting_for_memory (connection);
2979 if (message == NULL)
2981 _dbus_warn ("Failed to pop message! Should have been reply from GetMachineId message\n");
2985 if (dbus_message_get_reply_serial (message) != serial)
2987 _dbus_warn ("Wrong reply serial\n");
2988 dbus_message_unref (message);
2992 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
2994 _dbus_warn ("Unexpected message return during GetMachineId\n");
2995 dbus_message_unref (message);
3000 if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &machine_id, DBUS_TYPE_INVALID))
3002 _dbus_warn ("Did not get a machine ID in reply to GetMachineId\n");
3003 dbus_message_unref (message);
3007 if (machine_id == NULL || strlen (machine_id) != 32)
3009 _dbus_warn ("Machine id looks bogus: '%s'\n", machine_id ? machine_id : "null");
3010 dbus_message_unref (message);
3014 /* We can't check that the machine id is correct because during make check it is
3015 * just made up for each process separately
3018 dbus_message_unref (message);
3024 /* returns TRUE if the correct thing happens,
3025 * but the correct thing may include OOM errors.
3028 check_existent_service_auto_start (BusContext *context,
3029 DBusConnection *connection)
3031 DBusMessage *message;
3032 DBusMessage *base_service_message;
3033 dbus_uint32_t serial;
3035 const char *base_service;
3038 base_service_message = NULL;
3040 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
3041 "/org/freedesktop/TestSuite",
3042 "org.freedesktop.TestSuite",
3045 if (message == NULL)
3048 text = TEST_ECHO_MESSAGE;
3049 if (!dbus_message_append_args (message,
3050 DBUS_TYPE_STRING, &text,
3053 dbus_message_unref (message);
3057 if (!dbus_connection_send (connection, message, &serial))
3059 dbus_message_unref (message);
3063 dbus_message_unref (message);
3066 bus_test_run_everything (context);
3068 /* now wait for the message bus to hear back from the activated
3071 block_connection_until_message_from_bus (context, connection, "reply to Echo on existent service");
3072 bus_test_run_everything (context);
3074 if (!dbus_connection_get_is_connected (connection))
3076 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3082 message = pop_message_waiting_for_memory (connection);
3083 if (message == NULL)
3085 _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
3086 serial, connection);
3090 verbose_message_received (connection, message);
3091 _dbus_verbose (" (after sending %s)\n", "auto start");
3093 /* we should get zero or two ServiceOwnerChanged signals */
3094 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
3096 GotServiceInfo message_kind;
3098 if (!check_base_service_activated (context, connection,
3099 message, &base_service))
3102 base_service_message = message;
3105 /* We may need to block here for the test service to exit or finish up */
3106 block_connection_until_message_from_bus (context, connection, "service to exit");
3108 /* Should get a service creation notification for the activated
3109 * service name, or a service deletion on the base service name
3111 message = dbus_connection_borrow_message (connection);
3112 if (message == NULL)
3114 _dbus_warn ("No message after auto activation "
3115 "(should be a service announcement)\n");
3116 dbus_connection_return_message (connection, message);
3121 message_kind = check_got_service_info (message);
3123 dbus_connection_return_message (connection, message);
3126 switch (message_kind)
3128 case GOT_SERVICE_CREATED:
3129 message = pop_message_waiting_for_memory (connection);
3130 if (message == NULL)
3132 _dbus_warn ("Failed to pop message we just put back! "
3133 "should have been a NameOwnerChanged (creation)\n");
3137 /* Check that ServiceOwnerChanged (creation) was correctly received */
3138 if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME,
3139 base_service, message))
3142 dbus_message_unref (message);
3147 case GOT_SERVICE_DELETED:
3149 /* The service started up and got a base address, but then
3150 * failed to register under EXISTENT_SERVICE_NAME
3152 CheckServiceOwnerChangedData socd;
3154 socd.expected_kind = SERVICE_DELETED;
3155 socd.expected_service_name = base_service;
3156 socd.failed = FALSE;
3157 socd.skip_connection = NULL;
3158 bus_test_clients_foreach (check_service_owner_changed_foreach,
3168 case GOT_SOMETHING_ELSE:
3169 _dbus_warn ("Unexpected message after auto activation\n");
3174 /* OK, now we've dealt with ServiceOwnerChanged signals, now should
3175 * come the method reply (or error) from the initial method call
3178 /* Note: if this test is run in OOM mode, it will block when the bus
3179 * doesn't send a reply due to OOM.
3181 block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3183 message = pop_message_waiting_for_memory (connection);
3184 if (message == NULL)
3186 _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
3190 if (dbus_message_get_reply_serial (message) != serial)
3192 _dbus_warn ("Wrong reply serial\n");
3196 dbus_message_unref (message);
3199 if (!check_existent_ping (context, connection))
3202 if (!check_existent_get_machine_id (context, connection))
3205 if (!check_existent_hello_from_self (context, connection))
3208 if (!check_send_exit_to_service (context, connection,
3209 EXISTENT_SERVICE_NAME,
3217 dbus_message_unref (message);
3219 if (base_service_message)
3220 dbus_message_unref (base_service_message);
3225 #define SHELL_FAIL_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceFail"
3227 /* returns TRUE if the correct thing happens,
3228 * but the correct thing may include OOM errors.
3231 check_shell_fail_service_auto_start (BusContext *context,
3232 DBusConnection *connection)
3234 DBusMessage *message;
3235 dbus_uint32_t serial;
3238 message = dbus_message_new_method_call (SHELL_FAIL_SERVICE_NAME,
3239 "/org/freedesktop/TestSuite",
3240 "org.freedesktop.TestSuite",
3243 if (message == NULL)
3246 if (!dbus_connection_send (connection, message, &serial))
3248 dbus_message_unref (message);
3252 dbus_message_unref (message);
3255 bus_test_run_everything (context);
3256 block_connection_until_message_from_bus (context, connection, "reply to shell Echo on service which should fail to auto-start");
3257 bus_test_run_everything (context);
3259 if (!dbus_connection_get_is_connected (connection))
3261 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3267 message = pop_message_waiting_for_memory (connection);
3268 if (message == NULL)
3270 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3271 "Echo message (auto activation)", serial, connection);
3275 verbose_message_received (connection, message);
3277 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3279 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3281 _dbus_warn ("Message has wrong sender %s\n",
3282 dbus_message_get_sender (message) ?
3283 dbus_message_get_sender (message) : "(none)");
3287 if (dbus_message_is_error (message,
3288 DBUS_ERROR_NO_MEMORY))
3290 ; /* good, this is a valid response */
3292 else if (dbus_message_is_error (message,
3293 DBUS_ERROR_INVALID_ARGS))
3295 _dbus_verbose("got invalid args\n");
3296 ; /* good, this is expected also */
3300 warn_unexpected (connection, message, "not this error");
3307 _dbus_warn ("Did not expect to successfully auto-start shell fail service\n");
3315 dbus_message_unref (message);
3320 #define SHELL_SUCCESS_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceSuccess"
3322 /* returns TRUE if the correct thing happens,
3323 * but the correct thing may include OOM errors.
3326 check_shell_service_success_auto_start (BusContext *context,
3327 DBusConnection *connection)
3329 DBusMessage *message;
3330 DBusMessage *base_service_message;
3331 dbus_uint32_t serial;
3333 const char *base_service;
3334 const char *argv[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
3336 base_service_message = NULL;
3338 message = dbus_message_new_method_call (SHELL_SUCCESS_SERVICE_NAME,
3339 "/org/freedesktop/TestSuite",
3340 "org.freedesktop.TestSuite",
3343 if (message == NULL)
3346 if (!dbus_connection_send (connection, message, &serial))
3348 dbus_message_unref (message);
3352 dbus_message_unref (message);
3355 bus_test_run_everything (context);
3357 /* now wait for the message bus to hear back from the activated
3360 block_connection_until_message_from_bus (context, connection, "reply to Echo on shell success service");
3361 bus_test_run_everything (context);
3363 if (!dbus_connection_get_is_connected (connection))
3365 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3371 message = pop_message_waiting_for_memory (connection);
3372 if (message == NULL)
3374 _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
3375 serial, connection);
3379 verbose_message_received (connection, message);
3380 _dbus_verbose (" (after sending %s)\n", "auto start");
3382 /* we should get zero or two ServiceOwnerChanged signals */
3383 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
3385 GotServiceInfo message_kind;
3387 if (!check_base_service_activated (context, connection,
3388 message, &base_service))
3391 base_service_message = message;
3394 /* We may need to block here for the test service to exit or finish up */
3395 block_connection_until_message_from_bus (context, connection, "service to exit");
3397 /* Should get a service creation notification for the activated
3398 * service name, or a service deletion on the base service name
3400 message = dbus_connection_borrow_message (connection);
3401 if (message == NULL)
3403 _dbus_warn ("No message after auto activation "
3404 "(should be a service announcement)\n");
3405 dbus_connection_return_message (connection, message);
3410 message_kind = check_got_service_info (message);
3412 dbus_connection_return_message (connection, message);
3415 switch (message_kind)
3417 case GOT_SERVICE_CREATED:
3418 message = pop_message_waiting_for_memory (connection);
3419 if (message == NULL)
3421 _dbus_warn ("Failed to pop message we just put back! "
3422 "should have been a NameOwnerChanged (creation)\n");
3426 /* Check that ServiceOwnerChanged (creation) was correctly received */
3427 if (!check_service_auto_activated (context, connection, SHELL_SUCCESS_SERVICE_NAME,
3428 base_service, message))
3431 dbus_message_unref (message);
3436 case GOT_SERVICE_DELETED:
3438 /* The service started up and got a base address, but then
3439 * failed to register under SHELL_SUCCESS_SERVICE_NAME
3441 CheckServiceOwnerChangedData socd;
3443 socd.expected_kind = SERVICE_DELETED;
3444 socd.expected_service_name = base_service;
3445 socd.failed = FALSE;
3446 socd.skip_connection = NULL;
3447 bus_test_clients_foreach (check_service_owner_changed_foreach,
3457 case GOT_SOMETHING_ELSE:
3458 _dbus_warn ("Unexpected message after auto activation\n");
3463 /* OK, now we've dealt with ServiceOwnerChanged signals, now should
3464 * come the method reply (or error) from the initial method call
3467 /* Note: if this test is run in OOM mode, it will block when the bus
3468 * doesn't send a reply due to OOM.
3470 block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3472 message = pop_message_waiting_for_memory (connection);
3473 if (message == NULL)
3475 _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
3479 if (dbus_message_get_reply_serial (message) != serial)
3481 _dbus_warn ("Wrong reply serial\n");
3485 if (!dbus_message_get_args (message, NULL,
3486 DBUS_TYPE_STRING, &argv[0],
3487 DBUS_TYPE_STRING, &argv[1],
3488 DBUS_TYPE_STRING, &argv[2],
3489 DBUS_TYPE_STRING, &argv[3],
3490 DBUS_TYPE_STRING, &argv[4],
3491 DBUS_TYPE_STRING, &argv[5],
3492 DBUS_TYPE_STRING, &argv[6],
3495 _dbus_warn ("Error getting arguments from return\n");
3499 /* don't worry about arg[0] as it may be different
3500 depending on the path to the tests
3502 if (strcmp("-test", argv[1]) != 0)
3504 _dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n",
3509 if (strcmp("that", argv[2]) != 0)
3511 _dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n",
3516 if (strcmp("we get", argv[3]) != 0)
3518 _dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n",
3523 if (strcmp("back", argv[4]) != 0)
3525 _dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n",
3530 if (strcmp("--what", argv[5]) != 0)
3532 _dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n",
3537 if (strcmp("we put in", argv[6]) != 0)
3539 _dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n",
3540 "we put in", argv[6]);
3544 dbus_message_unref (message);
3547 if (!check_send_exit_to_service (context, connection,
3548 SHELL_SUCCESS_SERVICE_NAME,
3556 dbus_message_unref (message);
3558 if (base_service_message)
3559 dbus_message_unref (base_service_message);
3567 BusContext *context;
3571 check_oom_check1_func (void *data)
3573 Check1Data *d = data;
3575 if (! (* d->func) (d->context))
3578 if (!check_no_leftovers (d->context))
3580 _dbus_warn ("Messages were left over, should be covered by test suite\n");
3588 check1_try_iterations (BusContext *context,
3589 const char *description,
3595 d.context = context;
3597 if (!_dbus_test_oom_handling (description, check_oom_check1_func,
3599 _dbus_assert_not_reached ("test failed");
3603 check_get_services (BusContext *context,
3604 DBusConnection *connection,
3609 DBusMessage *message;
3610 dbus_uint32_t serial;
3617 dbus_error_init (&error);
3620 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
3622 DBUS_INTERFACE_DBUS,
3625 if (message == NULL)
3628 if (!dbus_connection_send (connection, message, &serial))
3630 dbus_message_unref (message);
3634 /* send our message */
3635 bus_test_run_clients_loop (SEND_PENDING (connection));
3637 dbus_message_unref (message);
3640 dbus_connection_ref (connection); /* because we may get disconnected */
3641 block_connection_until_message_from_bus (context, connection, "reply to ListActivatableNames/ListNames");
3643 if (!dbus_connection_get_is_connected (connection))
3645 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3647 dbus_connection_unref (connection);
3652 dbus_connection_unref (connection);
3654 message = pop_message_waiting_for_memory (connection);
3655 if (message == NULL)
3657 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
3658 method, serial, connection);
3662 verbose_message_received (connection, message);
3664 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3666 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
3668 ; /* good, this is a valid response */
3672 warn_unexpected (connection, message, "not this error");
3679 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
3681 ; /* good, expected */
3685 warn_unexpected (connection, message,
3686 "method_return for ListActivatableNames/ListNames");
3693 if (!dbus_message_get_args (message, &error,
3699 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
3701 _dbus_verbose ("no memory to list services by %s\n", method);
3702 dbus_error_free (&error);
3703 _dbus_wait_for_memory ();
3704 goto retry_get_property;
3708 _dbus_assert (dbus_error_is_set (&error));
3709 _dbus_warn ("Did not get the expected DBUS_TYPE_ARRAY from %s\n", method);
3718 if (!check_no_leftovers (context))
3724 dbus_error_free (&error);
3727 dbus_message_unref (message);
3732 /* returns TRUE if the correct thing happens,
3733 * but the correct thing may include OOM errors.
3736 check_list_services (BusContext *context,
3737 DBusConnection *connection)
3739 DBusMessage *message;
3740 DBusMessage *base_service_message;
3741 const char *base_service;
3742 dbus_uint32_t serial;
3744 const char *existent = EXISTENT_SERVICE_NAME;
3745 dbus_uint32_t flags;
3749 _dbus_verbose ("check_list_services for %p\n", connection);
3751 if (!check_get_services (context, connection, "ListActivatableNames", &services, &len))
3756 if (!_dbus_string_array_contains ((const char **)services, existent))
3758 _dbus_warn ("Did not get the expected %s from ListActivatableNames\n", existent);
3762 dbus_free_string_array (services);
3764 base_service_message = NULL;
3766 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
3768 DBUS_INTERFACE_DBUS,
3769 "StartServiceByName");
3771 if (message == NULL)
3774 dbus_message_set_auto_start (message, FALSE);
3777 if (!dbus_message_append_args (message,
3778 DBUS_TYPE_STRING, &existent,
3779 DBUS_TYPE_UINT32, &flags,
3782 dbus_message_unref (message);
3786 if (!dbus_connection_send (connection, message, &serial))
3788 dbus_message_unref (message);
3792 dbus_message_unref (message);
3795 bus_test_run_everything (context);
3797 /* now wait for the message bus to hear back from the activated
3800 block_connection_until_message_from_bus (context, connection, "activated service to connect");
3802 bus_test_run_everything (context);
3804 if (!dbus_connection_get_is_connected (connection))
3806 _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3812 message = pop_message_waiting_for_memory (connection);
3813 if (message == NULL)
3815 _dbus_warn ("Did not receive any messages after %s %d on %p\n",
3816 "StartServiceByName", serial, connection);
3820 verbose_message_received (connection, message);
3821 _dbus_verbose (" (after sending %s)\n", "StartServiceByName");
3823 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
3825 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
3827 _dbus_warn ("Message has wrong sender %s\n",
3828 dbus_message_get_sender (message) ?
3829 dbus_message_get_sender (message) : "(none)");
3833 if (dbus_message_is_error (message,
3834 DBUS_ERROR_NO_MEMORY))
3836 ; /* good, this is a valid response */
3838 else if (dbus_message_is_error (message,
3839 DBUS_ERROR_SPAWN_CHILD_EXITED) ||
3840 dbus_message_is_error (message,
3841 DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
3842 dbus_message_is_error (message,
3843 DBUS_ERROR_SPAWN_EXEC_FAILED))
3845 ; /* good, this is expected also */
3849 _dbus_warn ("Did not expect error %s\n",
3850 dbus_message_get_error_name (message));
3856 GotServiceInfo message_kind;
3858 if (!check_base_service_activated (context, connection,
3859 message, &base_service))
3862 base_service_message = message;
3865 /* We may need to block here for the test service to exit or finish up */
3866 block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
3868 message = dbus_connection_borrow_message (connection);
3869 if (message == NULL)
3871 _dbus_warn ("Did not receive any messages after base service creation notification\n");
3875 message_kind = check_got_service_info (message);
3877 dbus_connection_return_message (connection, message);
3880 switch (message_kind)
3882 case GOT_SOMETHING_ELSE:
3884 case GOT_SERVICE_DELETED:
3885 _dbus_warn ("Unexpected message after ActivateService "
3886 "(should be an error or a service announcement)\n");
3889 case GOT_SERVICE_CREATED:
3890 message = pop_message_waiting_for_memory (connection);
3891 if (message == NULL)
3893 _dbus_warn ("Failed to pop message we just put back! "
3894 "should have been a NameOwnerChanged (creation)\n");
3898 if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
3899 base_service, message))
3902 dbus_message_unref (message);
3905 if (!check_no_leftovers (context))
3907 _dbus_warn ("Messages were left over after successful activation\n");
3915 if (!check_get_services (context, connection, "ListNames", &services, &len))
3920 if (!_dbus_string_array_contains ((const char **)services, existent))
3922 _dbus_warn ("Did not get the expected %s from ListNames\n", existent);
3926 dbus_free_string_array (services);
3928 if (!check_send_exit_to_service (context, connection,
3929 EXISTENT_SERVICE_NAME, base_service))
3936 dbus_message_unref (message);
3938 if (base_service_message)
3939 dbus_message_unref (base_service_message);
3947 BusContext *context;
3948 DBusConnection *connection;
3952 check_oom_check2_func (void *data)
3954 Check2Data *d = data;
3956 if (! (* d->func) (d->context, d->connection))
3959 if (!check_no_leftovers (d->context))
3961 _dbus_warn ("Messages were left over, should be covered by test suite\n");
3969 check2_try_iterations (BusContext *context,
3970 DBusConnection *connection,
3971 const char *description,
3977 d.context = context;
3978 d.connection = connection;
3980 if (!_dbus_test_oom_handling (description, check_oom_check2_func,
3983 _dbus_warn ("%s failed during oom\n", description);
3984 _dbus_assert_not_reached ("test failed");
3989 bus_dispatch_test (const DBusString *test_data_dir)
3991 BusContext *context;
3992 DBusConnection *foo;
3993 DBusConnection *bar;
3994 DBusConnection *baz;
3997 dbus_error_init (&error);
3999 context = bus_context_new_test (test_data_dir,
4000 "valid-config-files/debug-allow-all.conf");
4001 if (context == NULL)
4004 foo = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4006 _dbus_assert_not_reached ("could not alloc connection");
4008 if (!bus_setup_debug_client (foo))
4009 _dbus_assert_not_reached ("could not set up connection");
4011 spin_connection_until_authenticated (context, foo);
4013 if (!check_hello_message (context, foo))
4014 _dbus_assert_not_reached ("hello message failed");
4016 if (!check_double_hello_message (context, foo))
4017 _dbus_assert_not_reached ("double hello message failed");
4019 if (!check_add_match_all (context, foo))
4020 _dbus_assert_not_reached ("AddMatch message failed");
4022 bar = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4024 _dbus_assert_not_reached ("could not alloc connection");
4026 if (!bus_setup_debug_client (bar))
4027 _dbus_assert_not_reached ("could not set up connection");
4029 spin_connection_until_authenticated (context, bar);
4031 if (!check_hello_message (context, bar))
4032 _dbus_assert_not_reached ("hello message failed");
4034 if (!check_add_match_all (context, bar))
4035 _dbus_assert_not_reached ("AddMatch message failed");
4037 baz = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4039 _dbus_assert_not_reached ("could not alloc connection");
4041 if (!bus_setup_debug_client (baz))
4042 _dbus_assert_not_reached ("could not set up connection");
4044 spin_connection_until_authenticated (context, baz);
4046 if (!check_hello_message (context, baz))
4047 _dbus_assert_not_reached ("hello message failed");
4049 if (!check_add_match_all (context, baz))
4050 _dbus_assert_not_reached ("AddMatch message failed");
4052 if (!check_get_connection_unix_user (context, baz))
4053 _dbus_assert_not_reached ("GetConnectionUnixUser message failed");
4055 if (!check_get_connection_unix_process_id (context, baz))
4056 _dbus_assert_not_reached ("GetConnectionUnixProcessID message failed");
4058 if (!check_list_services (context, baz))
4059 _dbus_assert_not_reached ("ListActivatableNames message failed");
4061 if (!check_no_leftovers (context))
4063 _dbus_warn ("Messages were left over after setting up initial connections\n");
4064 _dbus_assert_not_reached ("initial connection setup failed");
4067 check1_try_iterations (context, "create_and_hello",
4068 check_hello_connection);
4070 check2_try_iterations (context, foo, "nonexistent_service_no_auto_start",
4071 check_nonexistent_service_no_auto_start);
4073 #ifdef DBUS_WIN_FIXME
4074 _dbus_warn("TODO: dispatch.c segfault_service_no_auto_start test\n");
4076 check2_try_iterations (context, foo, "segfault_service_no_auto_start",
4077 check_segfault_service_no_auto_start);
4080 check2_try_iterations (context, foo, "existent_service_no_auto_start",
4081 check_existent_service_no_auto_start);
4083 check2_try_iterations (context, foo, "nonexistent_service_auto_start",
4084 check_nonexistent_service_auto_start);
4087 #ifdef DBUS_WIN_FIXME
4088 _dbus_warn("TODO: dispatch.c segfault_service_auto_start test\n");
4090 check2_try_iterations (context, foo, "segfault_service_auto_start",
4091 check_segfault_service_auto_start);
4094 check2_try_iterations (context, foo, "shell_fail_service_auto_start",
4095 check_shell_fail_service_auto_start);
4098 /* Note: need to resolve some issues with the testing code in order to run
4099 * this in oom (handle that we sometimes don't get replies back from the bus
4100 * when oom happens, without blocking the test).
4102 check2_try_iterations (context, foo, "existent_service_auto_auto_start",
4103 check_existent_service_auto_start);
4106 if (!check_existent_service_auto_start (context, foo))
4107 _dbus_assert_not_reached ("existent service auto start failed");
4109 if (!check_shell_service_success_auto_start (context, foo))
4110 _dbus_assert_not_reached ("shell success service auto start failed");
4112 _dbus_verbose ("Disconnecting foo, bar, and baz\n");
4114 kill_client_connection_unchecked (foo);
4115 kill_client_connection_unchecked (bar);
4116 kill_client_connection_unchecked (baz);
4118 bus_context_unref (context);
4124 bus_dispatch_sha1_test (const DBusString *test_data_dir)
4126 BusContext *context;
4127 DBusConnection *foo;
4130 dbus_error_init (&error);
4132 /* Test SHA1 authentication */
4133 _dbus_verbose ("Testing SHA1 context\n");
4135 context = bus_context_new_test (test_data_dir,
4136 "valid-config-files/debug-allow-all-sha1.conf");
4137 if (context == NULL)
4140 foo = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4142 _dbus_assert_not_reached ("could not alloc connection");
4144 if (!bus_setup_debug_client (foo))
4145 _dbus_assert_not_reached ("could not set up connection");
4147 spin_connection_until_authenticated (context, foo);
4149 if (!check_hello_message (context, foo))
4150 _dbus_assert_not_reached ("hello message failed");
4152 if (!check_add_match_all (context, foo))
4153 _dbus_assert_not_reached ("addmatch message failed");
4155 if (!check_no_leftovers (context))
4157 _dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
4158 _dbus_assert_not_reached ("initial connection setup failed");
4161 check1_try_iterations (context, "create_and_hello_sha1",
4162 check_hello_connection);
4164 kill_client_connection_unchecked (foo);
4166 bus_context_unref (context);
4171 #endif /* DBUS_BUILD_TESTS */