1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dispatch.c Message dispatcher
4 * Copyright (C) 2003 CodeFactory AB
5 * Copyright (C) 2003 Red Hat, Inc.
7 * Licensed under the Academic Free License version 1.2
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.
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.
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
26 #include "connection.h"
32 #include <dbus/dbus-internals.h>
35 static dbus_int32_t message_handler_slot = -1;
40 DBusConnection *sender;
42 BusTransaction *transaction;
47 send_one_message (DBusConnection *connection, void *data)
49 SendMessageData *d = data;
51 if (!bus_context_check_security_policy (d->context,
56 return TRUE; /* silently don't send it */
58 if (!bus_transaction_send (d->transaction,
62 BUS_SET_OOM (d->error);
70 bus_dispatch_broadcast_message (BusTransaction *transaction,
71 DBusConnection *sender,
77 BusConnections *connections;
79 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
81 _dbus_assert (dbus_message_get_sender (message) != NULL);
83 connections = bus_transaction_get_connections (transaction);
85 dbus_error_init (&tmp_error);
87 d.context = bus_transaction_get_context (transaction);
89 d.transaction = transaction;
92 bus_connections_foreach_active (connections, send_one_message, &d);
94 if (dbus_error_is_set (&tmp_error))
96 dbus_move_error (&tmp_error, error);
103 static DBusHandlerResult
104 bus_dispatch (DBusConnection *connection,
105 DBusMessage *message)
107 const char *sender, *service_name;
109 BusTransaction *transaction;
111 DBusHandlerResult result;
113 result = DBUS_HANDLER_RESULT_HANDLED;
116 dbus_error_init (&error);
118 context = bus_connection_get_context (connection);
119 _dbus_assert (context != NULL);
121 /* If we can't even allocate an OOM error, we just go to sleep
124 while (!bus_connection_preallocate_oom_error (connection))
125 _dbus_wait_for_memory ();
127 /* Ref connection in case we disconnect it at some point in here */
128 dbus_connection_ref (connection);
130 service_name = dbus_message_get_destination (message);
132 #ifdef DBUS_ENABLE_VERBOSE_MODE
134 const char *interface_name, *member_name, *error_name;
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);
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");
146 #endif /* DBUS_ENABLE_VERBOSE_MODE */
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.
153 if (service_name == NULL)
155 if (dbus_message_has_interface (message, DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL) &&
156 dbus_message_has_member (message, "Disconnect"))
157 bus_connection_disconnected (connection);
159 /* DBusConnection also handles some of these automatically, we leave
162 result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
166 _dbus_assert (service_name != NULL); /* this message is intended for bus routing */
168 /* Create our transaction */
169 transaction = bus_transaction_new (context);
170 if (transaction == NULL)
172 BUS_SET_OOM (&error);
176 /* Assign a sender to the message */
177 if (bus_connection_is_active (connection))
179 sender = bus_connection_get_name (connection);
180 _dbus_assert (sender != NULL);
182 if (!dbus_message_set_sender (message, sender))
184 BUS_SET_OOM (&error);
188 /* We need to refetch the service name here, because
189 * dbus_message_set_sender can cause the header to be
190 * reallocated, and thus the service_name pointer will become
193 service_name = dbus_message_get_destination (message);
196 if (strcmp (service_name, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS) == 0) /* to bus driver */
198 if (!bus_context_check_security_policy (context,
199 connection, NULL, message, &error))
201 _dbus_verbose ("Security policy rejected message\n");
205 _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
206 if (!bus_driver_handle_message (connection, transaction, message, &error))
209 else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */
211 _dbus_verbose ("Received message from non-registered client. Disconnecting.\n");
212 dbus_connection_disconnect (connection);
214 /* FIXME what if we un-special-case this service and just have a flag
215 * on services that all service owners will get messages to it, not just
218 else if (strcmp (service_name, DBUS_SERVICE_BROADCAST) == 0) /* spam! */
220 if (!bus_dispatch_broadcast_message (transaction, connection, message, &error))
223 else /* route to named service */
225 DBusString service_string;
227 BusRegistry *registry;
229 registry = bus_connection_get_registry (connection);
231 _dbus_string_init_const (&service_string, service_name);
232 service = bus_registry_lookup (registry, &service_string);
236 dbus_set_error (&error,
237 DBUS_ERROR_SERVICE_DOES_NOT_EXIST,
238 "Service \"%s\" does not exist",
244 DBusConnection *recipient;
246 recipient = bus_service_get_primary_owner (service);
247 _dbus_assert (recipient != NULL);
249 if (!bus_context_check_security_policy (context,
250 connection, recipient, message, &error))
253 /* Dispatch the message */
254 if (!bus_transaction_send (transaction, recipient, message))
256 BUS_SET_OOM (&error);
263 if (dbus_error_is_set (&error))
265 if (!dbus_connection_get_is_connected (connection))
267 /* If we disconnected it, we won't bother to send it any error
270 _dbus_verbose ("Not sending error to connection we disconnected\n");
272 else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
274 bus_connection_send_oom_error (connection, message);
276 /* cancel transaction due to OOM */
277 if (transaction != NULL)
279 bus_transaction_cancel_and_free (transaction);
285 /* Try to send the real error, if no mem to do that, send
288 _dbus_assert (transaction != NULL);
290 if (!bus_transaction_send_error_reply (transaction, connection,
293 bus_connection_send_oom_error (connection, message);
295 /* cancel transaction due to OOM */
296 if (transaction != NULL)
298 bus_transaction_cancel_and_free (transaction);
304 dbus_error_free (&error);
307 if (transaction != NULL)
309 bus_transaction_execute_and_free (transaction);
312 dbus_connection_unref (connection);
317 static DBusHandlerResult
318 bus_dispatch_message_handler (DBusMessageHandler *handler,
319 DBusConnection *connection,
320 DBusMessage *message,
323 return bus_dispatch (connection, message);
327 free_message_handler (void *data)
329 DBusMessageHandler *handler = data;
331 _dbus_assert (message_handler_slot >= 0);
333 dbus_message_handler_unref (handler);
334 dbus_connection_free_data_slot (&message_handler_slot);
338 bus_dispatch_add_connection (DBusConnection *connection)
340 DBusMessageHandler *handler;
342 if (!dbus_connection_allocate_data_slot (&message_handler_slot))
345 handler = dbus_message_handler_new (bus_dispatch_message_handler, NULL, NULL);
348 dbus_connection_free_data_slot (&message_handler_slot);
352 if (!dbus_connection_add_filter (connection, handler))
354 dbus_message_handler_unref (handler);
355 dbus_connection_free_data_slot (&message_handler_slot);
360 _dbus_assert (message_handler_slot >= 0);
362 if (!dbus_connection_set_data (connection,
363 message_handler_slot,
365 free_message_handler))
367 dbus_message_handler_unref (handler);
368 dbus_connection_free_data_slot (&message_handler_slot);
377 bus_dispatch_remove_connection (DBusConnection *connection)
379 /* Here we tell the bus driver that we want to get off. */
380 bus_driver_remove_connection (connection);
382 dbus_connection_set_data (connection,
383 message_handler_slot,
387 #ifdef DBUS_BUILD_TESTS
389 typedef dbus_bool_t (* Check1Func) (BusContext *context);
390 typedef dbus_bool_t (* Check2Func) (BusContext *context,
391 DBusConnection *connection);
393 static dbus_bool_t check_no_leftovers (BusContext *context);
396 block_connection_until_message_from_bus (BusContext *context,
397 DBusConnection *connection)
399 while (dbus_connection_get_dispatch_status (connection) ==
400 DBUS_DISPATCH_COMPLETE &&
401 dbus_connection_get_is_connected (connection))
403 bus_test_run_bus_loop (context, TRUE);
404 bus_test_run_clients_loop (FALSE);
408 /* compensate for fact that pop_message() can return #NULL due to OOM */
410 pop_message_waiting_for_memory (DBusConnection *connection)
412 while (dbus_connection_get_dispatch_status (connection) ==
413 DBUS_DISPATCH_NEED_MEMORY)
414 _dbus_wait_for_memory ();
416 return dbus_connection_pop_message (connection);
421 const char *expected_service_name;
423 } CheckServiceDeletedData;
426 check_service_deleted_foreach (DBusConnection *connection,
429 CheckServiceDeletedData *d = data;
430 DBusMessage *message;
434 dbus_error_init (&error);
438 message = pop_message_waiting_for_memory (connection);
441 _dbus_warn ("Did not receive a message on %p, expecting %s\n",
442 connection, DBUS_MESSAGE_SERVICE_DELETED);
445 else if (!dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_DELETED))
447 _dbus_warn ("Received message %s on %p, expecting %s\n",
448 dbus_message_get_name (message),
449 connection, DBUS_MESSAGE_SERVICE_DELETED);
454 if (!dbus_message_get_args (message, &error,
455 DBUS_TYPE_STRING, &service_name,
458 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
460 _dbus_verbose ("no memory to get service name arg\n");
464 _dbus_assert (dbus_error_is_set (&error));
465 _dbus_warn ("Did not get the expected single string argument\n");
469 else if (strcmp (service_name, d->expected_service_name) != 0)
471 _dbus_warn ("expected deletion of service %s, got deletion of %s\n",
472 d->expected_service_name,
481 dbus_free (service_name);
482 dbus_error_free (&error);
485 dbus_message_unref (message);
491 kill_client_connection (BusContext *context,
492 DBusConnection *connection)
496 CheckServiceDeletedData csdd;
498 _dbus_verbose ("killing connection %p\n", connection);
500 s = dbus_bus_get_base_service (connection);
501 _dbus_assert (s != NULL);
503 while ((base_service = _dbus_strdup (s)) == NULL)
504 _dbus_wait_for_memory ();
506 dbus_connection_ref (connection);
508 /* kick in the disconnect handler that unrefs the connection */
509 dbus_connection_disconnect (connection);
511 bus_test_run_everything (context);
513 _dbus_assert (bus_test_client_listed (connection));
515 /* Run disconnect handler in test.c */
516 if (bus_connection_dispatch_one_message (connection))
517 _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
519 _dbus_assert (!dbus_connection_get_is_connected (connection));
520 dbus_connection_unref (connection);
522 _dbus_assert (!bus_test_client_listed (connection));
524 csdd.expected_service_name = base_service;
527 bus_test_clients_foreach (check_service_deleted_foreach,
530 dbus_free (base_service);
533 _dbus_assert_not_reached ("didn't get the expected ServiceDeleted messages");
535 if (!check_no_leftovers (context))
536 _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
540 kill_client_connection_unchecked (DBusConnection *connection)
542 /* This kills the connection without expecting it to affect
543 * the rest of the bus.
545 _dbus_verbose ("Unchecked kill of connection %p\n", connection);
547 dbus_connection_ref (connection);
548 dbus_connection_disconnect (connection);
549 /* dispatching disconnect handler will unref once */
550 if (bus_connection_dispatch_one_message (connection))
551 _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
553 _dbus_assert (!bus_test_client_listed (connection));
554 dbus_connection_unref (connection);
560 } CheckNoMessagesData;
563 check_no_messages_foreach (DBusConnection *connection,
566 CheckNoMessagesData *d = data;
567 DBusMessage *message;
569 message = pop_message_waiting_for_memory (connection);
572 _dbus_warn ("Received message %s on %p, expecting no messages\n",
573 dbus_message_get_name (message), connection);
578 dbus_message_unref (message);
584 DBusConnection *skip_connection;
585 const char *expected_service_name;
587 } CheckServiceCreatedData;
590 check_service_created_foreach (DBusConnection *connection,
593 CheckServiceCreatedData *d = data;
594 DBusMessage *message;
598 if (connection == d->skip_connection)
601 dbus_error_init (&error);
605 message = pop_message_waiting_for_memory (connection);
608 _dbus_warn ("Did not receive a message on %p, expecting %s\n",
609 connection, DBUS_MESSAGE_SERVICE_CREATED);
612 else if (!dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_CREATED))
614 _dbus_warn ("Received message %s on %p, expecting %s\n",
615 dbus_message_get_name (message),
616 connection, DBUS_MESSAGE_SERVICE_CREATED);
621 if (!dbus_message_get_args (message, &error,
622 DBUS_TYPE_STRING, &service_name,
625 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
627 _dbus_verbose ("no memory to get service name arg\n");
631 _dbus_assert (dbus_error_is_set (&error));
632 _dbus_warn ("Did not get the expected single string argument\n");
636 else if (strcmp (service_name, d->expected_service_name) != 0)
638 _dbus_warn ("expected creation of service %s, got creation of %s\n",
639 d->expected_service_name,
648 dbus_free (service_name);
649 dbus_error_free (&error);
652 dbus_message_unref (message);
658 check_no_leftovers (BusContext *context)
660 CheckNoMessagesData nmd;
663 bus_test_clients_foreach (check_no_messages_foreach,
672 /* returns TRUE if the correct thing happens,
673 * but the correct thing may include OOM errors.
676 check_hello_message (BusContext *context,
677 DBusConnection *connection)
679 DBusMessage *message;
687 dbus_error_init (&error);
692 message = dbus_message_new_method_call (DBUS_MESSAGE_HELLO,
693 DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
698 if (!dbus_connection_send (connection, message, &serial))
700 dbus_message_unref (message);
704 dbus_message_unref (message);
707 /* send our message */
708 bus_test_run_clients_loop (TRUE);
710 dbus_connection_ref (connection); /* because we may get disconnected */
711 block_connection_until_message_from_bus (context, connection);
713 if (!dbus_connection_get_is_connected (connection))
715 _dbus_verbose ("connection was disconnected\n");
717 dbus_connection_unref (connection);
722 dbus_connection_unref (connection);
724 message = pop_message_waiting_for_memory (connection);
727 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
728 DBUS_MESSAGE_HELLO, serial, connection);
732 _dbus_verbose ("Received %s on %p\n",
733 dbus_message_get_name (message), connection);
735 if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
737 _dbus_warn ("Message has wrong sender %s\n",
738 dbus_message_get_sender (message) ?
739 dbus_message_get_sender (message) : "(none)");
743 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
745 if (dbus_message_has_name (message,
746 DBUS_ERROR_NO_MEMORY))
748 ; /* good, this is a valid response */
752 _dbus_warn ("Did not expect error %s\n",
753 dbus_message_get_name (message));
759 CheckServiceCreatedData scd;
761 if (dbus_message_has_name (message,
764 ; /* good, expected */
768 _dbus_warn ("Did not expect reply %s\n",
769 dbus_message_get_name (message));
773 retry_get_hello_name:
774 if (!dbus_message_get_args (message, &error,
775 DBUS_TYPE_STRING, &name,
778 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
780 _dbus_verbose ("no memory to get service name arg from hello\n");
781 dbus_error_free (&error);
782 _dbus_wait_for_memory ();
783 goto retry_get_hello_name;
787 _dbus_assert (dbus_error_is_set (&error));
788 _dbus_warn ("Did not get the expected single string argument to hello\n");
793 _dbus_verbose ("Got hello name: %s\n", name);
795 while (!dbus_bus_set_base_service (connection, name))
796 _dbus_wait_for_memory ();
798 scd.skip_connection = NULL;
800 scd.expected_service_name = name;
801 bus_test_clients_foreach (check_service_created_foreach,
807 /* Client should also have gotten ServiceAcquired */
808 dbus_message_unref (message);
809 message = pop_message_waiting_for_memory (connection);
812 _dbus_warn ("Expecting %s, got nothing\n",
813 DBUS_MESSAGE_SERVICE_ACQUIRED);
817 retry_get_acquired_name:
818 if (!dbus_message_get_args (message, &error,
819 DBUS_TYPE_STRING, &acquired,
822 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
824 _dbus_verbose ("no memory to get service name arg from acquired\n");
825 dbus_error_free (&error);
826 _dbus_wait_for_memory ();
827 goto retry_get_acquired_name;
831 _dbus_assert (dbus_error_is_set (&error));
832 _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");
837 _dbus_verbose ("Got acquired name: %s\n", acquired);
839 if (strcmp (acquired, name) != 0)
841 _dbus_warn ("Acquired name is %s but expected %s\n",
847 if (!check_no_leftovers (context))
853 dbus_error_free (&error);
856 dbus_free (acquired);
859 dbus_message_unref (message);
864 /* returns TRUE if the correct thing happens,
865 * but the correct thing may include OOM errors.
868 check_hello_connection (BusContext *context)
870 DBusConnection *connection;
873 dbus_error_init (&error);
875 connection = dbus_connection_open ("debug-pipe:name=test-server", &error);
876 if (connection == NULL)
878 _DBUS_ASSERT_ERROR_IS_SET (&error);
879 dbus_error_free (&error);
883 if (!bus_setup_debug_client (connection))
885 dbus_connection_disconnect (connection);
886 dbus_connection_unref (connection);
890 if (!check_hello_message (context, connection))
893 if (dbus_bus_get_base_service (connection) == NULL)
895 /* We didn't successfully register, so we can't
896 * do the usual kill_client_connection() checks
898 kill_client_connection_unchecked (connection);
902 kill_client_connection (context, connection);
908 #define NONEXISTENT_SERVICE_NAME "test.this.service.does.not.exist.ewuoiurjdfxcvn"
910 /* returns TRUE if the correct thing happens,
911 * but the correct thing may include OOM errors.
914 check_nonexistent_service_activation (BusContext *context,
915 DBusConnection *connection)
917 DBusMessage *message;
922 dbus_error_init (&error);
924 message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
925 DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
930 if (!dbus_message_append_args (message,
931 DBUS_TYPE_STRING, NONEXISTENT_SERVICE_NAME,
935 dbus_message_unref (message);
939 if (!dbus_connection_send (connection, message, &serial))
941 dbus_message_unref (message);
945 dbus_message_unref (message);
948 bus_test_run_everything (context);
949 block_connection_until_message_from_bus (context, connection);
950 bus_test_run_everything (context);
952 if (!dbus_connection_get_is_connected (connection))
954 _dbus_verbose ("connection was disconnected\n");
960 message = pop_message_waiting_for_memory (connection);
963 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
964 DBUS_MESSAGE_ACTIVATE_SERVICE, serial, connection);
968 _dbus_verbose ("Received %s on %p\n",
969 dbus_message_get_name (message), connection);
971 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
973 if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
975 _dbus_warn ("Message has wrong sender %s\n",
976 dbus_message_get_sender (message) ?
977 dbus_message_get_sender (message) : "(none)");
981 if (dbus_message_has_name (message,
982 DBUS_ERROR_NO_MEMORY))
984 ; /* good, this is a valid response */
986 else if (dbus_message_has_name (message,
987 DBUS_ERROR_ACTIVATE_SERVICE_NOT_FOUND))
989 ; /* good, this is expected also */
993 _dbus_warn ("Did not expect error %s\n",
994 dbus_message_get_name (message));
1000 _dbus_warn ("Did not expect to successfully activate %s\n",
1001 NONEXISTENT_SERVICE_NAME);
1009 dbus_message_unref (message);
1015 check_base_service_activated (BusContext *context,
1016 DBusConnection *connection,
1017 DBusMessage *initial_message,
1018 char **base_service_p)
1020 DBusMessage *message;
1025 base_service = NULL;
1028 dbus_error_init (&error);
1030 message = initial_message;
1031 dbus_message_ref (message);
1033 if (dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_CREATED))
1036 CheckServiceCreatedData scd;
1038 reget_service_name_arg:
1039 if (!dbus_message_get_args (message, &error,
1040 DBUS_TYPE_STRING, &service_name,
1043 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1045 dbus_error_free (&error);
1046 _dbus_wait_for_memory ();
1047 goto reget_service_name_arg;
1051 _dbus_warn ("Message %s doesn't have a service name: %s\n",
1052 dbus_message_get_name (message),
1054 dbus_error_free (&error);
1059 if (*service_name != ':')
1061 _dbus_warn ("Expected base service activation, got \"%s\" instead\n",
1066 base_service = service_name;
1067 service_name = NULL;
1069 scd.skip_connection = connection;
1071 scd.expected_service_name = base_service;
1072 bus_test_clients_foreach (check_service_created_foreach,
1080 _dbus_warn ("Expected to get base service ServiceCreated, instead got %s\n",
1081 dbus_message_get_name (message));
1089 *base_service_p = base_service;
1090 base_service = NULL;
1095 dbus_message_unref (message);
1098 dbus_free (base_service);
1104 check_service_activated (BusContext *context,
1105 DBusConnection *connection,
1106 const char *activated_name,
1107 const char *base_service_name,
1108 DBusMessage *initial_message)
1110 DBusMessage *message;
1113 dbus_uint32_t activation_result;
1117 dbus_error_init (&error);
1119 message = initial_message;
1120 dbus_message_ref (message);
1122 if (dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_CREATED))
1125 CheckServiceCreatedData scd;
1127 reget_service_name_arg:
1128 if (!dbus_message_get_args (message, &error,
1129 DBUS_TYPE_STRING, &service_name,
1132 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1134 dbus_error_free (&error);
1135 _dbus_wait_for_memory ();
1136 goto reget_service_name_arg;
1140 _dbus_warn ("Message %s doesn't have a service name: %s\n",
1141 dbus_message_get_name (message),
1143 dbus_error_free (&error);
1148 if (strcmp (service_name, activated_name) != 0)
1150 _dbus_warn ("Expected to see service %s created, saw %s instead\n",
1151 activated_name, service_name);
1152 dbus_free (service_name);
1156 scd.skip_connection = connection;
1158 scd.expected_service_name = service_name;
1159 bus_test_clients_foreach (check_service_created_foreach,
1162 dbus_free (service_name);
1167 dbus_message_unref (message);
1168 message = pop_message_waiting_for_memory (connection);
1169 if (message == NULL)
1171 _dbus_warn ("Expected a reply to %s, got nothing\n",
1172 DBUS_MESSAGE_ACTIVATE_SERVICE);
1178 _dbus_warn ("Expected to get service %s ServiceCreated, instead got %s\n",
1179 activated_name, dbus_message_get_name (message));
1183 if (!dbus_message_has_name (message, DBUS_MESSAGE_ACTIVATE_SERVICE))
1185 _dbus_warn ("Expected reply to %s, got message %s instead\n",
1186 DBUS_MESSAGE_ACTIVATE_SERVICE,
1187 dbus_message_get_name (message));
1191 activation_result = 0;
1192 if (!dbus_message_get_args (message, &error,
1193 DBUS_TYPE_UINT32, &activation_result,
1196 if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1198 _dbus_warn ("Did not have activation result first argument to %s: %s\n",
1199 DBUS_MESSAGE_ACTIVATE_SERVICE, error.message);
1200 dbus_error_free (&error);
1204 dbus_error_free (&error);
1208 if (activation_result == DBUS_ACTIVATION_REPLY_ACTIVATED)
1210 else if (activation_result == DBUS_ACTIVATION_REPLY_ALREADY_ACTIVE)
1214 _dbus_warn ("Activation result was 0x%x, no good.\n",
1220 dbus_message_unref (message);
1223 if (!check_no_leftovers (context))
1225 _dbus_warn ("Messages were left over after verifying existent activation results\n");
1233 dbus_message_unref (message);
1239 check_service_deactivated (BusContext *context,
1240 DBusConnection *connection,
1241 const char *activated_name,
1242 const char *base_service)
1244 DBusMessage *message;
1247 CheckServiceDeletedData csdd;
1252 dbus_error_init (&error);
1254 /* Now we are expecting ServiceDeleted messages for the base
1255 * service and the activated_name. The base service
1256 * notification is required to come last.
1258 csdd.expected_service_name = activated_name;
1259 csdd.failed = FALSE;
1260 bus_test_clients_foreach (check_service_deleted_foreach,
1266 csdd.expected_service_name = base_service;
1267 csdd.failed = FALSE;
1268 bus_test_clients_foreach (check_service_deleted_foreach,
1274 if (!check_no_leftovers (context))
1276 _dbus_warn ("Messages were left over after verifying results of service exiting\n");
1284 dbus_message_unref (message);
1290 check_send_exit_to_service (BusContext *context,
1291 DBusConnection *connection,
1292 const char *service_name,
1293 const char *base_service)
1295 dbus_bool_t got_error;
1296 DBusMessage *message;
1297 dbus_int32_t serial;
1300 _dbus_verbose ("Sending exit message to the test service\n");
1304 /* Kill off the test service by sending it a quit message */
1305 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteExit",
1308 if (message == NULL)
1310 /* Do this again; we still need the service to exit... */
1311 if (!check_send_exit_to_service (context, connection,
1312 service_name, base_service))
1318 if (!dbus_connection_send (connection, message, &serial))
1320 dbus_message_unref (message);
1322 /* Do this again; we still need the service to exit... */
1323 if (!check_send_exit_to_service (context, connection,
1324 service_name, base_service))
1330 dbus_message_unref (message);
1334 bus_test_run_clients_loop (TRUE);
1336 /* read it in and write it out to test service */
1337 bus_test_run_bus_loop (context, FALSE);
1339 /* see if we got an error during message bus dispatching */
1340 bus_test_run_clients_loop (FALSE);
1341 message = dbus_connection_borrow_message (connection);
1342 got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
1345 dbus_connection_return_message (connection, message);
1351 /* If no error, wait for the test service to exit */
1352 block_connection_until_message_from_bus (context, connection);
1354 bus_test_run_everything (context);
1359 message = pop_message_waiting_for_memory (connection);
1360 _dbus_assert (message != NULL);
1362 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1364 _dbus_warn ("expecting an error reply to asking test service to exit, got %s\n",
1365 dbus_message_get_name (message));
1368 else if (!dbus_message_has_name (message, DBUS_ERROR_NO_MEMORY))
1370 _dbus_warn ("not expecting error %s when asking test service to exit\n",
1371 dbus_message_get_name (message));
1375 _dbus_verbose ("Got error %s when asking test service to exit\n",
1376 dbus_message_get_name (message));
1378 /* Do this again; we still need the service to exit... */
1379 if (!check_send_exit_to_service (context, connection,
1380 service_name, base_service))
1385 if (!check_service_deactivated (context, connection,
1386 service_name, base_service))
1394 dbus_message_unref (message);
1400 check_got_error (BusContext *context,
1401 DBusConnection *connection,
1402 const char *first_error_name,
1405 DBusMessage *message;
1408 dbus_bool_t error_found;
1409 const char *error_name;
1413 message = pop_message_waiting_for_memory (connection);
1414 if (message == NULL)
1416 _dbus_warn ("Did not get an expected error\n");
1420 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1422 _dbus_warn ("Expected an error, got %s\n",
1423 dbus_message_get_name (message));
1427 error_found = FALSE;
1429 va_start (ap, first_error_name);
1430 error_name = first_error_name;
1431 while (error_name != NULL)
1433 if (dbus_message_has_name (message, error_name))
1438 error_name = va_arg (ap, char*);
1444 _dbus_warn ("Expected error %s or other, got %s instead\n",
1446 dbus_message_get_name (message));
1454 dbus_message_unref (message);
1459 #define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService"
1461 /* returns TRUE if the correct thing happens,
1462 * but the correct thing may include OOM errors.
1465 check_existent_service_activation (BusContext *context,
1466 DBusConnection *connection)
1468 DBusMessage *message;
1469 dbus_int32_t serial;
1474 base_service = NULL;
1476 dbus_error_init (&error);
1478 message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
1479 DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
1481 if (message == NULL)
1484 if (!dbus_message_append_args (message,
1485 DBUS_TYPE_STRING, EXISTENT_SERVICE_NAME,
1486 DBUS_TYPE_UINT32, 0,
1489 dbus_message_unref (message);
1493 if (!dbus_connection_send (connection, message, &serial))
1495 dbus_message_unref (message);
1499 dbus_message_unref (message);
1502 bus_test_run_everything (context);
1504 /* now wait for the message bus to hear back from the activated
1507 block_connection_until_message_from_bus (context, connection);
1509 bus_test_run_everything (context);
1511 if (!dbus_connection_get_is_connected (connection))
1513 _dbus_verbose ("connection was disconnected\n");
1519 message = pop_message_waiting_for_memory (connection);
1520 if (message == NULL)
1522 _dbus_warn ("Did not receive any messages after %s %d on %p\n",
1523 DBUS_MESSAGE_ACTIVATE_SERVICE, serial, connection);
1527 _dbus_verbose ("Received %s on %p after sending %s\n",
1528 dbus_message_get_name (message), connection,
1529 DBUS_MESSAGE_ACTIVATE_SERVICE);
1531 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1533 if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
1535 _dbus_warn ("Message has wrong sender %s\n",
1536 dbus_message_get_sender (message) ?
1537 dbus_message_get_sender (message) : "(none)");
1541 if (dbus_message_has_name (message,
1542 DBUS_ERROR_NO_MEMORY))
1544 ; /* good, this is a valid response */
1546 else if (dbus_message_has_name (message,
1547 DBUS_ERROR_SPAWN_CHILD_EXITED))
1549 ; /* good, this is expected also */
1553 _dbus_warn ("Did not expect error %s\n",
1554 dbus_message_get_name (message));
1560 dbus_bool_t got_service_deleted;
1561 dbus_bool_t got_error;
1563 if (!check_base_service_activated (context, connection,
1564 message, &base_service))
1567 dbus_message_unref (message);
1570 /* We may need to block here for the test service to exit or finish up */
1571 block_connection_until_message_from_bus (context, connection);
1573 message = dbus_connection_borrow_message (connection);
1574 if (message == NULL)
1576 _dbus_warn ("Did not receive any messages after base service creation notification\n");
1580 got_service_deleted = dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_DELETED);
1581 got_error = dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
1583 dbus_connection_return_message (connection, message);
1588 if (!check_got_error (context, connection,
1589 DBUS_ERROR_SPAWN_CHILD_EXITED,
1590 DBUS_ERROR_NO_MEMORY,
1594 /* A service deleted should be coming along now after this error.
1595 * We can also get the error *after* the service deleted.
1597 got_service_deleted = TRUE;
1600 if (got_service_deleted)
1602 /* The service started up and got a base address, but then
1603 * failed to register under EXISTENT_SERVICE_NAME
1605 CheckServiceDeletedData csdd;
1607 csdd.expected_service_name = base_service;
1608 csdd.failed = FALSE;
1609 bus_test_clients_foreach (check_service_deleted_foreach,
1615 /* Now we should get an error about the service exiting
1616 * if we didn't get it before.
1620 block_connection_until_message_from_bus (context, connection);
1622 /* and process everything again */
1623 bus_test_run_everything (context);
1625 if (!check_got_error (context, connection,
1626 DBUS_ERROR_SPAWN_CHILD_EXITED,
1633 message = pop_message_waiting_for_memory (connection);
1634 if (message == NULL)
1636 _dbus_warn ("Failed to pop message we just put back! should have been a ServiceCreated\n");
1640 if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
1641 base_service, message))
1644 dbus_message_unref (message);
1648 if (!check_no_leftovers (context))
1650 _dbus_warn ("Messages were left over after successful activation\n");
1654 if (!check_send_exit_to_service (context, connection,
1655 EXISTENT_SERVICE_NAME, base_service))
1664 dbus_message_unref (message);
1667 dbus_free (base_service);
1672 /* returns TRUE if the correct thing happens,
1673 * but the correct thing may include OOM errors.
1676 check_segfault_service_activation (BusContext *context,
1677 DBusConnection *connection)
1679 DBusMessage *message;
1680 dbus_int32_t serial;
1684 dbus_error_init (&error);
1686 message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
1687 DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
1689 if (message == NULL)
1692 if (!dbus_message_append_args (message,
1694 "org.freedesktop.DBus.TestSuiteSegfaultService",
1695 DBUS_TYPE_UINT32, 0,
1698 dbus_message_unref (message);
1702 if (!dbus_connection_send (connection, message, &serial))
1704 dbus_message_unref (message);
1708 dbus_message_unref (message);
1711 bus_test_run_everything (context);
1712 block_connection_until_message_from_bus (context, connection);
1713 bus_test_run_everything (context);
1715 if (!dbus_connection_get_is_connected (connection))
1717 _dbus_verbose ("connection was disconnected\n");
1723 message = pop_message_waiting_for_memory (connection);
1724 if (message == NULL)
1726 _dbus_warn ("Did not receive a reply to %s %d on %p\n",
1727 DBUS_MESSAGE_ACTIVATE_SERVICE, serial, connection);
1731 _dbus_verbose ("Received %s on %p\n",
1732 dbus_message_get_name (message), connection);
1734 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1736 if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
1738 _dbus_warn ("Message has wrong sender %s\n",
1739 dbus_message_get_sender (message) ?
1740 dbus_message_get_sender (message) : "(none)");
1744 if (dbus_message_has_name (message,
1745 DBUS_ERROR_NO_MEMORY))
1747 ; /* good, this is a valid response */
1749 else if (dbus_message_has_name (message,
1750 DBUS_ERROR_SPAWN_CHILD_SIGNALED))
1752 ; /* good, this is expected also */
1756 _dbus_warn ("Did not expect error %s\n",
1757 dbus_message_get_name (message));
1763 _dbus_warn ("Did not expect to successfully activate segfault service\n");
1771 dbus_message_unref (message);
1779 BusContext *context;
1783 check_oom_check1_func (void *data)
1785 Check1Data *d = data;
1787 if (! (* d->func) (d->context))
1790 if (!check_no_leftovers (d->context))
1792 _dbus_warn ("Messages were left over, should be covered by test suite\n");
1800 check1_try_iterations (BusContext *context,
1801 const char *description,
1807 d.context = context;
1809 if (!_dbus_test_oom_handling (description, check_oom_check1_func,
1811 _dbus_assert_not_reached ("test failed");
1817 BusContext *context;
1818 DBusConnection *connection;
1822 check_oom_check2_func (void *data)
1824 Check2Data *d = data;
1826 if (! (* d->func) (d->context, d->connection))
1829 if (!check_no_leftovers (d->context))
1831 _dbus_warn ("Messages were left over, should be covered by test suite");
1839 check2_try_iterations (BusContext *context,
1840 DBusConnection *connection,
1841 const char *description,
1847 d.context = context;
1848 d.connection = connection;
1850 if (!_dbus_test_oom_handling (description, check_oom_check2_func,
1852 _dbus_assert_not_reached ("test failed");
1856 bus_dispatch_test (const DBusString *test_data_dir)
1858 BusContext *context;
1859 DBusConnection *foo;
1860 DBusConnection *bar;
1861 DBusConnection *baz;
1864 dbus_error_init (&error);
1866 context = bus_context_new_test (test_data_dir,
1867 "valid-config-files/debug-allow-all.conf");
1868 if (context == NULL)
1871 foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
1873 _dbus_assert_not_reached ("could not alloc connection");
1875 if (!bus_setup_debug_client (foo))
1876 _dbus_assert_not_reached ("could not set up connection");
1878 if (!check_hello_message (context, foo))
1879 _dbus_assert_not_reached ("hello message failed");
1881 bar = dbus_connection_open ("debug-pipe:name=test-server", &error);
1883 _dbus_assert_not_reached ("could not alloc connection");
1885 if (!bus_setup_debug_client (bar))
1886 _dbus_assert_not_reached ("could not set up connection");
1888 if (!check_hello_message (context, bar))
1889 _dbus_assert_not_reached ("hello message failed");
1891 baz = dbus_connection_open ("debug-pipe:name=test-server", &error);
1893 _dbus_assert_not_reached ("could not alloc connection");
1895 if (!bus_setup_debug_client (baz))
1896 _dbus_assert_not_reached ("could not set up connection");
1898 if (!check_hello_message (context, baz))
1899 _dbus_assert_not_reached ("hello message failed");
1901 if (!check_no_leftovers (context))
1903 _dbus_warn ("Messages were left over after setting up initial connections");
1904 _dbus_assert_not_reached ("initial connection setup failed");
1907 check1_try_iterations (context, "create_and_hello",
1908 check_hello_connection);
1910 check2_try_iterations (context, foo, "nonexistent_service_activation",
1911 check_nonexistent_service_activation);
1913 check2_try_iterations (context, foo, "segfault_service_activation",
1914 check_segfault_service_activation);
1916 check2_try_iterations (context, foo, "existent_service_activation",
1917 check_existent_service_activation);
1919 _dbus_verbose ("Disconnecting foo, bar, and baz\n");
1921 kill_client_connection_unchecked (foo);
1922 kill_client_connection_unchecked (bar);
1923 kill_client_connection_unchecked (baz);
1925 bus_context_unref (context);
1931 bus_dispatch_sha1_test (const DBusString *test_data_dir)
1933 BusContext *context;
1934 DBusConnection *foo;
1937 dbus_error_init (&error);
1939 /* Test SHA1 authentication */
1940 _dbus_verbose ("Testing SHA1 context\n");
1942 context = bus_context_new_test (test_data_dir,
1943 "valid-config-files/debug-allow-all-sha1.conf");
1944 if (context == NULL)
1947 foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
1949 _dbus_assert_not_reached ("could not alloc connection");
1951 if (!bus_setup_debug_client (foo))
1952 _dbus_assert_not_reached ("could not set up connection");
1954 if (!check_hello_message (context, foo))
1955 _dbus_assert_not_reached ("hello message failed");
1957 if (!check_no_leftovers (context))
1959 _dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
1960 _dbus_assert_not_reached ("initial connection setup failed");
1963 check1_try_iterations (context, "create_and_hello_sha1",
1964 check_hello_connection);
1966 kill_client_connection_unchecked (foo);
1968 bus_context_unref (context);
1973 #endif /* DBUS_BUILD_TESTS */