00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <config.h>
00026 #include "dbus-bus.h"
00027 #include "dbus-protocol.h"
00028 #include "dbus-internals.h"
00029 #include "dbus-message.h"
00030 #include "dbus-marshal-validate.h"
00031 #include "dbus-threads-internal.h"
00032 #include "dbus-connection-internal.h"
00033 #include "dbus-string.h"
00034
00076 typedef struct
00077 {
00078 DBusConnection *connection;
00079 char *unique_name;
00081 unsigned int is_well_known : 1;
00082 } BusData;
00083
00086 static dbus_int32_t bus_data_slot = -1;
00087
00089 #define N_BUS_TYPES 3
00090
00091 static DBusConnection *bus_connections[N_BUS_TYPES];
00092 static char *bus_connection_addresses[N_BUS_TYPES] = { NULL, NULL, NULL };
00093
00094 static DBusBusType activation_bus_type = DBUS_BUS_STARTER;
00095
00096 static dbus_bool_t initialized = FALSE;
00097
00101 _DBUS_DEFINE_GLOBAL_LOCK (bus);
00102
00109 _DBUS_DEFINE_GLOBAL_LOCK (bus_datas);
00110
00111 static void
00112 addresses_shutdown_func (void *data)
00113 {
00114 int i;
00115
00116 i = 0;
00117 while (i < N_BUS_TYPES)
00118 {
00119 if (bus_connections[i] != NULL)
00120 _dbus_warn_check_failed ("dbus_shutdown() called but connections were still live. This probably means the application did not drop all its references to bus connections.\n");
00121
00122 dbus_free (bus_connection_addresses[i]);
00123 bus_connection_addresses[i] = NULL;
00124 ++i;
00125 }
00126
00127 activation_bus_type = DBUS_BUS_STARTER;
00128
00129 initialized = FALSE;
00130 }
00131
00132 static dbus_bool_t
00133 get_from_env (char **connection_p,
00134 const char *env_var)
00135 {
00136 const char *s;
00137
00138 _dbus_assert (*connection_p == NULL);
00139
00140 s = _dbus_getenv (env_var);
00141 if (s == NULL || *s == '\0')
00142 return TRUE;
00143 else
00144 {
00145 *connection_p = _dbus_strdup (s);
00146 return *connection_p != NULL;
00147 }
00148 }
00149
00150 static dbus_bool_t
00151 init_session_address (void)
00152 {
00153 dbus_bool_t retval;
00154
00155 retval = FALSE;
00156
00157
00158
00159 get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION],
00160 "DBUS_SESSION_BUS_ADDRESS");
00161 if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
00162 {
00163 dbus_bool_t supported;
00164 DBusString addr;
00165 DBusError error = DBUS_ERROR_INIT;
00166
00167 if (!_dbus_string_init (&addr))
00168 return FALSE;
00169
00170 supported = FALSE;
00171
00172
00173
00174
00175 retval = _dbus_lookup_session_address (&supported, &addr, &error);
00176 if (supported && retval)
00177 {
00178 retval =_dbus_string_steal_data (&addr, &bus_connection_addresses[DBUS_BUS_SESSION]);
00179 }
00180 else if (supported && !retval)
00181 {
00182 if (dbus_error_is_set(&error))
00183 _dbus_warn ("Dynamic session lookup supported but failed: %s\n", error.message);
00184 else
00185 _dbus_warn ("Dynamic session lookup supported but failed silently\n");
00186 }
00187 _dbus_string_free (&addr);
00188 }
00189 else
00190 retval = TRUE;
00191
00192 if (!retval)
00193 return FALSE;
00194
00195
00196
00197
00198 if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
00199 bus_connection_addresses[DBUS_BUS_SESSION] =
00200 _dbus_strdup (DBUS_SESSION_BUS_DEFAULT_ADDRESS);
00201 if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
00202 return FALSE;
00203
00204 return TRUE;
00205 }
00206
00207 static dbus_bool_t
00208 init_connections_unlocked (void)
00209 {
00210 if (!initialized)
00211 {
00212 const char *s;
00213 int i;
00214
00215 i = 0;
00216 while (i < N_BUS_TYPES)
00217 {
00218 bus_connections[i] = NULL;
00219 ++i;
00220 }
00221
00222
00223
00224
00225
00226
00227
00228
00229 if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00230 {
00231 _dbus_verbose ("Filling in system bus address...\n");
00232
00233 if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM],
00234 "DBUS_SYSTEM_BUS_ADDRESS"))
00235 return FALSE;
00236 }
00237
00238
00239 if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00240 {
00241
00242 bus_connection_addresses[DBUS_BUS_SYSTEM] =
00243 _dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS);
00244
00245 if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00246 return FALSE;
00247
00248 _dbus_verbose (" used default system bus \"%s\"\n",
00249 bus_connection_addresses[DBUS_BUS_SYSTEM]);
00250 }
00251 else
00252 _dbus_verbose (" used env var system bus \"%s\"\n",
00253 bus_connection_addresses[DBUS_BUS_SYSTEM]);
00254
00255 if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
00256 {
00257 _dbus_verbose ("Filling in session bus address...\n");
00258
00259 if (!init_session_address ())
00260 return FALSE;
00261
00262 _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?
00263 bus_connection_addresses[DBUS_BUS_SESSION] : "none set");
00264 }
00265
00266 if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)
00267 {
00268 _dbus_verbose ("Filling in activation bus address...\n");
00269
00270 if (!get_from_env (&bus_connection_addresses[DBUS_BUS_STARTER],
00271 "DBUS_STARTER_ADDRESS"))
00272 return FALSE;
00273
00274 _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_STARTER] ?
00275 bus_connection_addresses[DBUS_BUS_STARTER] : "none set");
00276 }
00277
00278
00279 if (bus_connection_addresses[DBUS_BUS_STARTER] != NULL)
00280 {
00281 s = _dbus_getenv ("DBUS_STARTER_BUS_TYPE");
00282
00283 if (s != NULL)
00284 {
00285 _dbus_verbose ("Bus activation type was set to \"%s\"\n", s);
00286
00287 if (strcmp (s, "system") == 0)
00288 activation_bus_type = DBUS_BUS_SYSTEM;
00289 else if (strcmp (s, "session") == 0)
00290 activation_bus_type = DBUS_BUS_SESSION;
00291 }
00292 }
00293 else
00294 {
00295
00296 if (bus_connection_addresses[DBUS_BUS_SESSION] != NULL)
00297 {
00298 bus_connection_addresses[DBUS_BUS_STARTER] =
00299 _dbus_strdup (bus_connection_addresses[DBUS_BUS_SESSION]);
00300 if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)
00301 return FALSE;
00302 }
00303 }
00304
00305
00306
00307
00308
00309 if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", NULL))
00310 return FALSE;
00311
00312 if (!_dbus_setenv ("DBUS_ACTIVATION_BUS_TYPE", NULL))
00313 return FALSE;
00314
00315 if (!_dbus_register_shutdown_func (addresses_shutdown_func,
00316 NULL))
00317 return FALSE;
00318
00319 initialized = TRUE;
00320 }
00321
00322 return initialized;
00323 }
00324
00325 static void
00326 bus_data_free (void *data)
00327 {
00328 BusData *bd = data;
00329
00330 if (bd->is_well_known)
00331 {
00332 int i;
00333 _DBUS_LOCK (bus);
00334
00335
00336
00337
00338
00339 i = 0;
00340 while (i < N_BUS_TYPES)
00341 {
00342 if (bus_connections[i] == bd->connection)
00343 bus_connections[i] = NULL;
00344
00345 ++i;
00346 }
00347 _DBUS_UNLOCK (bus);
00348 }
00349
00350 dbus_free (bd->unique_name);
00351 dbus_free (bd);
00352
00353 dbus_connection_free_data_slot (&bus_data_slot);
00354 }
00355
00356 static BusData*
00357 ensure_bus_data (DBusConnection *connection)
00358 {
00359 BusData *bd;
00360
00361 if (!dbus_connection_allocate_data_slot (&bus_data_slot))
00362 return NULL;
00363
00364 bd = dbus_connection_get_data (connection, bus_data_slot);
00365 if (bd == NULL)
00366 {
00367 bd = dbus_new0 (BusData, 1);
00368 if (bd == NULL)
00369 {
00370 dbus_connection_free_data_slot (&bus_data_slot);
00371 return NULL;
00372 }
00373
00374 bd->connection = connection;
00375
00376 if (!dbus_connection_set_data (connection, bus_data_slot, bd,
00377 bus_data_free))
00378 {
00379 dbus_free (bd);
00380 dbus_connection_free_data_slot (&bus_data_slot);
00381 return NULL;
00382 }
00383
00384
00385 }
00386 else
00387 {
00388 dbus_connection_free_data_slot (&bus_data_slot);
00389 }
00390
00391 return bd;
00392 }
00393
00400 void
00401 _dbus_bus_notify_shared_connection_disconnected_unlocked (DBusConnection *connection)
00402 {
00403 int i;
00404
00405 _DBUS_LOCK (bus);
00406
00407
00408
00409
00410
00411
00412
00413 for (i = 0; i < N_BUS_TYPES; ++i)
00414 {
00415 if (bus_connections[i] == connection)
00416 {
00417 bus_connections[i] = NULL;
00418 }
00419 }
00420
00421 _DBUS_UNLOCK (bus);
00422 }
00423
00424 static DBusConnection *
00425 internal_bus_get (DBusBusType type,
00426 dbus_bool_t private,
00427 DBusError *error)
00428 {
00429 const char *address;
00430 DBusConnection *connection;
00431 BusData *bd;
00432 DBusBusType address_type;
00433
00434 _dbus_return_val_if_fail (type >= 0 && type < N_BUS_TYPES, NULL);
00435 _dbus_return_val_if_error_is_set (error, NULL);
00436
00437 connection = NULL;
00438
00439 _DBUS_LOCK (bus);
00440
00441 if (!init_connections_unlocked ())
00442 {
00443 _DBUS_SET_OOM (error);
00444 goto out;
00445 }
00446
00447
00448
00449
00450
00451 address_type = type;
00452
00453
00454
00455
00456
00457
00458 if (type == DBUS_BUS_STARTER &&
00459 bus_connection_addresses[activation_bus_type] != NULL)
00460 type = activation_bus_type;
00461
00462 if (!private && bus_connections[type] != NULL)
00463 {
00464 connection = bus_connections[type];
00465 dbus_connection_ref (connection);
00466 goto out;
00467 }
00468
00469 address = bus_connection_addresses[address_type];
00470 if (address == NULL)
00471 {
00472 dbus_set_error (error, DBUS_ERROR_FAILED,
00473 "Unable to determine the address of the message bus (try 'man dbus-launch' and 'man dbus-daemon' for help)");
00474 goto out;
00475 }
00476
00477 if (private)
00478 connection = dbus_connection_open_private (address, error);
00479 else
00480 connection = dbus_connection_open (address, error);
00481
00482 if (!connection)
00483 {
00484 goto out;
00485 }
00486
00487 if (!dbus_bus_register (connection, error))
00488 {
00489 _dbus_connection_close_possibly_shared (connection);
00490 dbus_connection_unref (connection);
00491 connection = NULL;
00492 goto out;
00493 }
00494
00495 if (!private)
00496 {
00497
00498
00499
00500
00501 bus_connections[type] = connection;
00502 }
00503
00504
00505
00506
00507 dbus_connection_set_exit_on_disconnect (connection,
00508 TRUE);
00509
00510 _DBUS_LOCK (bus_datas);
00511 bd = ensure_bus_data (connection);
00512 _dbus_assert (bd != NULL);
00513
00514 bd->is_well_known = TRUE;
00515 _DBUS_UNLOCK (bus_datas);
00516
00517 out:
00518
00519 if (connection == NULL)
00520 _DBUS_ASSERT_ERROR_IS_SET (error);
00521
00522 _DBUS_UNLOCK (bus);
00523 return connection;
00524 }
00525
00526
00528
00559 DBusConnection *
00560 dbus_bus_get (DBusBusType type,
00561 DBusError *error)
00562 {
00563 return internal_bus_get (type, FALSE, error);
00564 }
00565
00591 DBusConnection *
00592 dbus_bus_get_private (DBusBusType type,
00593 DBusError *error)
00594 {
00595 return internal_bus_get (type, TRUE, error);
00596 }
00597
00647 dbus_bool_t
00648 dbus_bus_register (DBusConnection *connection,
00649 DBusError *error)
00650 {
00651 DBusMessage *message, *reply;
00652 char *name;
00653 BusData *bd;
00654 dbus_bool_t retval;
00655
00656 _dbus_return_val_if_fail (connection != NULL, FALSE);
00657 _dbus_return_val_if_error_is_set (error, FALSE);
00658
00659 retval = FALSE;
00660 message = NULL;
00661 reply = NULL;
00662
00663 _DBUS_LOCK (bus_datas);
00664
00665 bd = ensure_bus_data (connection);
00666 if (bd == NULL)
00667 {
00668 _DBUS_SET_OOM (error);
00669 goto out;
00670 }
00671
00672 if (bd->unique_name != NULL)
00673 {
00674 _dbus_verbose ("Ignoring attempt to register the same DBusConnection %s with the message bus a second time.\n",
00675 bd->unique_name);
00676
00677 retval = TRUE;
00678 goto out;
00679 }
00680
00681 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
00682 DBUS_PATH_DBUS,
00683 DBUS_INTERFACE_DBUS,
00684 "Hello");
00685
00686 if (!message)
00687 {
00688 _DBUS_SET_OOM (error);
00689 goto out;
00690 }
00691
00692 reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
00693
00694 if (reply == NULL)
00695 goto out;
00696 else if (dbus_set_error_from_message (error, reply))
00697 goto out;
00698 else if (!dbus_message_get_args (reply, error,
00699 DBUS_TYPE_STRING, &name,
00700 DBUS_TYPE_INVALID))
00701 goto out;
00702
00703 bd->unique_name = _dbus_strdup (name);
00704 if (bd->unique_name == NULL)
00705 {
00706 _DBUS_SET_OOM (error);
00707 goto out;
00708 }
00709
00710 retval = TRUE;
00711
00712 out:
00713 _DBUS_UNLOCK (bus_datas);
00714
00715 if (message)
00716 dbus_message_unref (message);
00717
00718 if (reply)
00719 dbus_message_unref (reply);
00720
00721 if (!retval)
00722 _DBUS_ASSERT_ERROR_IS_SET (error);
00723
00724 return retval;
00725 }
00726
00727
00762 dbus_bool_t
00763 dbus_bus_set_unique_name (DBusConnection *connection,
00764 const char *unique_name)
00765 {
00766 BusData *bd;
00767 dbus_bool_t success = FALSE;
00768
00769 _dbus_return_val_if_fail (connection != NULL, FALSE);
00770 _dbus_return_val_if_fail (unique_name != NULL, FALSE);
00771
00772 _DBUS_LOCK (bus_datas);
00773
00774 bd = ensure_bus_data (connection);
00775 if (bd == NULL)
00776 goto out;
00777
00778 _dbus_assert (bd->unique_name == NULL);
00779
00780 bd->unique_name = _dbus_strdup (unique_name);
00781 success = bd->unique_name != NULL;
00782
00783 out:
00784 _DBUS_UNLOCK (bus_datas);
00785
00786 return success;
00787 }
00788
00807 const char*
00808 dbus_bus_get_unique_name (DBusConnection *connection)
00809 {
00810 BusData *bd;
00811 const char *unique_name = NULL;
00812
00813 _dbus_return_val_if_fail (connection != NULL, NULL);
00814
00815 _DBUS_LOCK (bus_datas);
00816
00817 bd = ensure_bus_data (connection);
00818 if (bd == NULL)
00819 goto out;
00820
00821 unique_name = bd->unique_name;
00822
00823 out:
00824 _DBUS_UNLOCK (bus_datas);
00825
00826 return unique_name;
00827 }
00828
00852 unsigned long
00853 dbus_bus_get_unix_user (DBusConnection *connection,
00854 const char *name,
00855 DBusError *error)
00856 {
00857 DBusMessage *message, *reply;
00858 dbus_uint32_t uid;
00859
00860 _dbus_return_val_if_fail (connection != NULL, DBUS_UID_UNSET);
00861 _dbus_return_val_if_fail (name != NULL, DBUS_UID_UNSET);
00862 _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), DBUS_UID_UNSET);
00863 _dbus_return_val_if_error_is_set (error, DBUS_UID_UNSET);
00864
00865 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
00866 DBUS_PATH_DBUS,
00867 DBUS_INTERFACE_DBUS,
00868 "GetConnectionUnixUser");
00869
00870 if (message == NULL)
00871 {
00872 _DBUS_SET_OOM (error);
00873 return DBUS_UID_UNSET;
00874 }
00875
00876 if (!dbus_message_append_args (message,
00877 DBUS_TYPE_STRING, &name,
00878 DBUS_TYPE_INVALID))
00879 {
00880 dbus_message_unref (message);
00881 _DBUS_SET_OOM (error);
00882 return DBUS_UID_UNSET;
00883 }
00884
00885 reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
00886 error);
00887
00888 dbus_message_unref (message);
00889
00890 if (reply == NULL)
00891 {
00892 _DBUS_ASSERT_ERROR_IS_SET (error);
00893 return DBUS_UID_UNSET;
00894 }
00895
00896 if (dbus_set_error_from_message (error, reply))
00897 {
00898 _DBUS_ASSERT_ERROR_IS_SET (error);
00899 dbus_message_unref (reply);
00900 return DBUS_UID_UNSET;
00901 }
00902
00903 if (!dbus_message_get_args (reply, error,
00904 DBUS_TYPE_UINT32, &uid,
00905 DBUS_TYPE_INVALID))
00906 {
00907 _DBUS_ASSERT_ERROR_IS_SET (error);
00908 dbus_message_unref (reply);
00909 return DBUS_UID_UNSET;
00910 }
00911
00912 dbus_message_unref (reply);
00913
00914 return (unsigned long) uid;
00915 }
00916
00935 char*
00936 dbus_bus_get_id (DBusConnection *connection,
00937 DBusError *error)
00938 {
00939 DBusMessage *message, *reply;
00940 char *id;
00941 const char *v_STRING;
00942
00943 _dbus_return_val_if_fail (connection != NULL, NULL);
00944 _dbus_return_val_if_error_is_set (error, NULL);
00945
00946 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
00947 DBUS_PATH_DBUS,
00948 DBUS_INTERFACE_DBUS,
00949 "GetId");
00950
00951 if (message == NULL)
00952 {
00953 _DBUS_SET_OOM (error);
00954 return NULL;
00955 }
00956
00957 reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
00958 error);
00959
00960 dbus_message_unref (message);
00961
00962 if (reply == NULL)
00963 {
00964 _DBUS_ASSERT_ERROR_IS_SET (error);
00965 return NULL;
00966 }
00967
00968 if (dbus_set_error_from_message (error, reply))
00969 {
00970 _DBUS_ASSERT_ERROR_IS_SET (error);
00971 dbus_message_unref (reply);
00972 return NULL;
00973 }
00974
00975 v_STRING = NULL;
00976 if (!dbus_message_get_args (reply, error,
00977 DBUS_TYPE_STRING, &v_STRING,
00978 DBUS_TYPE_INVALID))
00979 {
00980 _DBUS_ASSERT_ERROR_IS_SET (error);
00981 dbus_message_unref (reply);
00982 return NULL;
00983 }
00984
00985 id = _dbus_strdup (v_STRING);
00986
00987 dbus_message_unref (reply);
00988
00989 if (id == NULL)
00990 _DBUS_SET_OOM (error);
00991
00992
00993
00994 return id;
00995 }
00996
01099 int
01100 dbus_bus_request_name (DBusConnection *connection,
01101 const char *name,
01102 unsigned int flags,
01103 DBusError *error)
01104 {
01105 DBusMessage *message, *reply;
01106 dbus_uint32_t result;
01107
01108 _dbus_return_val_if_fail (connection != NULL, 0);
01109 _dbus_return_val_if_fail (name != NULL, 0);
01110 _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
01111 _dbus_return_val_if_error_is_set (error, 0);
01112
01113 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01114 DBUS_PATH_DBUS,
01115 DBUS_INTERFACE_DBUS,
01116 "RequestName");
01117
01118 if (message == NULL)
01119 {
01120 _DBUS_SET_OOM (error);
01121 return -1;
01122 }
01123
01124 if (!dbus_message_append_args (message,
01125 DBUS_TYPE_STRING, &name,
01126 DBUS_TYPE_UINT32, &flags,
01127 DBUS_TYPE_INVALID))
01128 {
01129 dbus_message_unref (message);
01130 _DBUS_SET_OOM (error);
01131 return -1;
01132 }
01133
01134 reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
01135 error);
01136
01137 dbus_message_unref (message);
01138
01139 if (reply == NULL)
01140 {
01141 _DBUS_ASSERT_ERROR_IS_SET (error);
01142 return -1;
01143 }
01144
01145 if (dbus_set_error_from_message (error, reply))
01146 {
01147 _DBUS_ASSERT_ERROR_IS_SET (error);
01148 dbus_message_unref (reply);
01149 return -1;
01150 }
01151
01152 if (!dbus_message_get_args (reply, error,
01153 DBUS_TYPE_UINT32, &result,
01154 DBUS_TYPE_INVALID))
01155 {
01156 _DBUS_ASSERT_ERROR_IS_SET (error);
01157 dbus_message_unref (reply);
01158 return -1;
01159 }
01160
01161 dbus_message_unref (reply);
01162
01163 return result;
01164 }
01165
01166
01185 int
01186 dbus_bus_release_name (DBusConnection *connection,
01187 const char *name,
01188 DBusError *error)
01189 {
01190 DBusMessage *message, *reply;
01191 dbus_uint32_t result;
01192
01193 _dbus_return_val_if_fail (connection != NULL, 0);
01194 _dbus_return_val_if_fail (name != NULL, 0);
01195 _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
01196 _dbus_return_val_if_error_is_set (error, 0);
01197
01198 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01199 DBUS_PATH_DBUS,
01200 DBUS_INTERFACE_DBUS,
01201 "ReleaseName");
01202
01203 if (message == NULL)
01204 {
01205 _DBUS_SET_OOM (error);
01206 return -1;
01207 }
01208
01209 if (!dbus_message_append_args (message,
01210 DBUS_TYPE_STRING, &name,
01211 DBUS_TYPE_INVALID))
01212 {
01213 dbus_message_unref (message);
01214 _DBUS_SET_OOM (error);
01215 return -1;
01216 }
01217
01218 reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
01219 error);
01220
01221 dbus_message_unref (message);
01222
01223 if (reply == NULL)
01224 {
01225 _DBUS_ASSERT_ERROR_IS_SET (error);
01226 return -1;
01227 }
01228
01229 if (dbus_set_error_from_message (error, reply))
01230 {
01231 _DBUS_ASSERT_ERROR_IS_SET (error);
01232 dbus_message_unref (reply);
01233 return -1;
01234 }
01235
01236 if (!dbus_message_get_args (reply, error,
01237 DBUS_TYPE_UINT32, &result,
01238 DBUS_TYPE_INVALID))
01239 {
01240 _DBUS_ASSERT_ERROR_IS_SET (error);
01241 dbus_message_unref (reply);
01242 return -1;
01243 }
01244
01245 dbus_message_unref (reply);
01246
01247 return result;
01248 }
01249
01267 dbus_bool_t
01268 dbus_bus_name_has_owner (DBusConnection *connection,
01269 const char *name,
01270 DBusError *error)
01271 {
01272 DBusMessage *message, *reply;
01273 dbus_bool_t exists;
01274
01275 _dbus_return_val_if_fail (connection != NULL, FALSE);
01276 _dbus_return_val_if_fail (name != NULL, FALSE);
01277 _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), FALSE);
01278 _dbus_return_val_if_error_is_set (error, FALSE);
01279
01280 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01281 DBUS_PATH_DBUS,
01282 DBUS_INTERFACE_DBUS,
01283 "NameHasOwner");
01284 if (message == NULL)
01285 {
01286 _DBUS_SET_OOM (error);
01287 return FALSE;
01288 }
01289
01290 if (!dbus_message_append_args (message,
01291 DBUS_TYPE_STRING, &name,
01292 DBUS_TYPE_INVALID))
01293 {
01294 dbus_message_unref (message);
01295 _DBUS_SET_OOM (error);
01296 return FALSE;
01297 }
01298
01299 reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
01300 dbus_message_unref (message);
01301
01302 if (reply == NULL)
01303 {
01304 _DBUS_ASSERT_ERROR_IS_SET (error);
01305 return FALSE;
01306 }
01307
01308 if (!dbus_message_get_args (reply, error,
01309 DBUS_TYPE_BOOLEAN, &exists,
01310 DBUS_TYPE_INVALID))
01311 {
01312 _DBUS_ASSERT_ERROR_IS_SET (error);
01313 dbus_message_unref (reply);
01314 return FALSE;
01315 }
01316
01317 dbus_message_unref (reply);
01318 return exists;
01319 }
01320
01343 dbus_bool_t
01344 dbus_bus_start_service_by_name (DBusConnection *connection,
01345 const char *name,
01346 dbus_uint32_t flags,
01347 dbus_uint32_t *result,
01348 DBusError *error)
01349 {
01350 DBusMessage *msg;
01351 DBusMessage *reply;
01352
01353 _dbus_return_val_if_fail (connection != NULL, FALSE);
01354 _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), FALSE);
01355
01356 msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01357 DBUS_PATH_DBUS,
01358 DBUS_INTERFACE_DBUS,
01359 "StartServiceByName");
01360
01361 if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &name,
01362 DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID))
01363 {
01364 dbus_message_unref (msg);
01365 _DBUS_SET_OOM (error);
01366 return FALSE;
01367 }
01368
01369 reply = dbus_connection_send_with_reply_and_block (connection, msg,
01370 -1, error);
01371 dbus_message_unref (msg);
01372
01373 if (reply == NULL)
01374 {
01375 _DBUS_ASSERT_ERROR_IS_SET (error);
01376 return FALSE;
01377 }
01378
01379 if (dbus_set_error_from_message (error, reply))
01380 {
01381 _DBUS_ASSERT_ERROR_IS_SET (error);
01382 dbus_message_unref (reply);
01383 return FALSE;
01384 }
01385
01386 if (result != NULL &&
01387 !dbus_message_get_args (reply, error, DBUS_TYPE_UINT32,
01388 result, DBUS_TYPE_INVALID))
01389 {
01390 _DBUS_ASSERT_ERROR_IS_SET (error);
01391 dbus_message_unref (reply);
01392 return FALSE;
01393 }
01394
01395 dbus_message_unref (reply);
01396 return TRUE;
01397 }
01398
01399 static void
01400 send_no_return_values (DBusConnection *connection,
01401 DBusMessage *msg,
01402 DBusError *error)
01403 {
01404 if (error)
01405 {
01406
01407 DBusMessage *reply;
01408
01409 reply = dbus_connection_send_with_reply_and_block (connection, msg,
01410 -1, error);
01411
01412 if (reply == NULL)
01413 _DBUS_ASSERT_ERROR_IS_SET (error);
01414 else
01415 dbus_message_unref (reply);
01416 }
01417 else
01418 {
01419
01420 dbus_message_set_no_reply (msg, TRUE);
01421 dbus_connection_send (connection, msg, NULL);
01422 }
01423 }
01424
01513 void
01514 dbus_bus_add_match (DBusConnection *connection,
01515 const char *rule,
01516 DBusError *error)
01517 {
01518 DBusMessage *msg;
01519
01520 _dbus_return_if_fail (rule != NULL);
01521
01522 msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01523 DBUS_PATH_DBUS,
01524 DBUS_INTERFACE_DBUS,
01525 "AddMatch");
01526
01527 if (msg == NULL)
01528 {
01529 _DBUS_SET_OOM (error);
01530 return;
01531 }
01532
01533 if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &rule,
01534 DBUS_TYPE_INVALID))
01535 {
01536 dbus_message_unref (msg);
01537 _DBUS_SET_OOM (error);
01538 return;
01539 }
01540
01541 send_no_return_values (connection, msg, error);
01542
01543 dbus_message_unref (msg);
01544 }
01545
01563 void
01564 dbus_bus_remove_match (DBusConnection *connection,
01565 const char *rule,
01566 DBusError *error)
01567 {
01568 DBusMessage *msg;
01569
01570 _dbus_return_if_fail (rule != NULL);
01571
01572 msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
01573 DBUS_PATH_DBUS,
01574 DBUS_INTERFACE_DBUS,
01575 "RemoveMatch");
01576
01577 if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &rule,
01578 DBUS_TYPE_INVALID))
01579 {
01580 dbus_message_unref (msg);
01581 _DBUS_SET_OOM (error);
01582 return;
01583 }
01584
01585 send_no_return_values (connection, msg, error);
01586
01587 dbus_message_unref (msg);
01588 }
01589