gio/gdbusaddress.c

   1 /* GDBus - GLib D-Bus Library
   2  *
   3  * Copyright (C) 2008-2010 Red Hat, Inc.
   4  *
   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.1 of the License, or (at your option) any later version.
   9  *
  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.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: David Zeuthen <davidz@redhat.com>
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <errno.h>
  27
  28 #include "gioerror.h"
  29 #include "gdbusutils.h"
  30 #include "gdbusaddress.h"
  31 #include "gdbuserror.h"
  32 #include "gioenumtypes.h"
  33 #include "gnetworkaddress.h"
  34 #include "gsocketclient.h"
  35 #include "giostream.h"
  36 #include "gasyncresult.h"
  37 #include "gtask.h"
  38 #include "glib-private.h"
  39 #include "gdbusprivate.h"
  40 #include "giomodule-priv.h"
  41 #include "gdbusdaemon.h"
  42 #include "gstdio.h"
  43
  44 #ifdef G_OS_UNIX
  45 #include <unistd.h>
  46 #include <sys/stat.h>
  47 #include <sys/types.h>
  48 #include <gio/gunixsocketaddress.h>
  49 #endif
  50
  51 #ifdef G_OS_WIN32
  52 #include <windows.h>
  53 #include <io.h>
  54 #include <conio.h>
  55 #endif
  56
  57 #include "glibintl.h"
  58
  59 /**
  60  * SECTION:gdbusaddress
  61  * @title: D-Bus Addresses
  62  * @short_description: D-Bus connection endpoints
  63  * @include: gio/gio.h
  64  *
  65  * Routines for working with D-Bus addresses. A D-Bus address is a string
  66  * like `unix:tmpdir=/tmp/my-app-name`. The exact format of addresses
  67  * is explained in detail in the
  68  * [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
  69  */
  70
  71 static gchar *get_session_address_platform_specific (GError **error);
  72 static gchar *get_session_address_dbus_launch       (GError **error);
  73
  74 /* ---------------------------------------------------------------------------------------------------- */
  75
  76 /**
  77  * g_dbus_is_address:
  78  * @string: A string.
  79  *
  80  * Checks if @string is a
  81  * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
  82  *
  83  * This doesn't check if @string is actually supported by #GDBusServer
  84  * or #GDBusConnection - use g_dbus_is_supported_address() to do more
  85  * checks.
  86  *
  87  * Returns: %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
  88  *
  89  * Since: 2.26
  90  */
  91 gboolean
  92 g_dbus_is_address (const gchar *string)
  93 {
  94   guint n;
  95   gchar **a;
  96   gboolean ret;
  97
  98   ret = FALSE;
  99
 100   g_return_val_if_fail (string != NULL, FALSE);
 101
 102   a = g_strsplit (string, ";", 0);
 103   if (a[0] == NULL)
 104     goto out;
 105
 106   for (n = 0; a[n] != NULL; n++)
 107     {
 108       if (!_g_dbus_address_parse_entry (a[n],
 109                                         NULL,
 110                                         NULL,
 111                                         NULL))
 112         goto out;
 113     }
 114
 115   ret = TRUE;
 116
 117  out:
 118   g_strfreev (a);
 119   return ret;
 120 }
 121
 122 static gboolean
 123 is_valid_unix (const gchar  *address_entry,
 124                GHashTable   *key_value_pairs,
 125                GError      **error)
 126 {
 127   gboolean ret;
 128   GList *keys;
 129   GList *l;
 130   const gchar *path;
 131   const gchar *tmpdir;
 132   const gchar *abstract;
 133
 134   ret = FALSE;
 135   keys = NULL;
 136   path = NULL;
 137   tmpdir = NULL;
 138   abstract = NULL;
 139
 140   keys = g_hash_table_get_keys (key_value_pairs);
 141   for (l = keys; l != NULL; l = l->next)
 142     {
 143       const gchar *key = l->data;
 144       if (g_strcmp0 (key, "path") == 0)
 145         path = g_hash_table_lookup (key_value_pairs, key);
 146       else if (g_strcmp0 (key, "tmpdir") == 0)
 147         tmpdir = g_hash_table_lookup (key_value_pairs, key);
 148       else if (g_strcmp0 (key, "abstract") == 0)
 149         abstract = g_hash_table_lookup (key_value_pairs, key);
 150       else
 151         {
 152           g_set_error (error,
 153                        G_IO_ERROR,
 154                        G_IO_ERROR_INVALID_ARGUMENT,
 155                        _("Unsupported key “%s” in address entry “%s”"),
 156                        key,
 157                        address_entry);
 158           goto out;
 159         }
 160     }
 161
 162   if (path != NULL)
 163     {
 164       if (tmpdir != NULL || abstract != NULL)
 165         goto meaningless;
 166     }
 167   else if (tmpdir != NULL)
 168     {
 169       if (path != NULL || abstract != NULL)
 170         goto meaningless;
 171     }
 172   else if (abstract != NULL)
 173     {
 174       if (path != NULL || tmpdir != NULL)
 175         goto meaningless;
 176     }
 177   else
 178     {
 179       g_set_error (error,
 180                    G_IO_ERROR,
 181                    G_IO_ERROR_INVALID_ARGUMENT,
 182                    _("Address “%s” is invalid (need exactly one of path, tmpdir or abstract keys)"),
 183                    address_entry);
 184       goto out;
 185     }
 186
 187
 188   ret= TRUE;
 189   goto out;
 190
 191  meaningless:
 192   g_set_error (error,
 193                G_IO_ERROR,
 194                G_IO_ERROR_INVALID_ARGUMENT,
 195                _("Meaningless key/value pair combination in address entry “%s”"),
 196                address_entry);
 197
 198  out:
 199   g_list_free (keys);
 200
 201   return ret;
 202 }
 203
 204 static gboolean
 205 is_valid_nonce_tcp (const gchar  *address_entry,
 206                     GHashTable   *key_value_pairs,
 207                     GError      **error)
 208 {
 209   gboolean ret;
 210   GList *keys;
 211   GList *l;
 212   const gchar *host;
 213   const gchar *port;
 214   const gchar *family;
 215   const gchar *nonce_file;
 216   gint port_num;
 217   gchar *endp;
 218
 219   ret = FALSE;
 220   keys = NULL;
 221   host = NULL;
 222   port = NULL;
 223   family = NULL;
 224   nonce_file = NULL;
 225
 226   keys = g_hash_table_get_keys (key_value_pairs);
 227   for (l = keys; l != NULL; l = l->next)
 228     {
 229       const gchar *key = l->data;
 230       if (g_strcmp0 (key, "host") == 0)
 231         host = g_hash_table_lookup (key_value_pairs, key);
 232       else if (g_strcmp0 (key, "port") == 0)
 233         port = g_hash_table_lookup (key_value_pairs, key);
 234       else if (g_strcmp0 (key, "family") == 0)
 235         family = g_hash_table_lookup (key_value_pairs, key);
 236       else if (g_strcmp0 (key, "noncefile") == 0)
 237         nonce_file = g_hash_table_lookup (key_value_pairs, key);
 238       else
 239         {
 240           g_set_error (error,
 241                        G_IO_ERROR,
 242                        G_IO_ERROR_INVALID_ARGUMENT,
 243                        _("Unsupported key “%s” in address entry “%s”"),
 244                        key,
 245                        address_entry);
 246           goto out;
 247         }
 248     }
 249
 250   if (port != NULL)
 251     {
 252       port_num = strtol (port, &endp, 10);
 253       if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)
 254         {
 255           g_set_error (error,
 256                        G_IO_ERROR,
 257                        G_IO_ERROR_INVALID_ARGUMENT,
 258                        _("Error in address “%s” — the port attribute is malformed"),
 259                        address_entry);
 260           goto out;
 261         }
 262     }
 263
 264   if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))
 265     {
 266       g_set_error (error,
 267                    G_IO_ERROR,
 268                    G_IO_ERROR_INVALID_ARGUMENT,
 269                    _("Error in address “%s” — the family attribute is malformed"),
 270                    address_entry);
 271       goto out;
 272     }
 273
 274   if (host != NULL)
 275     {
 276       /* TODO: validate host */
 277     }
 278
 279   nonce_file = nonce_file; /* To avoid -Wunused-but-set-variable */
 280
 281   ret= TRUE;
 282
 283  out:
 284   g_list_free (keys);
 285
 286   return ret;
 287 }
 288
 289 static gboolean
 290 is_valid_tcp (const gchar  *address_entry,
 291               GHashTable   *key_value_pairs,
 292               GError      **error)
 293 {
 294   gboolean ret;
 295   GList *keys;
 296   GList *l;
 297   const gchar *host;
 298   const gchar *port;
 299   const gchar *family;
 300   gint port_num;
 301   gchar *endp;
 302
 303   ret = FALSE;
 304   keys = NULL;
 305   host = NULL;
 306   port = NULL;
 307   family = NULL;
 308
 309   keys = g_hash_table_get_keys (key_value_pairs);
 310   for (l = keys; l != NULL; l = l->next)
 311     {
 312       const gchar *key = l->data;
 313       if (g_strcmp0 (key, "host") == 0)
 314         host = g_hash_table_lookup (key_value_pairs, key);
 315       else if (g_strcmp0 (key, "port") == 0)
 316         port = g_hash_table_lookup (key_value_pairs, key);
 317       else if (g_strcmp0 (key, "family") == 0)
 318         family = g_hash_table_lookup (key_value_pairs, key);
 319       else
 320         {
 321           g_set_error (error,
 322                        G_IO_ERROR,
 323                        G_IO_ERROR_INVALID_ARGUMENT,
 324                        _("Unsupported key “%s” in address entry “%s”"),
 325                        key,
 326                        address_entry);
 327           goto out;
 328         }
 329     }
 330
 331   if (port != NULL)
 332     {
 333       port_num = strtol (port, &endp, 10);
 334       if ((*port == '\0' || *endp != '\0') || port_num < 0 || port_num >= 65536)
 335         {
 336           g_set_error (error,
 337                        G_IO_ERROR,
 338                        G_IO_ERROR_INVALID_ARGUMENT,
 339                        _("Error in address “%s” — the port attribute is malformed"),
 340                        address_entry);
 341           goto out;
 342         }
 343     }
 344
 345   if (family != NULL && !(g_strcmp0 (family, "ipv4") == 0 || g_strcmp0 (family, "ipv6") == 0))
 346     {
 347       g_set_error (error,
 348                    G_IO_ERROR,
 349                    G_IO_ERROR_INVALID_ARGUMENT,
 350                    _("Error in address “%s” — the family attribute is malformed"),
 351                    address_entry);
 352       goto out;
 353     }
 354
 355   if (host != NULL)
 356     {
 357       /* TODO: validate host */
 358     }
 359
 360   ret= TRUE;
 361
 362  out:
 363   g_list_free (keys);
 364
 365   return ret;
 366 }
 367
 368 /**
 369  * g_dbus_is_supported_address:
 370  * @string: A string.
 371  * @error: Return location for error or %NULL.
 372  *
 373  * Like g_dbus_is_address() but also checks if the library supports the
 374  * transports in @string and that key/value pairs for each transport
 375  * are valid. See the specification of the
 376  * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
 377  *
 378  * Returns: %TRUE if @string is a valid D-Bus address that is
 379  * supported by this library, %FALSE if @error is set.
 380  *
 381  * Since: 2.26
 382  */
 383 gboolean
 384 g_dbus_is_supported_address (const gchar  *string,
 385                              GError      **error)
 386 {
 387   guint n;
 388   gchar **a;
 389   gboolean ret;
 390
 391   ret = FALSE;
 392
 393   g_return_val_if_fail (string != NULL, FALSE);
 394   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 395
 396   a = g_strsplit (string, ";", 0);
 397   for (n = 0; a[n] != NULL; n++)
 398     {
 399       gchar *transport_name;
 400       GHashTable *key_value_pairs;
 401       gboolean supported;
 402
 403       if (!_g_dbus_address_parse_entry (a[n],
 404                                         &transport_name,
 405                                         &key_value_pairs,
 406                                         error))
 407         goto out;
 408
 409       supported = FALSE;
 410       if (g_strcmp0 (transport_name, "unix") == 0)
 411         supported = is_valid_unix (a[n], key_value_pairs, error);
 412       else if (g_strcmp0 (transport_name, "tcp") == 0)
 413         supported = is_valid_tcp (a[n], key_value_pairs, error);
 414       else if (g_strcmp0 (transport_name, "nonce-tcp") == 0)
 415         supported = is_valid_nonce_tcp (a[n], key_value_pairs, error);
 416       else if (g_strcmp0 (a[n], "autolaunch:") == 0)
 417         supported = TRUE;
 418
 419       g_free (transport_name);
 420       g_hash_table_unref (key_value_pairs);
 421
 422       if (!supported)
 423         goto out;
 424     }
 425
 426   ret = TRUE;
 427
 428  out:
 429   g_strfreev (a);
 430
 431   g_assert (ret || (!ret && (error == NULL || *error != NULL)));
 432
 433   return ret;
 434 }
 435
 436 gboolean
 437 _g_dbus_address_parse_entry (const gchar  *address_entry,
 438                              gchar       **out_transport_name,
 439                              GHashTable  **out_key_value_pairs,
 440                              GError      **error)
 441 {
 442   gboolean ret;
 443   GHashTable *key_value_pairs;
 444   gchar *transport_name;
 445   gchar **kv_pairs;
 446   const gchar *s;
 447   guint n;
 448
 449   ret = FALSE;
 450   kv_pairs = NULL;
 451   transport_name = NULL;
 452   key_value_pairs = NULL;
 453
 454   s = strchr (address_entry, ':');
 455   if (s == NULL)
 456     {
 457       g_set_error (error,
 458                    G_IO_ERROR,
 459                    G_IO_ERROR_INVALID_ARGUMENT,
 460                    _("Address element “%s” does not contain a colon (:)"),
 461                    address_entry);
 462       goto out;
 463     }
 464
 465   transport_name = g_strndup (address_entry, s - address_entry);
 466   key_value_pairs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 467
 468   kv_pairs = g_strsplit (s + 1, ",", 0);
 469   for (n = 0; kv_pairs != NULL && kv_pairs[n] != NULL; n++)
 470     {
 471       const gchar *kv_pair = kv_pairs[n];
 472       gchar *key;
 473       gchar *value;
 474
 475       s = strchr (kv_pair, '=');
 476       if (s == NULL)
 477         {
 478           g_set_error (error,
 479                        G_IO_ERROR,
 480                        G_IO_ERROR_INVALID_ARGUMENT,
 481                        _("Key/Value pair %d, “%s”, in address element “%s” does not contain an equal sign"),
 482                        n,
 483                        kv_pair,
 484                        address_entry);
 485           goto out;
 486         }
 487
 488       key = g_uri_unescape_segment (kv_pair, s, NULL);
 489       value = g_uri_unescape_segment (s + 1, kv_pair + strlen (kv_pair), NULL);
 490       if (key == NULL || value == NULL)
 491         {
 492           g_set_error (error,
 493                        G_IO_ERROR,
 494                        G_IO_ERROR_INVALID_ARGUMENT,
 495                        _("Error unescaping key or value in Key/Value pair %d, “%s”, in address element “%s”"),
 496                        n,
 497                        kv_pair,
 498                        address_entry);
 499           g_free (key);
 500           g_free (value);
 501           goto out;
 502         }
 503       g_hash_table_insert (key_value_pairs, key, value);
 504     }
 505
 506   ret = TRUE;
 507
 508 out:
 509   g_strfreev (kv_pairs);
 510   if (ret)
 511     {
 512       if (out_transport_name != NULL)
 513         *out_transport_name = transport_name;
 514       else
 515         g_free (transport_name);
 516       if (out_key_value_pairs != NULL)
 517         *out_key_value_pairs = key_value_pairs;
 518       else if (key_value_pairs != NULL)
 519         g_hash_table_unref (key_value_pairs);
 520     }
 521   else
 522     {
 523       g_free (transport_name);
 524       if (key_value_pairs != NULL)
 525         g_hash_table_unref (key_value_pairs);
 526     }
 527   return ret;
 528 }
 529
 530 /* ---------------------------------------------------------------------------------------------------- */
 531
 532 static GIOStream *
 533 g_dbus_address_try_connect_one (const gchar   *address_entry,
 534                                 gchar        **out_guid,
 535                                 GCancellable  *cancellable,
 536                                 GError       **error);
 537
 538 /* TODO: Declare an extension point called GDBusTransport (or similar)
 539  * and move code below to extensions implementing said extension
 540  * point. That way we can implement a D-Bus transport over X11 without
 541  * making libgio link to libX11...
 542  */
 543 static GIOStream *
 544 g_dbus_address_connect (const gchar   *address_entry,
 545                         const gchar   *transport_name,
 546                         GHashTable    *key_value_pairs,
 547                         GCancellable  *cancellable,
 548                         GError       **error)
 549 {
 550   GIOStream *ret;
 551   GSocketConnectable *connectable;
 552   const gchar *nonce_file;
 553
 554   connectable = NULL;
 555   ret = NULL;
 556   nonce_file = NULL;
 557
 558   if (FALSE)
 559     {
 560     }
 561 #ifdef G_OS_UNIX
 562   else if (g_strcmp0 (transport_name, "unix") == 0)
 563     {
 564       const gchar *path;
 565       const gchar *abstract;
 566       path = g_hash_table_lookup (key_value_pairs, "path");
 567       abstract = g_hash_table_lookup (key_value_pairs, "abstract");
 568       if ((path == NULL && abstract == NULL) || (path != NULL && abstract != NULL))
 569         {
 570           g_set_error (error,
 571                        G_IO_ERROR,
 572                        G_IO_ERROR_INVALID_ARGUMENT,
 573                        _("Error in address “%s” — the unix transport requires exactly one of the "
 574                          "keys “path” or “abstract” to be set"),
 575                        address_entry);
 576         }
 577       else if (path != NULL)
 578         {
 579           connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (path));
 580         }
 581       else if (abstract != NULL)
 582         {
 583           connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new_with_type (abstract,
 584                                                                                    -1,
 585                                                                                    G_UNIX_SOCKET_ADDRESS_ABSTRACT));
 586         }
 587       else
 588         {
 589           g_assert_not_reached ();
 590         }
 591     }
 592 #endif
 593   else if (g_strcmp0 (transport_name, "tcp") == 0 || g_strcmp0 (transport_name, "nonce-tcp") == 0)
 594     {
 595       const gchar *s;
 596       const gchar *host;
 597       glong port;
 598       gchar *endp;
 599       gboolean is_nonce;
 600
 601       is_nonce = (g_strcmp0 (transport_name, "nonce-tcp") == 0);
 602
 603       host = g_hash_table_lookup (key_value_pairs, "host");
 604       if (host == NULL)
 605         {
 606           g_set_error (error,
 607                        G_IO_ERROR,
 608                        G_IO_ERROR_INVALID_ARGUMENT,
 609                        _("Error in address “%s” — the host attribute is missing or malformed"),
 610                        address_entry);
 611           goto out;
 612         }
 613
 614       s = g_hash_table_lookup (key_value_pairs, "port");
 615       if (s == NULL)
 616         s = "0";
 617       port = strtol (s, &endp, 10);
 618       if ((*s == '\0' || *endp != '\0') || port < 0 || port >= 65536)
 619         {
 620           g_set_error (error,
 621                        G_IO_ERROR,
 622                        G_IO_ERROR_INVALID_ARGUMENT,
 623                        _("Error in address “%s” — the port attribute is missing or malformed"),
 624                        address_entry);
 625           goto out;
 626         }
 627
 628
 629       if (is_nonce)
 630         {
 631           nonce_file = g_hash_table_lookup (key_value_pairs, "noncefile");
 632           if (nonce_file == NULL)
 633             {
 634               g_set_error (error,
 635                            G_IO_ERROR,
 636                            G_IO_ERROR_INVALID_ARGUMENT,
 637                            _("Error in address “%s” — the noncefile attribute is missing or malformed"),
 638                            address_entry);
 639               goto out;
 640             }
 641         }
 642
 643       /* TODO: deal with family key/value-pair */
 644       connectable = g_network_address_new (host, port);
 645     }
 646   else if (g_strcmp0 (address_entry, "autolaunch:") == 0)
 647     {
 648       gchar *autolaunch_address;
 649       autolaunch_address = get_session_address_dbus_launch (error);
 650       if (autolaunch_address != NULL)
 651         {
 652           ret = g_dbus_address_try_connect_one (autolaunch_address, NULL, cancellable, error);
 653           g_free (autolaunch_address);
 654           goto out;
 655         }
 656       else
 657         {
 658           g_prefix_error (error, _("Error auto-launching: "));
 659         }
 660     }
 661   else
 662     {
 663       g_set_error (error,
 664                    G_IO_ERROR,
 665                    G_IO_ERROR_INVALID_ARGUMENT,
 666                    _("Unknown or unsupported transport “%s” for address “%s”"),
 667                    transport_name,
 668                    address_entry);
 669     }
 670
 671   if (connectable != NULL)
 672     {
 673       GSocketClient *client;
 674       GSocketConnection *connection;
 675
 676       g_assert (ret == NULL);
 677       client = g_socket_client_new ();
 678       connection = g_socket_client_connect (client,
 679                                             connectable,
 680                                             cancellable,
 681                                             error);
 682       g_object_unref (connectable);
 683       g_object_unref (client);
 684       if (connection == NULL)
 685         goto out;
 686
 687       ret = G_IO_STREAM (connection);
 688
 689       if (nonce_file != NULL)
 690         {
 691           gchar nonce_contents[16 + 1];
 692           size_t num_bytes_read;
 693           FILE *f;
 694           int errsv;
 695
 696           /* be careful to read only 16 bytes - we also check that the file is only 16 bytes long */
 697           f = fopen (nonce_file, "rb");
 698           errsv = errno;
 699           if (f == NULL)
 700             {
 701               g_set_error (error,
 702                            G_IO_ERROR,
 703                            G_IO_ERROR_INVALID_ARGUMENT,
 704                            _("Error opening nonce file “%s”: %s"),
 705                            nonce_file,
 706                            g_strerror (errsv));
 707               g_object_unref (ret);
 708               ret = NULL;
 709               goto out;
 710             }
 711           num_bytes_read = fread (nonce_contents,
 712                                   sizeof (gchar),
 713                                   16 + 1,
 714                                   f);
 715           errsv = errno;
 716           if (num_bytes_read != 16)
 717             {
 718               if (num_bytes_read == 0)
 719                 {
 720                   g_set_error (error,
 721                                G_IO_ERROR,
 722                                G_IO_ERROR_INVALID_ARGUMENT,
 723                                _("Error reading from nonce file “%s”: %s"),
 724                                nonce_file,
 725                                g_strerror (errsv));
 726                 }
 727               else
 728                 {
 729                   g_set_error (error,
 730                                G_IO_ERROR,
 731                                G_IO_ERROR_INVALID_ARGUMENT,
 732                                _("Error reading from nonce file “%s”, expected 16 bytes, got %d"),
 733                                nonce_file,
 734                                (gint) num_bytes_read);
 735                 }
 736               g_object_unref (ret);
 737               ret = NULL;
 738               fclose (f);
 739               goto out;
 740             }
 741           fclose (f);
 742
 743           if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),
 744                                           nonce_contents,
 745                                           16,
 746                                           NULL,
 747                                           cancellable,
 748                                           error))
 749             {
 750               g_prefix_error (error, _("Error writing contents of nonce file “%s” to stream:"), nonce_file);
 751               g_object_unref (ret);
 752               ret = NULL;
 753               goto out;
 754             }
 755         }
 756     }
 757
 758  out:
 759
 760   return ret;
 761 }
 762
 763 static GIOStream *
 764 g_dbus_address_try_connect_one (const gchar   *address_entry,
 765                                 gchar        **out_guid,
 766                                 GCancellable  *cancellable,
 767                                 GError       **error)
 768 {
 769   GIOStream *ret;
 770   GHashTable *key_value_pairs;
 771   gchar *transport_name;
 772   const gchar *guid;
 773
 774   ret = NULL;
 775   transport_name = NULL;
 776   key_value_pairs = NULL;
 777
 778   if (!_g_dbus_address_parse_entry (address_entry,
 779                                     &transport_name,
 780                                     &key_value_pairs,
 781                                     error))
 782     goto out;
 783
 784   ret = g_dbus_address_connect (address_entry,
 785                                 transport_name,
 786                                 key_value_pairs,
 787                                 cancellable,
 788                                 error);
 789   if (ret == NULL)
 790     goto out;
 791
 792   guid = g_hash_table_lookup (key_value_pairs, "guid");
 793   if (guid != NULL && out_guid != NULL)
 794     *out_guid = g_strdup (guid);
 795
 796 out:
 797   g_free (transport_name);
 798   if (key_value_pairs != NULL)
 799     g_hash_table_unref (key_value_pairs);
 800   return ret;
 801 }
 802
 803
 804 /* ---------------------------------------------------------------------------------------------------- */
 805
 806 typedef struct {
 807   gchar *address;
 808   gchar *guid;
 809 } GetStreamData;
 810
 811 static void
 812 get_stream_data_free (GetStreamData *data)
 813 {
 814   g_free (data->address);
 815   g_free (data->guid);
 816   g_free (data);
 817 }
 818
 819 static void
 820 get_stream_thread_func (GTask         *task,
 821                         gpointer       source_object,
 822                         gpointer       task_data,
 823                         GCancellable  *cancellable)
 824 {
 825   GetStreamData *data = task_data;
 826   GIOStream *stream;
 827   GError *error = NULL;
 828
 829   stream = g_dbus_address_get_stream_sync (data->address,
 830                                            &data->guid,
 831                                            cancellable,
 832                                            &error);
 833   if (stream)
 834     g_task_return_pointer (task, stream, g_object_unref);
 835   else
 836     g_task_return_error (task, error);
 837 }
 838
 839 /**
 840  * g_dbus_address_get_stream:
 841  * @address: A valid D-Bus address.
 842  * @cancellable: (nullable): A #GCancellable or %NULL.
 843  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 844  * @user_data: Data to pass to @callback.
 845  *
 846  * Asynchronously connects to an endpoint specified by @address and
 847  * sets up the connection so it is in a state to run the client-side
 848  * of the D-Bus authentication conversation. @address must be in the
 849  * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
 850  *
 851  * When the operation is finished, @callback will be invoked. You can
 852  * then call g_dbus_address_get_stream_finish() to get the result of
 853  * the operation.
 854  *
 855  * This is an asynchronous failable function. See
 856  * g_dbus_address_get_stream_sync() for the synchronous version.
 857  *
 858  * Since: 2.26
 859  */
 860 void
 861 g_dbus_address_get_stream (const gchar         *address,
 862                            GCancellable        *cancellable,
 863                            GAsyncReadyCallback  callback,
 864                            gpointer             user_data)
 865 {
 866   GTask *task;
 867   GetStreamData *data;
 868
 869   g_return_if_fail (address != NULL);
 870
 871   data = g_new0 (GetStreamData, 1);
 872   data->address = g_strdup (address);
 873
 874   task = g_task_new (NULL, cancellable, callback, user_data);
 875   g_task_set_source_tag (task, g_dbus_address_get_stream);
 876   g_task_set_task_data (task, data, (GDestroyNotify) get_stream_data_free);
 877   g_task_run_in_thread (task, get_stream_thread_func);
 878   g_object_unref (task);
 879 }
 880
 881 /**
 882  * g_dbus_address_get_stream_finish:
 883  * @res: A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
 884  * @out_guid: (optional) (out): %NULL or return location to store the GUID extracted from @address, if any.
 885  * @error: Return location for error or %NULL.
 886  *
 887  * Finishes an operation started with g_dbus_address_get_stream().
 888  *
 889  * Returns: (transfer full): A #GIOStream or %NULL if @error is set.
 890  *
 891  * Since: 2.26
 892  */
 893 GIOStream *
 894 g_dbus_address_get_stream_finish (GAsyncResult        *res,
 895                                   gchar              **out_guid,
 896                                   GError             **error)
 897 {
 898   GTask *task;
 899   GetStreamData *data;
 900   GIOStream *ret;
 901
 902   g_return_val_if_fail (g_task_is_valid (res, NULL), NULL);
 903   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 904
 905   task = G_TASK (res);
 906   ret = g_task_propagate_pointer (task, error);
 907
 908   if (ret != NULL && out_guid != NULL)
 909     {
 910       data = g_task_get_task_data (task);
 911       *out_guid = data->guid;
 912       data->guid = NULL;
 913     }
 914
 915   return ret;
 916 }
 917
 918 /**
 919  * g_dbus_address_get_stream_sync:
 920  * @address: A valid D-Bus address.
 921  * @out_guid: (optional) (out): %NULL or return location to store the GUID extracted from @address, if any.
 922  * @cancellable: (nullable): A #GCancellable or %NULL.
 923  * @error: Return location for error or %NULL.
 924  *
 925  * Synchronously connects to an endpoint specified by @address and
 926  * sets up the connection so it is in a state to run the client-side
 927  * of the D-Bus authentication conversation. @address must be in the
 928  * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
 929  *
 930  * This is a synchronous failable function. See
 931  * g_dbus_address_get_stream() for the asynchronous version.
 932  *
 933  * Returns: (transfer full): A #GIOStream or %NULL if @error is set.
 934  *
 935  * Since: 2.26
 936  */
 937 GIOStream *
 938 g_dbus_address_get_stream_sync (const gchar   *address,
 939                                 gchar        **out_guid,
 940                                 GCancellable  *cancellable,
 941                                 GError       **error)
 942 {
 943   GIOStream *ret;
 944   gchar **addr_array;
 945   guint n;
 946   GError *last_error;
 947
 948   g_return_val_if_fail (address != NULL, NULL);
 949   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 950
 951   ret = NULL;
 952   last_error = NULL;
 953
 954   addr_array = g_strsplit (address, ";", 0);
 955   if (addr_array != NULL && addr_array[0] == NULL)
 956     {
 957       last_error = g_error_new_literal (G_IO_ERROR,
 958                                         G_IO_ERROR_INVALID_ARGUMENT,
 959                                         _("The given address is empty"));
 960       goto out;
 961     }
 962
 963   for (n = 0; addr_array != NULL && addr_array[n] != NULL; n++)
 964     {
 965       const gchar *addr = addr_array[n];
 966       GError *this_error;
 967
 968       this_error = NULL;
 969       ret = g_dbus_address_try_connect_one (addr,
 970                                             out_guid,
 971                                             cancellable,
 972                                             &this_error);
 973       if (ret != NULL)
 974         {
 975           goto out;
 976         }
 977       else
 978         {
 979           g_assert (this_error != NULL);
 980           if (last_error != NULL)
 981             g_error_free (last_error);
 982           last_error = this_error;
 983         }
 984     }
 985
 986  out:
 987   if (ret != NULL)
 988     {
 989       if (last_error != NULL)
 990         g_error_free (last_error);
 991     }
 992   else
 993     {
 994       g_assert (last_error != NULL);
 995       g_propagate_error (error, last_error);
 996     }
 997
 998   g_strfreev (addr_array);
 999   return ret;
1000 }
1001
1002 /* ---------------------------------------------------------------------------------------------------- */
1003
1004 /*
1005  * Return the address of XDG_RUNTIME_DIR/bus if it exists, belongs to
1006  * us, and is a socket, and we are on Unix.
1007  */
1008 static gchar *
1009 get_session_address_xdg (void)
1010 {
1011 #ifdef G_OS_UNIX
1012   gchar *ret = NULL;
1013   gchar *bus;
1014   gchar *tmp;
1015   GStatBuf buf;
1016
1017   bus = g_build_filename (g_get_user_runtime_dir (), "bus", NULL);
1018
1019   /* if ENOENT, EPERM, etc., quietly don't use it */
1020   if (g_stat (bus, &buf) < 0)
1021     goto out;
1022
1023   /* if it isn't ours, we have incorrectly inherited someone else's
1024    * XDG_RUNTIME_DIR; silently don't use it
1025    */
1026   if (buf.st_uid != geteuid ())
1027     goto out;
1028
1029   /* if it isn't a socket, silently don't use it */
1030   if ((buf.st_mode & S_IFMT) != S_IFSOCK)
1031     goto out;
1032
1033   tmp = g_dbus_address_escape_value (bus);
1034   ret = g_strconcat ("unix:path=", tmp, NULL);
1035   g_free (tmp);
1036
1037 out:
1038   g_free (bus);
1039   return ret;
1040 #else
1041   return NULL;
1042 #endif
1043 }
1044
1045 /* ---------------------------------------------------------------------------------------------------- */
1046
1047 #ifdef G_OS_UNIX
1048 static gchar *
1049 get_session_address_dbus_launch (GError **error)
1050 {
1051   gchar *ret;
1052   gchar *machine_id;
1053   gchar *command_line;
1054   gchar *launch_stdout;
1055   gchar *launch_stderr;
1056   gint exit_status;
1057   gchar *old_dbus_verbose;
1058   gboolean restore_dbus_verbose;
1059
1060   ret = NULL;
1061   machine_id = NULL;
1062   command_line = NULL;
1063   launch_stdout = NULL;
1064   launch_stderr = NULL;
1065   restore_dbus_verbose = FALSE;
1066   old_dbus_verbose = NULL;
1067
1068   /* Don't run binaries as root if we're setuid. */
1069   if (GLIB_PRIVATE_CALL (g_check_setuid) ())
1070     {
1071       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
1072                    _("Cannot spawn a message bus when setuid"));
1073       goto out;
1074     }
1075
1076   machine_id = _g_dbus_get_machine_id (error);
1077   if (machine_id == NULL)
1078     {
1079       g_prefix_error (error, _("Cannot spawn a message bus without a machine-id: "));
1080       goto out;
1081     }
1082
1083   if (g_getenv ("DISPLAY") == NULL)
1084     {
1085       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
1086                    _("Cannot autolaunch D-Bus without X11 $DISPLAY"));
1087       goto out;
1088     }
1089
1090   /* We're using private libdbus facilities here. When everything
1091    * (X11, Mac OS X, Windows) is spec'ed out correctly (not even the
1092    * X11 property is correctly documented right now) we should
1093    * consider using the spec instead of dbus-launch.
1094    *
1095    *   --autolaunch=MACHINEID
1096    *          This option implies that dbus-launch should scan  for  a  previ‐
1097    *          ously-started  session  and  reuse the values found there. If no
1098    *          session is found, it will start a new session. The  --exit-with-
1099    *          session option is implied if --autolaunch is given.  This option
1100    *          is for the exclusive use of libdbus, you do not want to  use  it
1101    *          manually. It may change in the future.
1102    */
1103
1104   /* TODO: maybe provide a variable for where to look for the dbus-launch binary? */
1105   command_line = g_strdup_printf ("dbus-launch --autolaunch=%s --binary-syntax --close-stderr", machine_id);
1106
1107   if (G_UNLIKELY (_g_dbus_debug_address ()))
1108     {
1109       _g_dbus_debug_print_lock ();
1110       g_print ("GDBus-debug:Address: Running '%s' to get bus address (possibly autolaunching)\n", command_line);
1111       old_dbus_verbose = g_strdup (g_getenv ("DBUS_VERBOSE"));
1112       restore_dbus_verbose = TRUE;
1113       g_setenv ("DBUS_VERBOSE", "1", TRUE);
1114       _g_dbus_debug_print_unlock ();
1115     }
1116
1117   if (!g_spawn_command_line_sync (command_line,
1118                                   &launch_stdout,
1119                                   &launch_stderr,
1120                                   &exit_status,
1121                                   error))
1122     {
1123       goto out;
1124     }
1125
1126   if (!g_spawn_check_exit_status (exit_status, error))
1127     {
1128       g_prefix_error (error, _("Error spawning command line “%s”: "), command_line);
1129       goto out;
1130     }
1131
1132   /* From the dbus-launch(1) man page:
1133    *
1134    *   --binary-syntax Write to stdout a nul-terminated bus address,
1135    *   then the bus PID as a binary integer of size sizeof(pid_t),
1136    *   then the bus X window ID as a binary integer of size
1137    *   sizeof(long).  Integers are in the machine's byte order, not
1138    *   network byte order or any other canonical byte order.
1139    */
1140   ret = g_strdup (launch_stdout);
1141
1142  out:
1143   if (G_UNLIKELY (_g_dbus_debug_address ()))
1144     {
1145       gchar *s;
1146       _g_dbus_debug_print_lock ();
1147       g_print ("GDBus-debug:Address: dbus-launch output:");
1148       if (launch_stdout != NULL)
1149         {
1150           s = _g_dbus_hexdump (launch_stdout, strlen (launch_stdout) + 1 + sizeof (pid_t) + sizeof (long), 2);
1151           g_print ("\n%s", s);
1152           g_free (s);
1153         }
1154       else
1155         {
1156           g_print (" (none)\n");
1157         }
1158       g_print ("GDBus-debug:Address: dbus-launch stderr output:");
1159       if (launch_stderr != NULL)
1160         g_print ("\n%s", launch_stderr);
1161       else
1162         g_print (" (none)\n");
1163       _g_dbus_debug_print_unlock ();
1164     }
1165
1166   g_free (machine_id);
1167   g_free (command_line);
1168   g_free (launch_stdout);
1169   g_free (launch_stderr);
1170   if (G_UNLIKELY (restore_dbus_verbose))
1171     {
1172       if (old_dbus_verbose != NULL)
1173         g_setenv ("DBUS_VERBOSE", old_dbus_verbose, TRUE);
1174       else
1175         g_unsetenv ("DBUS_VERBOSE");
1176     }
1177   g_free (old_dbus_verbose);
1178   return ret;
1179 }
1180
1181 /* end of G_OS_UNIX case */
1182 #elif defined(G_OS_WIN32)
1183
1184 #define DBUS_DAEMON_ADDRESS_INFO "DBusDaemonAddressInfo"
1185 #define DBUS_DAEMON_MUTEX "DBusDaemonMutex"
1186 #define UNIQUE_DBUS_INIT_MUTEX "UniqueDBusInitMutex"
1187 #define DBUS_AUTOLAUNCH_MUTEX "DBusAutolaunchMutex"
1188
1189 static void
1190 release_mutex (HANDLE mutex)
1191 {
1192   ReleaseMutex (mutex);
1193   CloseHandle (mutex);
1194 }
1195
1196 static HANDLE
1197 acquire_mutex (const char *mutexname)
1198 {
1199   HANDLE mutex;
1200   DWORD res;
1201
1202   mutex = CreateMutexA (NULL, FALSE, mutexname);
1203   if (!mutex)
1204     return 0;
1205
1206   res = WaitForSingleObject (mutex, INFINITE);
1207   switch (res)
1208     {
1209     case WAIT_ABANDONED:
1210       release_mutex (mutex);
1211       return 0;
1212     case WAIT_FAILED:
1213     case WAIT_TIMEOUT:
1214       return 0;
1215     }
1216
1217   return mutex;
1218 }
1219
1220 static gboolean
1221 is_mutex_owned (const char *mutexname)
1222 {
1223   HANDLE mutex;
1224   gboolean res = FALSE;
1225
1226   mutex = CreateMutexA (NULL, FALSE, mutexname);
1227   if (WaitForSingleObject (mutex, 10) == WAIT_TIMEOUT)
1228     res = TRUE;
1229   else
1230     ReleaseMutex (mutex);
1231   CloseHandle (mutex);
1232
1233   return res;
1234 }
1235
1236 static char *
1237 read_shm (const char *shm_name)
1238 {
1239   HANDLE shared_mem;
1240   char *shared_data;
1241   char *res;
1242   int i;
1243
1244   res = NULL;
1245
1246   for (i = 0; i < 20; i++)
1247     {
1248       shared_mem = OpenFileMappingA (FILE_MAP_READ, FALSE, shm_name);
1249       if (shared_mem != 0)
1250         break;
1251       Sleep (100);
1252     }
1253
1254   if (shared_mem != 0)
1255     {
1256       shared_data = MapViewOfFile (shared_mem, FILE_MAP_READ, 0, 0, 0);
1257       if (shared_data != NULL)
1258         {
1259           res = g_strdup (shared_data);
1260           UnmapViewOfFile (shared_data);
1261         }
1262       CloseHandle (shared_mem);
1263     }
1264
1265   return res;
1266 }
1267
1268 static HANDLE
1269 set_shm (const char *shm_name, const char *value)
1270 {
1271   HANDLE shared_mem;
1272   char *shared_data;
1273
1274   shared_mem = CreateFileMappingA (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
1275                                    0, strlen (value) + 1, shm_name);
1276   if (shared_mem == 0)
1277     return 0;
1278
1279   shared_data = MapViewOfFile (shared_mem, FILE_MAP_WRITE, 0, 0, 0 );
1280   if (shared_data == NULL)
1281     return 0;
1282
1283   strcpy (shared_data, value);
1284
1285   UnmapViewOfFile (shared_data);
1286
1287   return shared_mem;
1288 }
1289
1290 /* These keep state between publish_session_bus and unpublish_session_bus */
1291 static HANDLE published_daemon_mutex;
1292 static HANDLE published_shared_mem;
1293
1294 static gboolean
1295 publish_session_bus (const char *address)
1296 {
1297   HANDLE init_mutex;
1298
1299   init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX);
1300
1301   published_daemon_mutex = CreateMutexA (NULL, FALSE, DBUS_DAEMON_MUTEX);
1302   if (WaitForSingleObject (published_daemon_mutex, 10 ) != WAIT_OBJECT_0)
1303     {
1304       release_mutex (init_mutex);
1305       CloseHandle (published_daemon_mutex);
1306       published_daemon_mutex = NULL;
1307       return FALSE;
1308     }
1309
1310   published_shared_mem = set_shm (DBUS_DAEMON_ADDRESS_INFO, address);
1311   if (!published_shared_mem)
1312     {
1313       release_mutex (init_mutex);
1314       CloseHandle (published_daemon_mutex);
1315       published_daemon_mutex = NULL;
1316       return FALSE;
1317     }
1318
1319   release_mutex (init_mutex);
1320   return TRUE;
1321 }
1322
1323 static void
1324 unpublish_session_bus (void)
1325 {
1326   HANDLE init_mutex;
1327
1328   init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX);
1329
1330   CloseHandle (published_shared_mem);
1331   published_shared_mem = NULL;
1332
1333   release_mutex (published_daemon_mutex);
1334   published_daemon_mutex = NULL;
1335
1336   release_mutex (init_mutex);
1337 }
1338
1339 static void
1340 wait_console_window (void)
1341 {
1342   FILE *console = fopen ("CONOUT$", "w");
1343
1344   SetConsoleTitleW (L"gdbus-daemon output. Type any character to close this window.");
1345   fprintf (console, _("(Type any character to close this window)\n"));
1346   fflush (console);
1347   _getch ();
1348 }
1349
1350 static void
1351 open_console_window (void)
1352 {
1353   if (((HANDLE) _get_osfhandle (fileno (stdout)) == INVALID_HANDLE_VALUE ||
1354        (HANDLE) _get_osfhandle (fileno (stderr)) == INVALID_HANDLE_VALUE) && AllocConsole ())
1355     {
1356       if ((HANDLE) _get_osfhandle (fileno (stdout)) == INVALID_HANDLE_VALUE)
1357         freopen ("CONOUT$", "w", stdout);
1358
1359       if ((HANDLE) _get_osfhandle (fileno (stderr)) == INVALID_HANDLE_VALUE)
1360         freopen ("CONOUT$", "w", stderr);
1361
1362       SetConsoleTitleW (L"gdbus-daemon debug output.");
1363
1364       atexit (wait_console_window);
1365     }
1366 }
1367
1368 static void
1369 idle_timeout_cb (GDBusDaemon *daemon, gpointer user_data)
1370 {
1371   GMainLoop *loop = user_data;
1372   g_main_loop_quit (loop);
1373 }
1374
1375 /* Satisfies STARTF_FORCEONFEEDBACK */
1376 static void
1377 turn_off_the_starting_cursor (void)
1378 {
1379   MSG msg;
1380   BOOL bRet;
1381
1382   PostQuitMessage (0);
1383
1384   while ((bRet = GetMessage (&msg, 0, 0, 0)) != 0)
1385     {
1386       if (bRet == -1)
1387         continue;
1388
1389       TranslateMessage (&msg);
1390       DispatchMessage (&msg);
1391     }
1392 }
1393
1394 __declspec(dllexport) void CALLBACK g_win32_run_session_bus (HWND hwnd, HINSTANCE hinst, char *cmdline, int nCmdShow);
1395
1396 __declspec(dllexport) void CALLBACK
1397 g_win32_run_session_bus (HWND hwnd, HINSTANCE hinst, char *cmdline, int nCmdShow)
1398 {
1399   GDBusDaemon *daemon;
1400   GMainLoop *loop;
1401   const char *address;
1402   GError *error = NULL;
1403
1404   turn_off_the_starting_cursor ();
1405
1406   if (g_getenv ("GDBUS_DAEMON_DEBUG") != NULL)
1407     open_console_window ();
1408
1409   loop = g_main_loop_new (NULL, FALSE);
1410
1411   address = "nonce-tcp:";
1412   daemon = _g_dbus_daemon_new (address, NULL, &error);
1413   if (daemon == NULL)
1414     {
1415       g_printerr ("Can't init bus: %s\n", error->message);
1416       g_error_free (error);
1417       return;
1418     }
1419
1420   g_signal_connect (daemon, "idle-timeout", G_CALLBACK (idle_timeout_cb), loop);
1421
1422   if (publish_session_bus (_g_dbus_daemon_get_address (daemon)))
1423     {
1424       g_main_loop_run (loop);
1425
1426       unpublish_session_bus ();
1427     }
1428
1429   g_main_loop_unref (loop);
1430   g_object_unref (daemon);
1431 }
1432
1433 static gchar *
1434 get_session_address_dbus_launch (GError **error)
1435 {
1436   HANDLE autolaunch_mutex, init_mutex;
1437   char *address = NULL;
1438   wchar_t gio_path[MAX_PATH+1+200];
1439
1440   autolaunch_mutex = acquire_mutex (DBUS_AUTOLAUNCH_MUTEX);
1441
1442   init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX);
1443
1444   if (is_mutex_owned (DBUS_DAEMON_MUTEX))
1445     address = read_shm (DBUS_DAEMON_ADDRESS_INFO);
1446
1447   release_mutex (init_mutex);
1448
1449   if (address == NULL)
1450     {
1451       gio_path[MAX_PATH] = 0;
1452       if (GetModuleFileNameW (_g_io_win32_get_module (), gio_path, MAX_PATH))
1453         {
1454           PROCESS_INFORMATION pi = { 0 };
1455           STARTUPINFOW si = { 0 };
1456           BOOL res;
1457           wchar_t gio_path_short[MAX_PATH];
1458           wchar_t rundll_path[MAX_PATH*2];
1459           wchar_t args[MAX_PATH*4];
1460
1461           GetShortPathNameW (gio_path, gio_path_short, MAX_PATH);
1462
1463           GetWindowsDirectoryW (rundll_path, MAX_PATH);
1464           wcscat (rundll_path, L"\\rundll32.exe");
1465           if (GetFileAttributesW (rundll_path) == INVALID_FILE_ATTRIBUTES)
1466             {
1467               GetSystemDirectoryW (rundll_path, MAX_PATH);
1468               wcscat (rundll_path, L"\\rundll32.exe");
1469             }
1470
1471           wcscpy (args, L"\"");
1472           wcscat (args, rundll_path);
1473           wcscat (args, L"\" ");
1474           wcscat (args, gio_path_short);
1475 #if defined(_WIN64) || defined(_M_X64) || defined(_M_AMD64)
1476           wcscat (args, L",g_win32_run_session_bus");
1477 #elif defined (_MSC_VER)
1478           wcscat (args, L",_g_win32_run_session_bus@16");
1479 #else
1480           wcscat (args, L",g_win32_run_session_bus@16");
1481 #endif
1482
1483           res = CreateProcessW (rundll_path, args,
1484                                 0, 0, FALSE,
1485                                 NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW | DETACHED_PROCESS,
1486                                 0, NULL /* TODO: Should be root */,
1487                                 &si, &pi);
1488           if (res)
1489             address = read_shm (DBUS_DAEMON_ADDRESS_INFO);
1490         }
1491     }
1492
1493   release_mutex (autolaunch_mutex);
1494
1495   if (address == NULL)
1496     g_set_error (error,
1497                  G_IO_ERROR,
1498                  G_IO_ERROR_FAILED,
1499                  _("Session dbus not running, and autolaunch failed"));
1500
1501   return address;
1502 }
1503 #else /* neither G_OS_UNIX nor G_OS_WIN32 */
1504 static gchar *
1505 get_session_address_dbus_launch (GError **error)
1506 {
1507   g_set_error (error,
1508                G_IO_ERROR,
1509                G_IO_ERROR_FAILED,
1510                _("Cannot determine session bus address (not implemented for this OS)"));
1511   return NULL;
1512 }
1513 #endif /* neither G_OS_UNIX nor G_OS_WIN32 */
1514
1515 /* ---------------------------------------------------------------------------------------------------- */
1516
1517 static gchar *
1518 get_session_address_platform_specific (GError **error)
1519 {
1520   gchar *ret;
1521
1522   /* Use XDG_RUNTIME_DIR/bus if it exists and is suitable. This is appropriate
1523    * for systems using the "a session is a user-session" model described in
1524    * <http://lists.freedesktop.org/archives/dbus/2015-January/016522.html>,
1525    * and implemented in dbus >= 1.9.14 and sd-bus.
1526    *
1527    * On systems following the more traditional "a session is a login-session"
1528    * model, this will fail and we'll fall through to X11 autolaunching
1529    * (dbus-launch) below.
1530    */
1531   ret = get_session_address_xdg ();
1532
1533   if (ret != NULL)
1534     return ret;
1535
1536   /* TODO (#694472): try launchd on OS X, like
1537    * _dbus_lookup_session_address_launchd() does, since
1538    * 'dbus-launch --autolaunch' probably won't work there
1539    */
1540
1541   /* As a last resort, try the "autolaunch:" transport. On Unix this means
1542    * X11 autolaunching; on Windows this means a different autolaunching
1543    * mechanism based on shared memory.
1544    */
1545   return get_session_address_dbus_launch (error);
1546 }
1547
1548 /* ---------------------------------------------------------------------------------------------------- */
1549
1550 /**
1551  * g_dbus_address_get_for_bus_sync:
1552  * @bus_type: a #GBusType
1553  * @cancellable: (nullable): a #GCancellable or %NULL
1554  * @error: return location for error or %NULL
1555  *
1556  * Synchronously looks up the D-Bus address for the well-known message
1557  * bus instance specified by @bus_type. This may involve using various
1558  * platform specific mechanisms.
1559  *
1560  * The returned address will be in the
1561  * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
1562  *
1563  * Returns: a valid D-Bus address string for @bus_type or %NULL if
1564  *     @error is set
1565  *
1566  * Since: 2.26
1567  */
1568 gchar *
1569 g_dbus_address_get_for_bus_sync (GBusType       bus_type,
1570                                  GCancellable  *cancellable,
1571                                  GError       **error)
1572 {
1573   gchar *ret, *s = NULL;
1574   const gchar *starter_bus;
1575   GError *local_error;
1576
1577   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1578
1579   ret = NULL;
1580   local_error = NULL;
1581
1582   if (G_UNLIKELY (_g_dbus_debug_address ()))
1583     {
1584       guint n;
1585       _g_dbus_debug_print_lock ();
1586       s = _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type);
1587       g_print ("GDBus-debug:Address: In g_dbus_address_get_for_bus_sync() for bus type '%s'\n",
1588                s);
1589       g_free (s);
1590       for (n = 0; n < 3; n++)
1591         {
1592           const gchar *k;
1593           const gchar *v;
1594           switch (n)
1595             {
1596             case 0: k = "DBUS_SESSION_BUS_ADDRESS"; break;
1597             case 1: k = "DBUS_SYSTEM_BUS_ADDRESS"; break;
1598             case 2: k = "DBUS_STARTER_BUS_TYPE"; break;
1599             default: g_assert_not_reached ();
1600             }
1601           v = g_getenv (k);
1602           g_print ("GDBus-debug:Address: env var %s", k);
1603           if (v != NULL)
1604             g_print ("='%s'\n", v);
1605           else
1606             g_print (" is not set\n");
1607         }
1608       _g_dbus_debug_print_unlock ();
1609     }
1610
1611   switch (bus_type)
1612     {
1613     case G_BUS_TYPE_SYSTEM:
1614       ret = g_strdup (g_getenv ("DBUS_SYSTEM_BUS_ADDRESS"));
1615       if (ret == NULL)
1616         {
1617           ret = g_strdup ("unix:path=/var/run/dbus/system_bus_socket");
1618         }
1619       break;
1620
1621     case G_BUS_TYPE_SESSION:
1622       ret = g_strdup (g_getenv ("DBUS_SESSION_BUS_ADDRESS"));
1623       if (ret == NULL)
1624         {
1625           ret = get_session_address_platform_specific (&local_error);
1626         }
1627       break;
1628
1629     case G_BUS_TYPE_STARTER:
1630       starter_bus = g_getenv ("DBUS_STARTER_BUS_TYPE");
1631       if (g_strcmp0 (starter_bus, "session") == 0)
1632         {
1633           ret = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SESSION, cancellable, &local_error);
1634           goto out;
1635         }
1636       else if (g_strcmp0 (starter_bus, "system") == 0)
1637         {
1638           ret = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SYSTEM, cancellable, &local_error);
1639           goto out;
1640         }
1641       else
1642         {
1643           if (starter_bus != NULL)
1644             {
1645               g_set_error (&local_error,
1646                            G_IO_ERROR,
1647                            G_IO_ERROR_FAILED,
1648                            _("Cannot determine bus address from DBUS_STARTER_BUS_TYPE environment variable"
1649                              " — unknown value “%s”"),
1650                            starter_bus);
1651             }
1652           else
1653             {
1654               g_set_error_literal (&local_error,
1655                                    G_IO_ERROR,
1656                                    G_IO_ERROR_FAILED,
1657                                    _("Cannot determine bus address because the DBUS_STARTER_BUS_TYPE environment "
1658                                      "variable is not set"));
1659             }
1660         }
1661       break;
1662
1663     default:
1664       g_set_error (&local_error,
1665                    G_IO_ERROR,
1666                    G_IO_ERROR_FAILED,
1667                    _("Unknown bus type %d"),
1668                    bus_type);
1669       break;
1670     }
1671
1672  out:
1673   if (G_UNLIKELY (_g_dbus_debug_address ()))
1674     {
1675       _g_dbus_debug_print_lock ();
1676       s = _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type);
1677       if (ret != NULL)
1678         {
1679           g_print ("GDBus-debug:Address: Returning address '%s' for bus type '%s'\n",
1680                    ret, s);
1681         }
1682       else
1683         {
1684           g_print ("GDBus-debug:Address: Cannot look-up address bus type '%s': %s\n",
1685                    s, local_error ? local_error->message : "");
1686         }
1687       g_free (s);
1688       _g_dbus_debug_print_unlock ();
1689     }
1690
1691   if (local_error != NULL)
1692     g_propagate_error (error, local_error);
1693
1694   return ret;
1695 }
1696
1697 /**
1698  * g_dbus_address_escape_value:
1699  * @string: an unescaped string to be included in a D-Bus address
1700  *     as the value in a key-value pair
1701  *
1702  * Escape @string so it can appear in a D-Bus address as the value
1703  * part of a key-value pair.
1704  *
1705  * For instance, if @string is `/run/bus-for-:0`,
1706  * this function would return `/run/bus-for-%3A0`,
1707  * which could be used in a D-Bus address like
1708  * `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`.
1709  *
1710  * Returns: (transfer full): a copy of @string with all
1711  *     non-optionally-escaped bytes escaped
1712  *
1713  * Since: 2.36
1714  */
1715 gchar *
1716 g_dbus_address_escape_value (const gchar *string)
1717 {
1718   GString *s;
1719   gsize i;
1720
1721   g_return_val_if_fail (string != NULL, NULL);
1722
1723   /* There will often not be anything needing escaping at all. */
1724   s = g_string_sized_new (strlen (string));
1725
1726   /* D-Bus address escaping is mostly the same as URI escaping... */
1727   g_string_append_uri_escaped (s, string, "\\/", FALSE);
1728
1729   /* ... but '~' is an unreserved character in URIs, but a
1730    * non-optionally-escaped character in D-Bus addresses. */
1731   for (i = 0; i < s->len; i++)
1732     {
1733       if (G_UNLIKELY (s->str[i] == '~'))
1734         {
1735           s->str[i] = '%';
1736           g_string_insert (s, i + 1, "7E");
1737           i += 2;
1738         }
1739     }
1740
1741   return g_string_free (s, FALSE);
1742 }