1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* driver.c Bus client (driver)
4 * Copyright (C) 2003 CodeFactory AB
5 * Copyright (C) 2003, 2004, 2005 Red Hat, Inc.
7 * Licensed under the Academic Free License version 2.1
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "activation.h"
27 #include "connection.h"
34 #include <dbus/dbus-string.h>
35 #include <dbus/dbus-internals.h>
36 #include <dbus/dbus-message.h>
37 #include <dbus/dbus-marshal-recursive.h>
40 static dbus_bool_t bus_driver_send_welcome_message (DBusConnection *connection,
41 DBusMessage *hello_message,
42 BusTransaction *transaction,
46 bus_driver_send_service_owner_changed (const char *service_name,
47 const char *old_owner,
48 const char *new_owner,
49 BusTransaction *transaction,
54 const char *null_service;
56 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
59 _dbus_verbose ("sending name owner changed: %s [%s -> %s]\n",
61 old_owner ? old_owner : null_service,
62 new_owner ? new_owner : null_service);
64 message = dbus_message_new_signal (DBUS_PATH_DBUS,
74 if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS))
77 if (!dbus_message_append_args (message,
78 DBUS_TYPE_STRING, &service_name,
79 DBUS_TYPE_STRING, old_owner ? &old_owner : &null_service,
80 DBUS_TYPE_STRING, new_owner ? &new_owner : &null_service,
84 _dbus_assert (dbus_message_has_signature (message, "sss"));
86 retval = bus_dispatch_matches (transaction, NULL, NULL, message, error);
87 dbus_message_unref (message);
92 dbus_message_unref (message);
98 bus_driver_send_service_lost (DBusConnection *connection,
99 const char *service_name,
100 BusTransaction *transaction,
103 DBusMessage *message;
105 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
107 message = dbus_message_new_signal (DBUS_PATH_DBUS,
117 if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||
118 !dbus_message_append_args (message,
119 DBUS_TYPE_STRING, &service_name,
122 dbus_message_unref (message);
127 if (!bus_transaction_send_from_driver (transaction, connection, message))
129 dbus_message_unref (message);
135 dbus_message_unref (message);
141 bus_driver_send_service_acquired (DBusConnection *connection,
142 const char *service_name,
143 BusTransaction *transaction,
146 DBusMessage *message;
148 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
150 message = dbus_message_new_signal (DBUS_PATH_DBUS,
160 if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||
161 !dbus_message_append_args (message,
162 DBUS_TYPE_STRING, &service_name,
165 dbus_message_unref (message);
170 if (!bus_transaction_send_from_driver (transaction, connection, message))
172 dbus_message_unref (message);
178 dbus_message_unref (message);
184 create_unique_client_name (BusRegistry *registry,
187 /* We never want to use the same unique client name twice, because
188 * we want to guarantee that if you send a message to a given unique
189 * name, you always get the same application. So we use two numbers
190 * for INT_MAX * INT_MAX combinations, should be pretty safe against
193 /* FIXME these should be in BusRegistry rather than static vars */
194 static int next_major_number = 0;
195 static int next_minor_number = 0;
198 len = _dbus_string_get_length (str);
202 /* start out with 1-0, go to 1-1, 1-2, 1-3,
203 * up to 1-MAXINT, then 2-0, 2-1, etc.
205 if (next_minor_number <= 0)
207 next_major_number += 1;
208 next_minor_number = 0;
209 if (next_major_number <= 0)
210 _dbus_assert_not_reached ("INT_MAX * INT_MAX clients were added");
213 _dbus_assert (next_major_number > 0);
214 _dbus_assert (next_minor_number >= 0);
216 /* appname:MAJOR-MINOR */
218 if (!_dbus_string_append (str, ":"))
221 if (!_dbus_string_append_int (str, next_major_number))
224 if (!_dbus_string_append (str, "."))
227 if (!_dbus_string_append_int (str, next_minor_number))
230 next_minor_number += 1;
232 /* Check if a client with the name exists */
233 if (bus_registry_lookup (registry, str) == NULL)
236 /* drop the number again, try the next one. */
237 _dbus_string_set_length (str, len);
244 bus_driver_handle_hello (DBusConnection *connection,
245 BusTransaction *transaction,
246 DBusMessage *message,
249 DBusString unique_name;
252 BusRegistry *registry;
253 BusConnections *connections;
255 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
257 if (bus_connection_is_active (connection))
259 /* We already handled an Hello message for this connection. */
260 dbus_set_error (error, DBUS_ERROR_FAILED,
261 "Already handled an Hello message");
265 /* Note that when these limits are exceeded we don't disconnect the
266 * connection; we just sort of leave it hanging there until it times
267 * out or disconnects itself or is dropped due to the max number of
268 * incomplete connections. It's even OK if the connection wants to
269 * retry the hello message, we support that.
271 connections = bus_connection_get_connections (connection);
272 if (!bus_connections_check_limits (connections, connection,
275 _DBUS_ASSERT_ERROR_IS_SET (error);
279 if (!_dbus_string_init (&unique_name))
287 registry = bus_connection_get_registry (connection);
289 if (!create_unique_client_name (registry, &unique_name))
295 if (!bus_connection_complete (connection, &unique_name, error))
297 _DBUS_ASSERT_ERROR_IS_SET (error);
301 if (!dbus_message_set_sender (message,
302 bus_connection_get_name (connection)))
308 if (!bus_driver_send_welcome_message (connection, message, transaction, error))
311 /* Create the service */
312 service = bus_registry_ensure (registry,
313 &unique_name, connection, 0, transaction, error);
317 _dbus_assert (bus_connection_is_active (connection));
321 _dbus_string_free (&unique_name);
326 bus_driver_send_welcome_message (DBusConnection *connection,
327 DBusMessage *hello_message,
328 BusTransaction *transaction,
331 DBusMessage *welcome;
334 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
336 name = bus_connection_get_name (connection);
337 _dbus_assert (name != NULL);
339 welcome = dbus_message_new_method_return (hello_message);
346 if (!dbus_message_append_args (welcome,
347 DBUS_TYPE_STRING, &name,
350 dbus_message_unref (welcome);
355 _dbus_assert (dbus_message_has_signature (welcome, DBUS_TYPE_STRING_AS_STRING));
357 if (!bus_transaction_send_from_driver (transaction, connection, welcome))
359 dbus_message_unref (welcome);
365 dbus_message_unref (welcome);
371 bus_driver_handle_list_services (DBusConnection *connection,
372 BusTransaction *transaction,
373 DBusMessage *message,
379 BusRegistry *registry;
381 DBusMessageIter iter;
384 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
386 registry = bus_connection_get_registry (connection);
388 reply = dbus_message_new_method_return (message);
395 if (!bus_registry_list_services (registry, &services, &len))
397 dbus_message_unref (reply);
402 dbus_message_iter_init_append (reply, &iter);
404 if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
405 DBUS_TYPE_STRING_AS_STRING,
408 dbus_free_string_array (services);
409 dbus_message_unref (reply);
415 /* Include the bus driver in the list */
416 const char *v_STRING = DBUS_SERVICE_DBUS;
417 if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
420 dbus_free_string_array (services);
421 dbus_message_unref (reply);
430 if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
433 dbus_free_string_array (services);
434 dbus_message_unref (reply);
441 dbus_free_string_array (services);
443 if (!dbus_message_iter_close_container (&iter, &sub))
445 dbus_message_unref (reply);
450 if (!bus_transaction_send_from_driver (transaction, connection, reply))
452 dbus_message_unref (reply);
458 dbus_message_unref (reply);
464 bus_driver_handle_list_activatable_services (DBusConnection *connection,
465 BusTransaction *transaction,
466 DBusMessage *message,
472 BusActivation *activation;
474 DBusMessageIter iter;
477 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
479 activation = bus_connection_get_activation (connection);
481 reply = dbus_message_new_method_return (message);
488 if (!bus_activation_list_services (activation, &services, &len))
490 dbus_message_unref (reply);
495 dbus_message_iter_init_append (reply, &iter);
497 if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
498 DBUS_TYPE_STRING_AS_STRING,
501 dbus_free_string_array (services);
502 dbus_message_unref (reply);
508 /* Include the bus driver in the list */
509 const char *v_STRING = DBUS_SERVICE_DBUS;
510 if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
513 dbus_free_string_array (services);
514 dbus_message_unref (reply);
523 if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,
526 dbus_free_string_array (services);
527 dbus_message_unref (reply);
534 dbus_free_string_array (services);
536 if (!dbus_message_iter_close_container (&iter, &sub))
538 dbus_message_unref (reply);
543 if (!bus_transaction_send_from_driver (transaction, connection, reply))
545 dbus_message_unref (reply);
551 dbus_message_unref (reply);
557 bus_driver_handle_acquire_service (DBusConnection *connection,
558 BusTransaction *transaction,
559 DBusMessage *message,
563 DBusString service_name;
565 dbus_uint32_t service_reply;
568 BusRegistry *registry;
570 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
572 registry = bus_connection_get_registry (connection);
574 if (!dbus_message_get_args (message, error,
575 DBUS_TYPE_STRING, &name,
576 DBUS_TYPE_UINT32, &flags,
580 _dbus_verbose ("Trying to own name %s with flags 0x%x\n", name, flags);
585 _dbus_string_init_const (&service_name, name);
587 if (!bus_registry_acquire_service (registry, connection,
588 &service_name, flags,
589 &service_reply, transaction,
593 reply = dbus_message_new_method_return (message);
600 if (!dbus_message_append_args (reply, DBUS_TYPE_UINT32, &service_reply, DBUS_TYPE_INVALID))
606 if (!bus_transaction_send_from_driver (transaction, connection, reply))
616 dbus_message_unref (reply);
621 bus_driver_handle_release_service (DBusConnection *connection,
622 BusTransaction *transaction,
623 DBusMessage *message,
627 DBusString service_name;
629 dbus_uint32_t service_reply;
631 BusRegistry *registry;
633 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
635 registry = bus_connection_get_registry (connection);
637 if (!dbus_message_get_args (message, error,
638 DBUS_TYPE_STRING, &name,
642 _dbus_verbose ("Trying to release name %s\n", name);
647 _dbus_string_init_const (&service_name, name);
649 if (!bus_registry_release_service (registry, connection,
650 &service_name, &service_reply,
654 reply = dbus_message_new_method_return (message);
661 if (!dbus_message_append_args (reply, DBUS_TYPE_UINT32, &service_reply, DBUS_TYPE_INVALID))
667 if (!bus_transaction_send_from_driver (transaction, connection, reply))
677 dbus_message_unref (reply);
682 bus_driver_handle_service_exists (DBusConnection *connection,
683 BusTransaction *transaction,
684 DBusMessage *message,
688 DBusString service_name;
690 dbus_bool_t service_exists;
693 BusRegistry *registry;
695 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
697 registry = bus_connection_get_registry (connection);
699 if (!dbus_message_get_args (message, error,
700 DBUS_TYPE_STRING, &name,
706 if (strcmp (name, DBUS_SERVICE_DBUS) == 0)
708 service_exists = TRUE;
712 _dbus_string_init_const (&service_name, name);
713 service = bus_registry_lookup (registry, &service_name);
714 service_exists = service != NULL;
717 reply = dbus_message_new_method_return (message);
724 if (!dbus_message_append_args (reply,
725 DBUS_TYPE_BOOLEAN, &service_exists,
732 if (!bus_transaction_send_from_driver (transaction, connection, reply))
742 dbus_message_unref (reply);
748 bus_driver_handle_activate_service (DBusConnection *connection,
749 BusTransaction *transaction,
750 DBusMessage *message,
756 BusActivation *activation;
758 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
760 activation = bus_connection_get_activation (connection);
762 if (!dbus_message_get_args (message, error,
763 DBUS_TYPE_STRING, &name,
764 DBUS_TYPE_UINT32, &flags,
767 _DBUS_ASSERT_ERROR_IS_SET (error);
768 _dbus_verbose ("No memory to get arguments to StartServiceByName\n");
774 if (!bus_activation_activate_service (activation, connection, transaction, FALSE,
775 message, name, error))
777 _DBUS_ASSERT_ERROR_IS_SET (error);
778 _dbus_verbose ("bus_activation_activate_service() failed\n");
789 send_ack_reply (DBusConnection *connection,
790 BusTransaction *transaction,
791 DBusMessage *message,
796 if (dbus_message_get_no_reply (message))
799 reply = dbus_message_new_method_return (message);
806 if (!bus_transaction_send_from_driver (transaction, connection, reply))
809 dbus_message_unref (reply);
813 dbus_message_unref (reply);
819 bus_driver_handle_update_activation_environment (DBusConnection *connection,
820 BusTransaction *transaction,
821 DBusMessage *message,
825 BusActivation *activation;
826 DBusMessageIter iter;
827 DBusMessageIter dict_iter;
828 DBusMessageIter dict_entry_iter;
832 DBusList *keys, *key_link;
833 DBusList *values, *value_link;
835 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
837 activation = bus_connection_get_activation (connection);
839 dbus_message_iter_init (message, &iter);
841 /* The message signature has already been checked for us,
842 * so let's just assert it's right.
844 msg_type = dbus_message_iter_get_arg_type (&iter);
846 _dbus_assert (msg_type == DBUS_TYPE_ARRAY);
848 dbus_message_iter_recurse (&iter, &dict_iter);
852 /* Then loop through the sent dictionary, add the location of
853 * the environment keys and values to lists. The result will
854 * be in reverse order, so we don't have to constantly search
855 * for the end of the list in a loop.
859 while ((array_type = dbus_message_iter_get_arg_type (&dict_iter)) == DBUS_TYPE_DICT_ENTRY)
861 dbus_message_iter_recurse (&dict_iter, &dict_entry_iter);
863 while ((key_type = dbus_message_iter_get_arg_type (&dict_entry_iter)) == DBUS_TYPE_STRING)
869 dbus_message_iter_get_basic (&dict_entry_iter, &key);
870 dbus_message_iter_next (&dict_entry_iter);
872 value_type = dbus_message_iter_get_arg_type (&dict_entry_iter);
874 if (value_type != DBUS_TYPE_STRING)
877 dbus_message_iter_get_basic (&dict_entry_iter, &value);
879 if (!_dbus_list_append (&keys, key))
885 if (!_dbus_list_append (&values, value))
891 dbus_message_iter_next (&dict_entry_iter);
894 if (key_type != DBUS_TYPE_INVALID)
897 dbus_message_iter_next (&dict_iter);
900 if (array_type != DBUS_TYPE_INVALID)
903 _dbus_assert (_dbus_list_get_length (&keys) == _dbus_list_get_length (&values));
907 while (key_link != NULL)
912 key = key_link->data;
913 value = value_link->data;
915 if (!bus_activation_set_environment_variable (activation,
918 _DBUS_ASSERT_ERROR_IS_SET (error);
919 _dbus_verbose ("bus_activation_set_environment_variable() failed\n");
922 key_link = _dbus_list_get_next_link (&keys, key_link);
923 value_link = _dbus_list_get_next_link (&values, value_link);
926 /* FIXME: We can fail early having set only some of the environment variables,
927 * (because of OOM failure). It's sort of hard to fix and it doesn't really
928 * matter, so we're punting for now.
930 if (key_link != NULL)
933 if (!send_ack_reply (connection, transaction,
940 _dbus_list_clear (&keys);
941 _dbus_list_clear (&values);
946 bus_driver_handle_add_match (DBusConnection *connection,
947 BusTransaction *transaction,
948 DBusMessage *message,
954 BusMatchmaker *matchmaker;
956 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
961 if (bus_connection_get_n_match_rules (connection) >=
962 bus_context_get_max_match_rules_per_connection (bus_transaction_get_context (transaction)))
964 dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
965 "Connection \"%s\" is not allowed to add more match rules "
966 "(increase limits in configuration file if required)",
967 bus_connection_is_active (connection) ?
968 bus_connection_get_name (connection) :
973 if (!dbus_message_get_args (message, error,
974 DBUS_TYPE_STRING, &text,
977 _dbus_verbose ("No memory to get arguments to AddMatch\n");
981 _dbus_string_init_const (&str, text);
983 rule = bus_match_rule_parse (connection, &str, error);
987 matchmaker = bus_connection_get_matchmaker (connection);
989 if (!bus_matchmaker_add_rule (matchmaker, rule))
995 if (!send_ack_reply (connection, transaction,
998 bus_matchmaker_remove_rule (matchmaker, rule);
1002 bus_match_rule_unref (rule);
1007 _DBUS_ASSERT_ERROR_IS_SET (error);
1009 bus_match_rule_unref (rule);
1014 bus_driver_handle_remove_match (DBusConnection *connection,
1015 BusTransaction *transaction,
1016 DBusMessage *message,
1022 BusMatchmaker *matchmaker;
1024 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1029 if (!dbus_message_get_args (message, error,
1030 DBUS_TYPE_STRING, &text,
1033 _dbus_verbose ("No memory to get arguments to RemoveMatch\n");
1037 _dbus_string_init_const (&str, text);
1039 rule = bus_match_rule_parse (connection, &str, error);
1043 /* Send the ack before we remove the rule, since the ack is undone
1044 * on transaction cancel, but rule removal isn't.
1046 if (!send_ack_reply (connection, transaction,
1050 matchmaker = bus_connection_get_matchmaker (connection);
1052 if (!bus_matchmaker_remove_rule_by_value (matchmaker, rule, error))
1055 bus_match_rule_unref (rule);
1060 _DBUS_ASSERT_ERROR_IS_SET (error);
1062 bus_match_rule_unref (rule);
1067 bus_driver_handle_get_service_owner (DBusConnection *connection,
1068 BusTransaction *transaction,
1069 DBusMessage *message,
1073 const char *base_name;
1075 BusRegistry *registry;
1076 BusService *service;
1079 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1081 registry = bus_connection_get_registry (connection);
1086 if (! dbus_message_get_args (message, error,
1087 DBUS_TYPE_STRING, &text,
1091 _dbus_string_init_const (&str, text);
1092 service = bus_registry_lookup (registry, &str);
1093 if (service == NULL &&
1094 _dbus_string_equal_c_str (&str, DBUS_SERVICE_DBUS))
1096 /* ORG_FREEDESKTOP_DBUS owns itself */
1097 base_name = DBUS_SERVICE_DBUS;
1099 else if (service == NULL)
1101 dbus_set_error (error,
1102 DBUS_ERROR_NAME_HAS_NO_OWNER,
1103 "Could not get owner of name '%s': no such name", text);
1108 base_name = bus_connection_get_name (bus_service_get_primary_owners_connection (service));
1109 if (base_name == NULL)
1111 /* FIXME - how is this error possible? */
1112 dbus_set_error (error,
1114 "Could not determine unique name for '%s'", text);
1117 _dbus_assert (*base_name == ':');
1120 _dbus_assert (base_name != NULL);
1122 reply = dbus_message_new_method_return (message);
1126 if (! dbus_message_append_args (reply,
1127 DBUS_TYPE_STRING, &base_name,
1131 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1134 dbus_message_unref (reply);
1139 BUS_SET_OOM (error);
1142 _DBUS_ASSERT_ERROR_IS_SET (error);
1144 dbus_message_unref (reply);
1149 bus_driver_handle_list_queued_owners (DBusConnection *connection,
1150 BusTransaction *transaction,
1151 DBusMessage *message,
1155 DBusList *base_names;
1158 BusRegistry *registry;
1159 BusService *service;
1161 DBusMessageIter iter, array_iter;
1162 char *dbus_service_name = DBUS_SERVICE_DBUS;
1164 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1166 registry = bus_connection_get_registry (connection);
1172 if (! dbus_message_get_args (message, error,
1173 DBUS_TYPE_STRING, &text,
1177 _dbus_string_init_const (&str, text);
1178 service = bus_registry_lookup (registry, &str);
1179 if (service == NULL &&
1180 _dbus_string_equal_c_str (&str, DBUS_SERVICE_DBUS))
1182 /* ORG_FREEDESKTOP_DBUS owns itself */
1183 if (! _dbus_list_append (&base_names, dbus_service_name))
1186 else if (service == NULL)
1188 dbus_set_error (error,
1189 DBUS_ERROR_NAME_HAS_NO_OWNER,
1190 "Could not get owners of name '%s': no such name", text);
1195 if (!bus_service_list_queued_owners (service,
1201 _dbus_assert (base_names != NULL);
1203 reply = dbus_message_new_method_return (message);
1207 dbus_message_iter_init_append (reply, &iter);
1208 if (!dbus_message_iter_open_container (&iter,
1210 DBUS_TYPE_STRING_AS_STRING,
1214 link = _dbus_list_get_first_link (&base_names);
1215 while (link != NULL)
1219 _dbus_assert (link->data != NULL);
1220 uname = (char *)link->data;
1222 if (!dbus_message_iter_append_basic (&array_iter,
1227 link = _dbus_list_get_next_link (&base_names, link);
1230 if (! dbus_message_iter_close_container (&iter, &array_iter))
1234 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1237 dbus_message_unref (reply);
1242 BUS_SET_OOM (error);
1245 _DBUS_ASSERT_ERROR_IS_SET (error);
1247 dbus_message_unref (reply);
1250 _dbus_list_clear (&base_names);
1256 bus_driver_handle_get_connection_unix_user (DBusConnection *connection,
1257 BusTransaction *transaction,
1258 DBusMessage *message,
1261 const char *service;
1263 BusRegistry *registry;
1265 DBusConnection *conn;
1268 dbus_uint32_t uid32;
1270 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1272 registry = bus_connection_get_registry (connection);
1277 if (! dbus_message_get_args (message, error,
1278 DBUS_TYPE_STRING, &service,
1282 _dbus_verbose ("asked for UID of connection %s\n", service);
1284 _dbus_string_init_const (&str, service);
1285 serv = bus_registry_lookup (registry, &str);
1288 dbus_set_error (error,
1289 DBUS_ERROR_NAME_HAS_NO_OWNER,
1290 "Could not get UID of name '%s': no such name", service);
1294 conn = bus_service_get_primary_owners_connection (serv);
1296 reply = dbus_message_new_method_return (message);
1300 if (!dbus_connection_get_unix_user (conn, &uid))
1302 dbus_set_error (error,
1304 "Could not determine UID for '%s'", service);
1309 if (! dbus_message_append_args (reply,
1310 DBUS_TYPE_UINT32, &uid32,
1314 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1317 dbus_message_unref (reply);
1322 BUS_SET_OOM (error);
1325 _DBUS_ASSERT_ERROR_IS_SET (error);
1327 dbus_message_unref (reply);
1332 bus_driver_handle_get_connection_unix_process_id (DBusConnection *connection,
1333 BusTransaction *transaction,
1334 DBusMessage *message,
1337 const char *service;
1339 BusRegistry *registry;
1341 DBusConnection *conn;
1344 dbus_uint32_t pid32;
1346 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1348 registry = bus_connection_get_registry (connection);
1353 if (! dbus_message_get_args (message, error,
1354 DBUS_TYPE_STRING, &service,
1358 _dbus_verbose ("asked for PID of connection %s\n", service);
1360 _dbus_string_init_const (&str, service);
1361 serv = bus_registry_lookup (registry, &str);
1364 dbus_set_error (error,
1365 DBUS_ERROR_NAME_HAS_NO_OWNER,
1366 "Could not get PID of name '%s': no such name", service);
1370 conn = bus_service_get_primary_owners_connection (serv);
1372 reply = dbus_message_new_method_return (message);
1376 if (!dbus_connection_get_unix_process_id (conn, &pid))
1378 dbus_set_error (error,
1379 DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
1380 "Could not determine PID for '%s'", service);
1385 if (! dbus_message_append_args (reply,
1386 DBUS_TYPE_UINT32, &pid32,
1390 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1393 dbus_message_unref (reply);
1398 BUS_SET_OOM (error);
1401 _DBUS_ASSERT_ERROR_IS_SET (error);
1403 dbus_message_unref (reply);
1408 bus_driver_handle_get_adt_audit_session_data (DBusConnection *connection,
1409 BusTransaction *transaction,
1410 DBusMessage *message,
1413 const char *service;
1415 BusRegistry *registry;
1417 DBusConnection *conn;
1420 dbus_uint32_t data_size;
1422 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1424 registry = bus_connection_get_registry (connection);
1429 if (! dbus_message_get_args (message, error,
1430 DBUS_TYPE_STRING, &service,
1434 _dbus_verbose ("asked for audit session data for connection %s\n", service);
1436 _dbus_string_init_const (&str, service);
1437 serv = bus_registry_lookup (registry, &str);
1440 dbus_set_error (error,
1441 DBUS_ERROR_NAME_HAS_NO_OWNER,
1442 "Could not get audit session data for name '%s': no such name", service);
1446 conn = bus_service_get_primary_owners_connection (serv);
1448 reply = dbus_message_new_method_return (message);
1452 if (!dbus_connection_get_adt_audit_session_data (conn, &data, &data_size) || data == NULL)
1454 dbus_set_error (error,
1455 DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN,
1456 "Could not determine audit session data for '%s'", service);
1460 if (! dbus_message_append_args (reply,
1461 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &data, data_size,
1465 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1468 dbus_message_unref (reply);
1473 BUS_SET_OOM (error);
1476 _DBUS_ASSERT_ERROR_IS_SET (error);
1478 dbus_message_unref (reply);
1483 bus_driver_handle_get_connection_selinux_security_context (DBusConnection *connection,
1484 BusTransaction *transaction,
1485 DBusMessage *message,
1488 const char *service;
1490 BusRegistry *registry;
1492 DBusConnection *conn;
1494 BusSELinuxID *context;
1496 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1498 registry = bus_connection_get_registry (connection);
1503 if (! dbus_message_get_args (message, error,
1504 DBUS_TYPE_STRING, &service,
1508 _dbus_verbose ("asked for security context of connection %s\n", service);
1510 _dbus_string_init_const (&str, service);
1511 serv = bus_registry_lookup (registry, &str);
1514 dbus_set_error (error,
1515 DBUS_ERROR_NAME_HAS_NO_OWNER,
1516 "Could not get security context of name '%s': no such name", service);
1520 conn = bus_service_get_primary_owners_connection (serv);
1522 reply = dbus_message_new_method_return (message);
1526 context = bus_connection_get_selinux_id (conn);
1529 dbus_set_error (error,
1530 DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN,
1531 "Could not determine security context for '%s'", service);
1535 if (! bus_selinux_append_context (reply, context, error))
1538 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1541 dbus_message_unref (reply);
1546 BUS_SET_OOM (error);
1549 _DBUS_ASSERT_ERROR_IS_SET (error);
1551 dbus_message_unref (reply);
1556 bus_driver_handle_reload_config (DBusConnection *connection,
1557 BusTransaction *transaction,
1558 DBusMessage *message,
1561 BusContext *context;
1564 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1568 context = bus_connection_get_context (connection);
1569 if (!bus_context_reload_config (context, error))
1572 reply = dbus_message_new_method_return (message);
1576 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1579 dbus_message_unref (reply);
1583 BUS_SET_OOM (error);
1586 _DBUS_ASSERT_ERROR_IS_SET (error);
1588 dbus_message_unref (reply);
1593 bus_driver_handle_get_id (DBusConnection *connection,
1594 BusTransaction *transaction,
1595 DBusMessage *message,
1598 BusContext *context;
1601 const char *v_STRING;
1603 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1605 if (!_dbus_string_init (&uuid))
1607 BUS_SET_OOM (error);
1613 context = bus_connection_get_context (connection);
1614 if (!bus_context_get_id (context, &uuid))
1617 reply = dbus_message_new_method_return (message);
1621 v_STRING = _dbus_string_get_const_data (&uuid);
1622 if (!dbus_message_append_args (reply,
1623 DBUS_TYPE_STRING, &v_STRING,
1627 _dbus_assert (dbus_message_has_signature (reply, "s"));
1629 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1632 _dbus_string_free (&uuid);
1633 dbus_message_unref (reply);
1637 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1639 BUS_SET_OOM (error);
1642 dbus_message_unref (reply);
1643 _dbus_string_free (&uuid);
1650 const char *in_args;
1651 const char *out_args;
1652 dbus_bool_t (* handler) (DBusConnection *connection,
1653 BusTransaction *transaction,
1654 DBusMessage *message,
1658 /* For speed it might be useful to sort this in order of
1659 * frequency of use (but doesn't matter with only a few items
1662 static const MessageHandler dbus_message_handlers[] = {
1665 DBUS_TYPE_STRING_AS_STRING,
1666 bus_driver_handle_hello },
1668 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_UINT32_AS_STRING,
1669 DBUS_TYPE_UINT32_AS_STRING,
1670 bus_driver_handle_acquire_service },
1672 DBUS_TYPE_STRING_AS_STRING,
1673 DBUS_TYPE_UINT32_AS_STRING,
1674 bus_driver_handle_release_service },
1675 { "StartServiceByName",
1676 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_UINT32_AS_STRING,
1677 DBUS_TYPE_UINT32_AS_STRING,
1678 bus_driver_handle_activate_service },
1679 { "UpdateActivationEnvironment",
1680 DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
1682 bus_driver_handle_update_activation_environment },
1684 DBUS_TYPE_STRING_AS_STRING,
1685 DBUS_TYPE_BOOLEAN_AS_STRING,
1686 bus_driver_handle_service_exists },
1689 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
1690 bus_driver_handle_list_services },
1691 { "ListActivatableNames",
1693 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
1694 bus_driver_handle_list_activatable_services },
1696 DBUS_TYPE_STRING_AS_STRING,
1698 bus_driver_handle_add_match },
1700 DBUS_TYPE_STRING_AS_STRING,
1702 bus_driver_handle_remove_match },
1704 DBUS_TYPE_STRING_AS_STRING,
1705 DBUS_TYPE_STRING_AS_STRING,
1706 bus_driver_handle_get_service_owner },
1707 { "ListQueuedOwners",
1708 DBUS_TYPE_STRING_AS_STRING,
1709 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
1710 bus_driver_handle_list_queued_owners },
1711 { "GetConnectionUnixUser",
1712 DBUS_TYPE_STRING_AS_STRING,
1713 DBUS_TYPE_UINT32_AS_STRING,
1714 bus_driver_handle_get_connection_unix_user },
1715 { "GetConnectionUnixProcessID",
1716 DBUS_TYPE_STRING_AS_STRING,
1717 DBUS_TYPE_UINT32_AS_STRING,
1718 bus_driver_handle_get_connection_unix_process_id },
1719 { "GetAdtAuditSessionData",
1720 DBUS_TYPE_STRING_AS_STRING,
1721 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING,
1722 bus_driver_handle_get_adt_audit_session_data },
1723 { "GetConnectionSELinuxSecurityContext",
1724 DBUS_TYPE_STRING_AS_STRING,
1725 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING,
1726 bus_driver_handle_get_connection_selinux_security_context },
1730 bus_driver_handle_reload_config },
1733 DBUS_TYPE_STRING_AS_STRING,
1734 bus_driver_handle_get_id },
1735 { NULL, NULL, NULL, NULL }
1738 static dbus_bool_t bus_driver_handle_introspect (DBusConnection *,
1739 BusTransaction *, DBusMessage *, DBusError *);
1741 static const MessageHandler introspectable_message_handlers[] = {
1742 { "Introspect", "", DBUS_TYPE_STRING_AS_STRING, bus_driver_handle_introspect },
1743 { NULL, NULL, NULL, NULL }
1748 const MessageHandler *message_handlers;
1749 const char *extra_introspection;
1752 /* These should ideally be sorted by frequency of use, although it
1753 * probably doesn't matter with this few items */
1754 static InterfaceHandler interface_handlers[] = {
1755 { DBUS_INTERFACE_DBUS, dbus_message_handlers,
1756 " <signal name=\"NameOwnerChanged\">\n"
1757 " <arg type=\"s\"/>\n"
1758 " <arg type=\"s\"/>\n"
1759 " <arg type=\"s\"/>\n"
1761 " <signal name=\"NameLost\">\n"
1762 " <arg type=\"s\"/>\n"
1764 " <signal name=\"NameAcquired\">\n"
1765 " <arg type=\"s\"/>\n"
1767 { DBUS_INTERFACE_INTROSPECTABLE, introspectable_message_handlers, NULL },
1768 { NULL, NULL, NULL }
1772 write_args_for_direction (DBusString *xml,
1773 const char *signature,
1776 DBusTypeReader typereader;
1780 _dbus_string_init_const (&sigstr, signature);
1781 _dbus_type_reader_init_types_only (&typereader, &sigstr, 0);
1783 while ((current_type = _dbus_type_reader_get_current_type (&typereader)) != DBUS_TYPE_INVALID)
1785 const DBusString *subsig;
1788 _dbus_type_reader_get_signature (&typereader, &subsig, &start, &len);
1789 if (!_dbus_string_append_printf (xml, " <arg direction=\"%s\" type=\"",
1792 if (!_dbus_string_append_len (xml,
1793 _dbus_string_get_const_data (subsig) + start,
1796 if (!_dbus_string_append (xml, "\"/>\n"))
1799 _dbus_type_reader_next (&typereader);
1807 bus_driver_generate_introspect_string (DBusString *xml)
1809 const InterfaceHandler *ih;
1810 const MessageHandler *mh;
1812 if (!_dbus_string_append (xml, DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE))
1814 if (!_dbus_string_append (xml, "<node>\n"))
1817 for (ih = interface_handlers; ih->name != NULL; ih++)
1819 if (!_dbus_string_append_printf (xml, " <interface name=\"%s\">\n",
1823 for (mh = ih->message_handlers; mh->name != NULL; mh++)
1825 if (!_dbus_string_append_printf (xml, " <method name=\"%s\">\n",
1829 if (!write_args_for_direction (xml, mh->in_args, TRUE))
1832 if (!write_args_for_direction (xml, mh->out_args, FALSE))
1835 if (!_dbus_string_append (xml, " </method>\n"))
1839 if (ih->extra_introspection != NULL &&
1840 !_dbus_string_append (xml, ih->extra_introspection))
1843 if (!_dbus_string_append (xml, " </interface>\n"))
1847 if (!_dbus_string_append (xml, "</node>\n"))
1854 bus_driver_handle_introspect (DBusConnection *connection,
1855 BusTransaction *transaction,
1856 DBusMessage *message,
1861 const char *v_STRING;
1863 _dbus_verbose ("Introspect() on bus driver\n");
1865 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1869 if (! dbus_message_get_args (message, error,
1872 _DBUS_ASSERT_ERROR_IS_SET (error);
1876 if (!_dbus_string_init (&xml))
1878 BUS_SET_OOM (error);
1882 if (!bus_driver_generate_introspect_string (&xml))
1885 v_STRING = _dbus_string_get_const_data (&xml);
1887 reply = dbus_message_new_method_return (message);
1891 if (! dbus_message_append_args (reply,
1892 DBUS_TYPE_STRING, &v_STRING,
1896 if (! bus_transaction_send_from_driver (transaction, connection, reply))
1899 dbus_message_unref (reply);
1900 _dbus_string_free (&xml);
1905 BUS_SET_OOM (error);
1908 dbus_message_unref (reply);
1910 _dbus_string_free (&xml);
1916 bus_driver_handle_message (DBusConnection *connection,
1917 BusTransaction *transaction,
1918 DBusMessage *message,
1921 const char *name, *sender, *interface;
1922 const InterfaceHandler *ih;
1923 const MessageHandler *mh;
1924 dbus_bool_t found_interface = FALSE;
1926 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1928 if (dbus_message_is_signal (message, "org.freedesktop.systemd1.Activator", "ActivationFailure"))
1930 BusContext *context;
1932 context = bus_connection_get_context (connection);
1933 return dbus_activation_systemd_failure(bus_context_get_activation(context), message);
1936 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
1938 _dbus_verbose ("Driver got a non-method-call message, ignoring\n");
1939 return TRUE; /* we just ignore this */
1942 /* may be NULL, which means "any interface will do" */
1943 interface = dbus_message_get_interface (message);
1945 _dbus_assert (dbus_message_get_member (message) != NULL);
1947 name = dbus_message_get_member (message);
1948 sender = dbus_message_get_sender (message);
1950 _dbus_verbose ("Driver got a method call: %s\n",
1951 dbus_message_get_member (message));
1953 /* security checks should have kept this from getting here */
1954 _dbus_assert (sender != NULL || strcmp (name, "Hello") == 0);
1956 for (ih = interface_handlers; ih->name != NULL; ih++)
1958 if (interface != NULL && strcmp (interface, ih->name) != 0)
1961 found_interface = TRUE;
1963 for (mh = ih->message_handlers; mh->name != NULL; mh++)
1965 if (strcmp (mh->name, name) != 0)
1968 _dbus_verbose ("Found driver handler for %s\n", name);
1970 if (!dbus_message_has_signature (message, mh->in_args))
1972 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1973 _dbus_verbose ("Call to %s has wrong args (%s, expected %s)\n",
1974 name, dbus_message_get_signature (message),
1977 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
1978 "Call to %s has wrong args (%s, expected %s)\n",
1979 name, dbus_message_get_signature (message),
1981 _DBUS_ASSERT_ERROR_IS_SET (error);
1985 if ((* mh->handler) (connection, transaction, message, error))
1987 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1988 _dbus_verbose ("Driver handler succeeded\n");
1993 _DBUS_ASSERT_ERROR_IS_SET (error);
1994 _dbus_verbose ("Driver handler returned failure\n");
2001 _dbus_verbose ("No driver handler for message \"%s\"\n",
2004 dbus_set_error (error, found_interface ? DBUS_ERROR_UNKNOWN_METHOD : DBUS_ERROR_UNKNOWN_INTERFACE,
2005 "%s does not understand message %s",
2006 DBUS_SERVICE_DBUS, name);
2012 bus_driver_remove_connection (DBusConnection *connection)
2014 /* FIXME 1.0 Does nothing for now, should unregister the connection
2015 * with the bus driver.