1 /* GDBus - GLib D-Bus Library
3 * Copyright (C) 2008-2010 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: David Zeuthen <davidz@redhat.com>
31 #include "gdbusutils.h"
32 #include "gdbusaddress.h"
33 #include "gdbuserror.h"
34 #include "gioenumtypes.h"
35 #include "gnetworkaddress.h"
36 #include "gsocketclient.h"
37 #include "giostream.h"
38 #include "gasyncresult.h"
39 #include "gsimpleasyncresult.h"
40 #include "gdbusprivate.h"
43 #include <gio/gunixsocketaddress.h>
50 * SECTION:gdbusaddress
51 * @title: D-Bus Addresses
52 * @short_description: D-Bus connection endpoints
55 * Routines for working with D-Bus addresses. A D-Bus address is a string
56 * like "unix:tmpdir=/tmp/my-app-name". The exact format of addresses
57 * is explained in detail in the <link linkend="http://dbus.freedesktop.org/doc/dbus-specification.html#addresses">D-Bus specification</link>.
60 static gchar *get_session_address_platform_specific (GError **error);
62 /* ---------------------------------------------------------------------------------------------------- */
68 * Checks if @string is a D-Bus address.
70 * This doesn't check if @string is actually supported by #GDBusServer
71 * or #GDBusConnection - use g_dbus_is_supported_address() to do more
74 * Returns: %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
79 g_dbus_is_address (const gchar *string)
87 g_return_val_if_fail (string != NULL, FALSE);
89 a = g_strsplit (string, ";", 0);
93 for (n = 0; a[n] != NULL; n++)
95 if (!_g_dbus_address_parse_entry (a[n],
110 is_valid_unix (const gchar *address_entry,
111 GHashTable *key_value_pairs,
119 const gchar *abstract;
127 keys = g_hash_table_get_keys (key_value_pairs);
128 for (l = keys; l != NULL; l = l->next)
130 const gchar *key = l->data;
131 if (g_strcmp0 (key, "path") == 0)
132 path = g_hash_table_lookup (key_value_pairs, key);
133 else if (g_strcmp0 (key, "tmpdir") == 0)
134 tmpdir = g_hash_table_lookup (key_value_pairs, key);
135 else if (g_strcmp0 (key, "abstract") == 0)
136 abstract = g_hash_table_lookup (key_value_pairs, key);
141 G_IO_ERROR_INVALID_ARGUMENT,
142 _("Unsupported key `%s' in address entry `%s'"),
151 if (tmpdir != NULL || abstract != NULL)
154 else if (tmpdir != NULL)
156 if (path != NULL || abstract != NULL)
159 else if (abstract != NULL)
161 if (path != NULL || tmpdir != NULL)
168 G_IO_ERROR_INVALID_ARGUMENT,
169 _("Address `%s' is invalid (need exactly one of path, tmpdir or abstract keys)"),
181 G_IO_ERROR_INVALID_ARGUMENT,
182 _("Meaningless key/value pair combination in address entry `%s'"),
192 is_valid_nonce_tcp (const gchar *address_entry,
193 GHashTable *key_value_pairs,
202 const gchar *nonce_file;
213 keys = g_hash_table_get_keys (key_value_pairs);
214 for (l = keys; l != NULL; l = l->next)
216 const gchar *key = l->data;
217 if (g_strcmp0 (key, "host") == 0)
218 host = g_hash_table_lookup (key_value_pairs, key);
219 else if (g_strcmp0 (key, "port") == 0)
220 port = g_hash_table_lookup (key_value_pairs, key);
221 else if (g_strcmp0 (key, "family") == 0)
222 family = g_hash_table_lookup (key_value_pairs, key);
223 else if (g_strcmp0 (key, "noncefile") == 0)
224 nonce_file = g_hash_table_lookup (key_value_pairs, key);
229 G_IO_ERROR_INVALID_ARGUMENT,
230 _("Unsupported key `%s' in address entry `%s'"),
239 port_num = strtol (port, &endp, 10);
240 if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)
244 G_IO_ERROR_INVALID_ARGUMENT,
245 _("Error in address `%s' - the port attribute is malformed"),
251 if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))
255 G_IO_ERROR_INVALID_ARGUMENT,
256 _("Error in address `%s' - the family attribute is malformed"),
263 /* TODO: validate host */
266 nonce_file = nonce_file; /* To avoid -Wunused-but-set-variable */
277 is_valid_tcp (const gchar *address_entry,
278 GHashTable *key_value_pairs,
296 keys = g_hash_table_get_keys (key_value_pairs);
297 for (l = keys; l != NULL; l = l->next)
299 const gchar *key = l->data;
300 if (g_strcmp0 (key, "host") == 0)
301 host = g_hash_table_lookup (key_value_pairs, key);
302 else if (g_strcmp0 (key, "port") == 0)
303 port = g_hash_table_lookup (key_value_pairs, key);
304 else if (g_strcmp0 (key, "family") == 0)
305 family = g_hash_table_lookup (key_value_pairs, key);
310 G_IO_ERROR_INVALID_ARGUMENT,
311 _("Unsupported key `%s' in address entry `%s'"),
320 port_num = strtol (port, &endp, 10);
321 if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)
325 G_IO_ERROR_INVALID_ARGUMENT,
326 _("Error in address `%s' - the port attribute is malformed"),
332 if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))
336 G_IO_ERROR_INVALID_ARGUMENT,
337 _("Error in address `%s' - the family attribute is malformed"),
344 /* TODO: validate host */
356 * g_dbus_is_supported_address:
358 * @error: Return location for error or %NULL.
360 * Like g_dbus_is_address() but also checks if the library suppors the
361 * transports in @string and that key/value pairs for each transport
364 * Returns: %TRUE if @string is a valid D-Bus address that is
365 * supported by this library, %FALSE if @error is set.
370 g_dbus_is_supported_address (const gchar *string,
379 g_return_val_if_fail (string != NULL, FALSE);
380 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
382 a = g_strsplit (string, ";", 0);
383 for (n = 0; a[n] != NULL; n++)
385 gchar *transport_name;
386 GHashTable *key_value_pairs;
389 if (!_g_dbus_address_parse_entry (a[n],
396 if (g_strcmp0 (transport_name, "unix") == 0)
397 supported = is_valid_unix (a[n], key_value_pairs, error);
398 else if (g_strcmp0 (transport_name, "tcp") == 0)
399 supported = is_valid_tcp (a[n], key_value_pairs, error);
400 else if (g_strcmp0 (transport_name, "nonce-tcp") == 0)
401 supported = is_valid_nonce_tcp (a[n], key_value_pairs, error);
402 else if (g_strcmp0 (a[n], "autolaunch:") == 0)
405 g_free (transport_name);
406 g_hash_table_unref (key_value_pairs);
417 g_assert (ret || (!ret && (error == NULL || *error != NULL)));
423 _g_dbus_address_parse_entry (const gchar *address_entry,
424 gchar **out_transport_name,
425 GHashTable **out_key_value_pairs,
429 GHashTable *key_value_pairs;
430 gchar *transport_name;
437 transport_name = NULL;
438 key_value_pairs = NULL;
440 s = strchr (address_entry, ':');
445 G_IO_ERROR_INVALID_ARGUMENT,
446 _("Address element `%s', does not contain a colon (:)"),
451 transport_name = g_strndup (address_entry, s - address_entry);
452 key_value_pairs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
454 kv_pairs = g_strsplit (s + 1, ",", 0);
455 for (n = 0; kv_pairs != NULL && kv_pairs[n] != NULL; n++)
457 const gchar *kv_pair = kv_pairs[n];
461 s = strchr (kv_pair, '=');
466 G_IO_ERROR_INVALID_ARGUMENT,
467 _("Key/Value pair %d, `%s', in address element `%s', does not contain an equal sign"),
474 key = g_uri_unescape_segment (kv_pair, s, NULL);
475 value = g_uri_unescape_segment (s + 1, kv_pair + strlen (kv_pair), NULL);
476 if (key == NULL || value == NULL)
480 G_IO_ERROR_INVALID_ARGUMENT,
481 _("Error unescaping key or value in Key/Value pair %d, `%s', in address element `%s'"),
489 g_hash_table_insert (key_value_pairs, key, value);
495 g_strfreev (kv_pairs);
498 if (out_transport_name != NULL)
499 *out_transport_name = transport_name;
501 g_free (transport_name);
502 if (out_key_value_pairs != NULL)
503 *out_key_value_pairs = key_value_pairs;
504 else if (key_value_pairs != NULL)
505 g_hash_table_unref (key_value_pairs);
509 g_free (transport_name);
510 if (key_value_pairs != NULL)
511 g_hash_table_unref (key_value_pairs);
516 /* ---------------------------------------------------------------------------------------------------- */
519 g_dbus_address_try_connect_one (const gchar *address_entry,
521 GCancellable *cancellable,
524 /* TODO: Declare an extension point called GDBusTransport (or similar)
525 * and move code below to extensions implementing said extension
526 * point. That way we can implement a D-Bus transport over X11 without
527 * making libgio link to libX11...
530 g_dbus_address_connect (const gchar *address_entry,
531 const gchar *transport_name,
532 GHashTable *key_value_pairs,
533 GCancellable *cancellable,
537 GSocketConnectable *connectable;
538 const gchar *nonce_file;
548 else if (g_strcmp0 (transport_name, "unix") == 0)
551 const gchar *abstract;
552 path = g_hash_table_lookup (key_value_pairs, "path");
553 abstract = g_hash_table_lookup (key_value_pairs, "abstract");
554 if ((path == NULL && abstract == NULL) || (path != NULL && abstract != NULL))
558 G_IO_ERROR_INVALID_ARGUMENT,
559 _("Error in address `%s' - the unix transport requires exactly one of the "
560 "keys `path' or `abstract' to be set"),
563 else if (path != NULL)
565 connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (path));
567 else if (abstract != NULL)
569 connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new_with_type (abstract,
571 G_UNIX_SOCKET_ADDRESS_ABSTRACT));
575 g_assert_not_reached ();
579 else if (g_strcmp0 (transport_name, "tcp") == 0 || g_strcmp0 (transport_name, "nonce-tcp") == 0)
587 is_nonce = (g_strcmp0 (transport_name, "nonce-tcp") == 0);
589 host = g_hash_table_lookup (key_value_pairs, "host");
594 G_IO_ERROR_INVALID_ARGUMENT,
595 _("Error in address `%s' - the host attribute is missing or malformed"),
600 s = g_hash_table_lookup (key_value_pairs, "port");
603 port = strtol (s, &endp, 10);
604 if ((*s == '\0' || *endp != '\0') || port < 0 || port >= 65536)
608 G_IO_ERROR_INVALID_ARGUMENT,
609 _("Error in address `%s' - the port attribute is missing or malformed"),
617 nonce_file = g_hash_table_lookup (key_value_pairs, "noncefile");
618 if (nonce_file == NULL)
622 G_IO_ERROR_INVALID_ARGUMENT,
623 _("Error in address `%s' - the noncefile attribute is missing or malformed"),
629 /* TODO: deal with family key/value-pair */
630 connectable = g_network_address_new (host, port);
632 else if (g_strcmp0 (address_entry, "autolaunch:") == 0)
634 gchar *autolaunch_address;
635 autolaunch_address = get_session_address_platform_specific (error);
636 if (autolaunch_address != NULL)
638 ret = g_dbus_address_try_connect_one (autolaunch_address, NULL, cancellable, error);
639 g_free (autolaunch_address);
644 g_prefix_error (error, _("Error auto-launching: "));
651 G_IO_ERROR_INVALID_ARGUMENT,
652 _("Unknown or unsupported transport `%s' for address `%s'"),
657 if (connectable != NULL)
659 GSocketClient *client;
660 GSocketConnection *connection;
662 g_assert (ret == NULL);
663 client = g_socket_client_new ();
664 connection = g_socket_client_connect (client,
668 g_object_unref (connectable);
669 g_object_unref (client);
670 if (connection == NULL)
673 ret = G_IO_STREAM (connection);
675 if (nonce_file != NULL)
677 gchar nonce_contents[16 + 1];
678 size_t num_bytes_read;
681 /* be careful to read only 16 bytes - we also check that the file is only 16 bytes long */
682 f = fopen (nonce_file, "rb");
687 G_IO_ERROR_INVALID_ARGUMENT,
688 _("Error opening nonce file `%s': %s"),
691 g_object_unref (ret);
695 num_bytes_read = fread (nonce_contents,
699 if (num_bytes_read != 16)
701 if (num_bytes_read == 0)
705 G_IO_ERROR_INVALID_ARGUMENT,
706 _("Error reading from nonce file `%s': %s"),
714 G_IO_ERROR_INVALID_ARGUMENT,
715 _("Error reading from nonce file `%s', expected 16 bytes, got %d"),
717 (gint) num_bytes_read);
719 g_object_unref (ret);
726 if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),
733 g_prefix_error (error, _("Error writing contents of nonce file `%s' to stream:"), nonce_file);
734 g_object_unref (ret);
747 g_dbus_address_try_connect_one (const gchar *address_entry,
749 GCancellable *cancellable,
753 GHashTable *key_value_pairs;
754 gchar *transport_name;
758 transport_name = NULL;
759 key_value_pairs = NULL;
761 if (!_g_dbus_address_parse_entry (address_entry,
767 ret = g_dbus_address_connect (address_entry,
775 guid = g_hash_table_lookup (key_value_pairs, "guid");
776 if (guid != NULL && out_guid != NULL)
777 *out_guid = g_strdup (guid);
780 g_free (transport_name);
781 if (key_value_pairs != NULL)
782 g_hash_table_unref (key_value_pairs);
787 /* ---------------------------------------------------------------------------------------------------- */
796 get_stream_data_free (GetStreamData *data)
798 g_free (data->address);
799 if (data->stream != NULL)
800 g_object_unref (data->stream);
806 get_stream_thread_func (GSimpleAsyncResult *res,
808 GCancellable *cancellable)
813 data = g_simple_async_result_get_op_res_gpointer (res);
816 data->stream = g_dbus_address_get_stream_sync (data->address,
820 if (data->stream == NULL)
821 g_simple_async_result_take_error (res, error);
825 * g_dbus_address_get_stream:
826 * @address: A valid D-Bus address.
827 * @cancellable: A #GCancellable or %NULL.
828 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
829 * @user_data: Data to pass to @callback.
831 * Asynchronously connects to an endpoint specified by @address and
832 * sets up the connection so it is in a state to run the client-side
833 * of the D-Bus authentication conversation.
835 * When the operation is finished, @callback will be invoked. You can
836 * then call g_dbus_address_get_stream_finish() to get the result of
839 * This is an asynchronous failable function. See
840 * g_dbus_address_get_stream_sync() for the synchronous version.
845 g_dbus_address_get_stream (const gchar *address,
846 GCancellable *cancellable,
847 GAsyncReadyCallback callback,
850 GSimpleAsyncResult *res;
853 g_return_if_fail (address != NULL);
855 res = g_simple_async_result_new (NULL,
858 g_dbus_address_get_stream);
859 g_simple_async_result_set_check_cancellable (res, cancellable);
860 data = g_new0 (GetStreamData, 1);
861 data->address = g_strdup (address);
862 g_simple_async_result_set_op_res_gpointer (res,
864 (GDestroyNotify) get_stream_data_free);
865 g_simple_async_result_run_in_thread (res,
866 get_stream_thread_func,
869 g_object_unref (res);
873 * g_dbus_address_get_stream_finish:
874 * @res: A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
875 * @out_guid: %NULL or return location to store the GUID extracted from @address, if any.
876 * @error: Return location for error or %NULL.
878 * Finishes an operation started with g_dbus_address_get_stream().
880 * Returns: (transfer full): A #GIOStream or %NULL if @error is set.
885 g_dbus_address_get_stream_finish (GAsyncResult *res,
889 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
893 g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL);
894 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
896 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_dbus_address_get_stream);
900 data = g_simple_async_result_get_op_res_gpointer (simple);
901 if (g_simple_async_result_propagate_error (simple, error))
904 ret = g_object_ref (data->stream);
905 if (out_guid != NULL)
906 *out_guid = g_strdup (data->guid);
913 * g_dbus_address_get_stream_sync:
914 * @address: A valid D-Bus address.
915 * @out_guid: %NULL or return location to store the GUID extracted from @address, if any.
916 * @cancellable: A #GCancellable or %NULL.
917 * @error: Return location for error or %NULL.
919 * Synchronously connects to an endpoint specified by @address and
920 * sets up the connection so it is in a state to run the client-side
921 * of the D-Bus authentication conversation.
923 * This is a synchronous failable function. See
924 * g_dbus_address_get_stream() for the asynchronous version.
926 * Returns: (transfer full): A #GIOStream or %NULL if @error is set.
931 g_dbus_address_get_stream_sync (const gchar *address,
933 GCancellable *cancellable,
941 g_return_val_if_fail (address != NULL, NULL);
942 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
947 addr_array = g_strsplit (address, ";", 0);
948 if (addr_array != NULL && addr_array[0] == NULL)
950 last_error = g_error_new_literal (G_IO_ERROR,
951 G_IO_ERROR_INVALID_ARGUMENT,
952 _("The given address is empty"));
956 for (n = 0; addr_array != NULL && addr_array[n] != NULL; n++)
958 const gchar *addr = addr_array[n];
962 ret = g_dbus_address_try_connect_one (addr,
972 g_assert (this_error != NULL);
973 if (last_error != NULL)
974 g_error_free (last_error);
975 last_error = this_error;
982 if (last_error != NULL)
983 g_error_free (last_error);
987 g_assert (last_error != NULL);
988 g_propagate_error (error, last_error);
991 g_strfreev (addr_array);
995 /* ---------------------------------------------------------------------------------------------------- */
999 get_session_address_dbus_launch (GError **error)
1003 gchar *command_line;
1004 gchar *launch_stdout;
1005 gchar *launch_stderr;
1007 gchar *old_dbus_verbose;
1008 gboolean restore_dbus_verbose;
1012 command_line = NULL;
1013 launch_stdout = NULL;
1014 launch_stderr = NULL;
1015 restore_dbus_verbose = FALSE;
1016 old_dbus_verbose = NULL;
1018 machine_id = _g_dbus_get_machine_id (error);
1019 if (machine_id == NULL)
1021 g_prefix_error (error, _("Cannot spawn a message bus without a machine-id: "));
1025 /* We're using private libdbus facilities here. When everything
1026 * (X11, Mac OS X, Windows) is spec'ed out correctly (not even the
1027 * X11 property is correctly documented right now) we should
1028 * consider using the spec instead of dbus-launch.
1030 * --autolaunch=MACHINEID
1031 * This option implies that dbus-launch should scan for a previ‐
1032 * ously-started session and reuse the values found there. If no
1033 * session is found, it will start a new session. The --exit-with-
1034 * session option is implied if --autolaunch is given. This option
1035 * is for the exclusive use of libdbus, you do not want to use it
1036 * manually. It may change in the future.
1039 /* TODO: maybe provide a variable for where to look for the dbus-launch binary? */
1040 command_line = g_strdup_printf ("dbus-launch --autolaunch=%s --binary-syntax --close-stderr", machine_id);
1042 if (G_UNLIKELY (_g_dbus_debug_address ()))
1044 _g_dbus_debug_print_lock ();
1045 g_print ("GDBus-debug:Address: Running `%s' to get bus address (possibly autolaunching)\n", command_line);
1046 old_dbus_verbose = g_strdup (g_getenv ("DBUS_VERBOSE"));
1047 restore_dbus_verbose = TRUE;
1048 g_setenv ("DBUS_VERBOSE", "1", TRUE);
1049 _g_dbus_debug_print_unlock ();
1052 if (!g_spawn_command_line_sync (command_line,
1058 g_prefix_error (error, _("Error spawning command line `%s': "), command_line);
1062 if (!WIFEXITED (exit_status))
1064 gchar *escaped_stderr;
1065 escaped_stderr = g_strescape (launch_stderr, "");
1069 _("Abnormal program termination spawning command line `%s': %s"),
1072 g_free (escaped_stderr);
1076 if (WEXITSTATUS (exit_status) != 0)
1078 gchar *escaped_stderr;
1079 escaped_stderr = g_strescape (launch_stderr, "");
1083 _("Command line `%s' exited with non-zero exit status %d: %s"),
1085 WEXITSTATUS (exit_status),
1087 g_free (escaped_stderr);
1091 /* From the dbus-launch(1) man page:
1093 * --binary-syntax Write to stdout a nul-terminated bus address,
1094 * then the bus PID as a binary integer of size sizeof(pid_t),
1095 * then the bus X window ID as a binary integer of size
1096 * sizeof(long). Integers are in the machine's byte order, not
1097 * network byte order or any other canonical byte order.
1099 ret = g_strdup (launch_stdout);
1102 if (G_UNLIKELY (_g_dbus_debug_address ()))
1105 _g_dbus_debug_print_lock ();
1106 g_print ("GDBus-debug:Address: dbus-launch output:");
1107 if (launch_stdout != NULL)
1109 s = _g_dbus_hexdump (launch_stdout, strlen (launch_stdout) + 1 + sizeof (pid_t) + sizeof (long), 2);
1110 g_print ("\n%s", s);
1115 g_print (" (none)\n");
1117 g_print ("GDBus-debug:Address: dbus-launch stderr output:");
1118 if (launch_stderr != NULL)
1119 g_print ("\n%s", launch_stderr);
1121 g_print (" (none)\n");
1122 _g_dbus_debug_print_unlock ();
1125 g_free (machine_id);
1126 g_free (command_line);
1127 g_free (launch_stdout);
1128 g_free (launch_stderr);
1129 if (G_UNLIKELY (restore_dbus_verbose))
1131 if (old_dbus_verbose != NULL)
1132 g_setenv ("DBUS_VERBOSE", old_dbus_verbose, TRUE);
1134 g_unsetenv ("DBUS_VERBOSE");
1136 g_free (old_dbus_verbose);
1141 /* ---------------------------------------------------------------------------------------------------- */
1144 get_session_address_platform_specific (GError **error)
1148 /* need to handle OS X in a different way since `dbus-launch --autolaunch' probably won't work there */
1149 ret = get_session_address_dbus_launch (error);
1151 /* TODO: implement for UNIX, Win32 and OS X */
1156 _("Cannot determine session bus address (not implemented for this OS)"));
1161 /* ---------------------------------------------------------------------------------------------------- */
1164 * g_dbus_address_get_for_bus_sync:
1165 * @bus_type: A #GBusType.
1166 * @cancellable: A #GCancellable or %NULL.
1167 * @error: Return location for error or %NULL.
1169 * Synchronously looks up the D-Bus address for the well-known message
1170 * bus instance specified by @bus_type. This may involve using various
1171 * platform specific mechanisms.
1173 * Returns: A valid D-Bus address string for @bus_type or %NULL if @error is set.
1178 g_dbus_address_get_for_bus_sync (GBusType bus_type,
1179 GCancellable *cancellable,
1183 const gchar *starter_bus;
1184 GError *local_error;
1186 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1191 if (G_UNLIKELY (_g_dbus_debug_address ()))
1194 _g_dbus_debug_print_lock ();
1195 g_print ("GDBus-debug:Address: In g_dbus_address_get_for_bus_sync() for bus type `%s'\n",
1196 _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type));
1197 for (n = 0; n < 3; n++)
1203 case 0: k = "DBUS_SESSION_BUS_ADDRESS"; break;
1204 case 1: k = "DBUS_SYSTEM_BUS_ADDRESS"; break;
1205 case 2: k = "DBUS_STARTER_BUS_TYPE"; break;
1206 default: g_assert_not_reached ();
1209 g_print ("GDBus-debug:Address: env var %s", k);
1211 g_print ("=`%s'\n", v);
1213 g_print (" is not set\n");
1215 _g_dbus_debug_print_unlock ();
1220 case G_BUS_TYPE_SYSTEM:
1221 ret = g_strdup (g_getenv ("DBUS_SYSTEM_BUS_ADDRESS"));
1224 ret = g_strdup ("unix:path=/var/run/dbus/system_bus_socket");
1228 case G_BUS_TYPE_SESSION:
1229 ret = g_strdup (g_getenv ("DBUS_SESSION_BUS_ADDRESS"));
1232 ret = get_session_address_platform_specific (&local_error);
1236 case G_BUS_TYPE_STARTER:
1237 starter_bus = g_getenv ("DBUS_STARTER_BUS_TYPE");
1238 if (g_strcmp0 (starter_bus, "session") == 0)
1240 ret = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SESSION, cancellable, &local_error);
1243 else if (g_strcmp0 (starter_bus, "system") == 0)
1245 ret = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SYSTEM, cancellable, &local_error);
1250 if (starter_bus != NULL)
1252 g_set_error (&local_error,
1255 _("Cannot determine bus address from DBUS_STARTER_BUS_TYPE environment variable"
1256 " - unknown value `%s'"),
1261 g_set_error_literal (&local_error,
1264 _("Cannot determine bus address because the DBUS_STARTER_BUS_TYPE environment "
1265 "variable is not set"));
1271 g_set_error (&local_error,
1274 _("Unknown bus type %d"),
1280 if (G_UNLIKELY (_g_dbus_debug_address ()))
1282 _g_dbus_debug_print_lock ();
1285 g_print ("GDBus-debug:Address: Returning address `%s' for bus type `%s'\n",
1287 _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type));
1291 g_print ("GDBus-debug:Address: Cannot look-up address bus type `%s': %s\n",
1292 _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type),
1293 local_error ? local_error->message : "");
1295 _g_dbus_debug_print_unlock ();
1298 if (local_error != NULL)
1299 g_propagate_error (error, local_error);