gio/gdbusprivate.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 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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: David Zeuthen <davidz@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #ifdef HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30
  31 #include "giotypes.h"
  32 #include "gsocket.h"
  33 #include "gdbusprivate.h"
  34 #include "gdbusmessage.h"
  35 #include "gdbuserror.h"
  36 #include "gdbusintrospection.h"
  37 #include "gasyncresult.h"
  38 #include "gsimpleasyncresult.h"
  39 #include "ginputstream.h"
  40 #include "giostream.h"
  41 #include "gsocketcontrolmessage.h"
  42 #include "gsocketconnection.h"
  43
  44 #ifdef G_OS_UNIX
  45 #include "gunixfdmessage.h"
  46 #include "gunixconnection.h"
  47 #include "gunixcredentialsmessage.h"
  48 #endif
  49
  50 #ifdef G_OS_WIN32
  51 #include <windows.h>
  52 #endif
  53
  54 #include "glibintl.h"
  55 #include "gioalias.h"
  56
  57 /* ---------------------------------------------------------------------------------------------------- */
  58
  59 gchar *
  60 _g_dbus_hexdump (const gchar *data, gsize len, guint indent)
  61 {
  62  guint n, m;
  63  GString *ret;
  64
  65  ret = g_string_new (NULL);
  66
  67  for (n = 0; n < len; n += 16)
  68    {
  69      g_string_append_printf (ret, "%*s%04x: ", indent, "", n);
  70
  71      for (m = n; m < n + 16; m++)
  72        {
  73          if (m > n && (m%4) == 0)
  74            g_string_append_c (ret, ' ');
  75          if (m < len)
  76            g_string_append_printf (ret, "%02x ", (guchar) data[m]);
  77          else
  78            g_string_append (ret, "   ");
  79        }
  80
  81      g_string_append (ret, "   ");
  82
  83      for (m = n; m < len && m < n + 16; m++)
  84        g_string_append_c (ret, g_ascii_isprint (data[m]) ? data[m] : '.');
  85
  86      g_string_append_c (ret, '\n');
  87    }
  88
  89  return g_string_free (ret, FALSE);
  90 }
  91
  92 /* ---------------------------------------------------------------------------------------------------- */
  93
  94 /* Unfortunately ancillary messages are discarded when reading from a
  95  * socket using the GSocketInputStream abstraction. So we provide a
  96  * very GInputStream-ish API that uses GSocket in this case (very
  97  * similar to GSocketInputStream).
  98  */
  99
 100 typedef struct
 101 {
 102   GSocket *socket;
 103   GCancellable *cancellable;
 104
 105   void *buffer;
 106   gsize count;
 107
 108   GSocketControlMessage ***messages;
 109   gint *num_messages;
 110
 111   GSimpleAsyncResult *simple;
 112
 113   gboolean from_mainloop;
 114 } ReadWithControlData;
 115
 116 static void
 117 read_with_control_data_free (ReadWithControlData *data)
 118 {
 119   g_object_unref (data->socket);
 120   if (data->cancellable != NULL)
 121     g_object_unref (data->cancellable);
 122   g_object_unref (data->simple);
 123   g_free (data);
 124 }
 125
 126 static gboolean
 127 _g_socket_read_with_control_messages_ready (GSocket      *socket,
 128                                             GIOCondition  condition,
 129                                             gpointer      user_data)
 130 {
 131   ReadWithControlData *data = user_data;
 132   GError *error;
 133   gssize result;
 134   GInputVector vector;
 135
 136   error = NULL;
 137   vector.buffer = data->buffer;
 138   vector.size = data->count;
 139   result = g_socket_receive_message (data->socket,
 140                                      NULL, /* address */
 141                                      &vector,
 142                                      1,
 143                                      data->messages,
 144                                      data->num_messages,
 145                                      NULL,
 146                                      data->cancellable,
 147                                      &error);
 148   if (result >= 0)
 149     {
 150       g_simple_async_result_set_op_res_gssize (data->simple, result);
 151     }
 152   else
 153     {
 154       g_assert (error != NULL);
 155       g_simple_async_result_set_from_error (data->simple, error);
 156       g_error_free (error);
 157     }
 158
 159   if (data->from_mainloop)
 160     g_simple_async_result_complete (data->simple);
 161   else
 162     g_simple_async_result_complete_in_idle (data->simple);
 163
 164   return FALSE;
 165 }
 166
 167 static void
 168 _g_socket_read_with_control_messages (GSocket                 *socket,
 169                                       void                    *buffer,
 170                                       gsize                    count,
 171                                       GSocketControlMessage ***messages,
 172                                       gint                    *num_messages,
 173                                       gint                     io_priority,
 174                                       GCancellable            *cancellable,
 175                                       GAsyncReadyCallback      callback,
 176                                       gpointer                 user_data)
 177 {
 178   ReadWithControlData *data;
 179
 180   data = g_new0 (ReadWithControlData, 1);
 181   data->socket = g_object_ref (socket);
 182   data->cancellable = cancellable != NULL ? g_object_ref (cancellable) : NULL;
 183   data->buffer = buffer;
 184   data->count = count;
 185   data->messages = messages;
 186   data->num_messages = num_messages;
 187
 188   data->simple = g_simple_async_result_new (G_OBJECT (socket),
 189                                             callback,
 190                                             user_data,
 191                                             _g_socket_read_with_control_messages);
 192
 193   if (!g_socket_condition_check (socket, G_IO_IN))
 194     {
 195       GSource *source;
 196       data->from_mainloop = TRUE;
 197       source = g_socket_create_source (data->socket,
 198                                        G_IO_IN | G_IO_HUP | G_IO_ERR,
 199                                        cancellable);
 200       g_source_set_callback (source,
 201                              (GSourceFunc) _g_socket_read_with_control_messages_ready,
 202                              data,
 203                              (GDestroyNotify) read_with_control_data_free);
 204       g_source_attach (source, g_main_context_get_thread_default ());
 205       g_source_unref (source);
 206     }
 207   else
 208     {
 209       _g_socket_read_with_control_messages_ready (data->socket, G_IO_IN, data);
 210       read_with_control_data_free (data);
 211     }
 212 }
 213
 214 static gssize
 215 _g_socket_read_with_control_messages_finish (GSocket       *socket,
 216                                              GAsyncResult  *result,
 217                                              GError       **error)
 218 {
 219   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 220
 221   g_return_val_if_fail (G_IS_SOCKET (socket), -1);
 222   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == _g_socket_read_with_control_messages);
 223
 224   if (g_simple_async_result_propagate_error (simple, error))
 225       return -1;
 226   else
 227     return g_simple_async_result_get_op_res_gssize (simple);
 228 }
 229
 230 /* ---------------------------------------------------------------------------------------------------- */
 231
 232 G_LOCK_DEFINE_STATIC (shared_thread_lock);
 233
 234 typedef struct
 235 {
 236   gint num_users;
 237   GThread *thread;
 238   GMainContext *context;
 239   GMainLoop *loop;
 240 } SharedThreadData;
 241
 242 static SharedThreadData *shared_thread_data = NULL;
 243
 244 static gpointer
 245 shared_thread_func (gpointer data)
 246 {
 247   g_main_context_push_thread_default (shared_thread_data->context);
 248   g_main_loop_run (shared_thread_data->loop);
 249   g_main_context_pop_thread_default (shared_thread_data->context);
 250   return NULL;
 251 }
 252
 253 typedef void (*GDBusSharedThreadFunc) (gpointer user_data);
 254
 255 typedef struct
 256 {
 257   GDBusSharedThreadFunc func;
 258   gpointer              user_data;
 259   gboolean              done;
 260 } CallerData;
 261
 262 static gboolean
 263 invoke_caller (gpointer user_data)
 264 {
 265   CallerData *data = user_data;
 266   data->func (data->user_data);
 267   data->done = TRUE;
 268   return FALSE;
 269 }
 270
 271 static void
 272 _g_dbus_shared_thread_ref (GDBusSharedThreadFunc func,
 273                            gpointer              user_data)
 274 {
 275   GError *error;
 276   GSource *idle_source;
 277   CallerData *data;
 278
 279   G_LOCK (shared_thread_lock);
 280
 281   if (shared_thread_data != NULL)
 282     {
 283       shared_thread_data->num_users += 1;
 284       goto have_thread;
 285     }
 286
 287   shared_thread_data = g_new0 (SharedThreadData, 1);
 288   shared_thread_data->num_users = 1;
 289
 290   error = NULL;
 291   shared_thread_data->context = g_main_context_new ();
 292   shared_thread_data->loop = g_main_loop_new (shared_thread_data->context, FALSE);
 293   shared_thread_data->thread = g_thread_create (shared_thread_func,
 294                                                 NULL,
 295                                                 TRUE,
 296                                                 &error);
 297   g_assert_no_error (error);
 298
 299  have_thread:
 300
 301   data = g_new0 (CallerData, 1);
 302   data->func = func;
 303   data->user_data = user_data;
 304   data->done = FALSE;
 305
 306   idle_source = g_idle_source_new ();
 307   g_source_set_priority (idle_source, G_PRIORITY_DEFAULT);
 308   g_source_set_callback (idle_source,
 309                          invoke_caller,
 310                          data,
 311                          NULL);
 312   g_source_attach (idle_source, shared_thread_data->context);
 313   g_source_unref (idle_source);
 314
 315   /* wait for the user code to run.. hmm.. probably use a condition variable instead */
 316   while (!data->done)
 317     g_thread_yield ();
 318
 319   g_free (data);
 320
 321   G_UNLOCK (shared_thread_lock);
 322 }
 323
 324 static void
 325 _g_dbus_shared_thread_unref (void)
 326 {
 327   /* TODO: actually destroy the shared thread here */
 328 #if 0
 329   G_LOCK (shared_thread_lock);
 330   g_assert (shared_thread_data != NULL);
 331   shared_thread_data->num_users -= 1;
 332   if (shared_thread_data->num_users == 0)
 333     {
 334       g_main_loop_quit (shared_thread_data->loop);
 335       //g_thread_join (shared_thread_data->thread);
 336       g_main_loop_unref (shared_thread_data->loop);
 337       g_main_context_unref (shared_thread_data->context);
 338       g_free (shared_thread_data);
 339       shared_thread_data = NULL;
 340       G_UNLOCK (shared_thread_lock);
 341     }
 342   else
 343     {
 344       G_UNLOCK (shared_thread_lock);
 345     }
 346 #endif
 347 }
 348
 349 /* ---------------------------------------------------------------------------------------------------- */
 350
 351 struct GDBusWorker
 352 {
 353   volatile gint                       ref_count;
 354
 355   gboolean                            stopped;
 356
 357   /* TODO: frozen (e.g. G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING) currently
 358    * only affects messages received from the other peer (since GDBusServer is the
 359    * only user) - we might want it to affect messages sent to the other peer too?
 360    */
 361   gboolean                            frozen;
 362   GQueue                             *received_messages_while_frozen;
 363
 364   GIOStream                          *stream;
 365   GDBusCapabilityFlags                capabilities;
 366   GCancellable                       *cancellable;
 367   GDBusWorkerMessageReceivedCallback  message_received_callback;
 368   GDBusWorkerMessageAboutToBeSentCallback message_about_to_be_sent_callback;
 369   GDBusWorkerDisconnectedCallback     disconnected_callback;
 370   gpointer                            user_data;
 371
 372   GThread                            *thread;
 373
 374   /* if not NULL, stream is GSocketConnection */
 375   GSocket *socket;
 376
 377   /* used for reading */
 378   GMutex                             *read_lock;
 379   gchar                              *read_buffer;
 380   gsize                               read_buffer_allocated_size;
 381   gsize                               read_buffer_cur_size;
 382   gsize                               read_buffer_bytes_wanted;
 383   GUnixFDList                        *read_fd_list;
 384   GSocketControlMessage             **read_ancillary_messages;
 385   gint                                read_num_ancillary_messages;
 386
 387   /* used for writing */
 388   GMutex                             *write_lock;
 389   GQueue                             *write_queue;
 390   gboolean                            write_is_pending;
 391 };
 392
 393 struct _MessageToWriteData ;
 394 typedef struct _MessageToWriteData MessageToWriteData;
 395
 396 static void message_to_write_data_free (MessageToWriteData *data);
 397
 398 static GDBusWorker *
 399 _g_dbus_worker_ref (GDBusWorker *worker)
 400 {
 401   g_atomic_int_inc (&worker->ref_count);
 402   return worker;
 403 }
 404
 405 static void
 406 _g_dbus_worker_unref (GDBusWorker *worker)
 407 {
 408   if (g_atomic_int_dec_and_test (&worker->ref_count))
 409     {
 410       _g_dbus_shared_thread_unref ();
 411
 412       g_object_unref (worker->stream);
 413
 414       g_mutex_free (worker->read_lock);
 415       g_object_unref (worker->cancellable);
 416       if (worker->read_fd_list != NULL)
 417         g_object_unref (worker->read_fd_list);
 418
 419       g_queue_foreach (worker->received_messages_while_frozen, (GFunc) g_object_unref, NULL);
 420       g_queue_free (worker->received_messages_while_frozen);
 421
 422       g_mutex_free (worker->write_lock);
 423       g_queue_foreach (worker->write_queue, (GFunc) message_to_write_data_free, NULL);
 424       g_queue_free (worker->write_queue);
 425
 426       g_free (worker);
 427     }
 428 }
 429
 430 static void
 431 _g_dbus_worker_emit_disconnected (GDBusWorker  *worker,
 432                                   gboolean      remote_peer_vanished,
 433                                   GError       *error)
 434 {
 435   if (!worker->stopped)
 436     worker->disconnected_callback (worker, remote_peer_vanished, error, worker->user_data);
 437 }
 438
 439 static void
 440 _g_dbus_worker_emit_message_received (GDBusWorker  *worker,
 441                                       GDBusMessage *message)
 442 {
 443   if (!worker->stopped)
 444     worker->message_received_callback (worker, message, worker->user_data);
 445 }
 446
 447 static gboolean
 448 _g_dbus_worker_emit_message_about_to_be_sent (GDBusWorker  *worker,
 449                                               GDBusMessage *message)
 450 {
 451   gboolean ret;
 452   ret = FALSE;
 453   if (!worker->stopped)
 454     ret = worker->message_about_to_be_sent_callback (worker, message, worker->user_data);
 455   return ret;
 456 }
 457
 458 /* can only be called from private thread with read-lock held - takes ownership of @message */
 459 static void
 460 _g_dbus_worker_queue_or_deliver_received_message (GDBusWorker  *worker,
 461                                                   GDBusMessage *message)
 462 {
 463   if (worker->frozen || g_queue_get_length (worker->received_messages_while_frozen) > 0)
 464     {
 465       /* queue up */
 466       g_queue_push_tail (worker->received_messages_while_frozen, message);
 467     }
 468   else
 469     {
 470       /* not frozen, nor anything in queue */
 471       _g_dbus_worker_emit_message_received (worker, message);
 472       g_object_unref (message);
 473     }
 474 }
 475
 476 /* called in private thread shared by all GDBusConnection instances (without read-lock held) */
 477 static gboolean
 478 unfreeze_in_idle_cb (gpointer user_data)
 479 {
 480   GDBusWorker *worker = user_data;
 481   GDBusMessage *message;
 482
 483   g_mutex_lock (worker->read_lock);
 484   if (worker->frozen)
 485     {
 486       while ((message = g_queue_pop_head (worker->received_messages_while_frozen)) != NULL)
 487         {
 488           _g_dbus_worker_emit_message_received (worker, message);
 489           g_object_unref (message);
 490         }
 491       worker->frozen = FALSE;
 492     }
 493   else
 494     {
 495       g_assert (g_queue_get_length (worker->received_messages_while_frozen) == 0);
 496     }
 497   g_mutex_unlock (worker->read_lock);
 498   return FALSE;
 499 }
 500
 501 /* can be called from any thread */
 502 void
 503 _g_dbus_worker_unfreeze (GDBusWorker *worker)
 504 {
 505   GSource *idle_source;
 506   idle_source = g_idle_source_new ();
 507   g_source_set_priority (idle_source, G_PRIORITY_DEFAULT);
 508   g_source_set_callback (idle_source,
 509                          unfreeze_in_idle_cb,
 510                          _g_dbus_worker_ref (worker),
 511                          (GDestroyNotify) _g_dbus_worker_unref);
 512   g_source_attach (idle_source, shared_thread_data->context);
 513   g_source_unref (idle_source);
 514 }
 515
 516 /* ---------------------------------------------------------------------------------------------------- */
 517
 518 static void _g_dbus_worker_do_read_unlocked (GDBusWorker *worker);
 519
 520 /* called in private thread shared by all GDBusConnection instances (without read-lock held) */
 521 static void
 522 _g_dbus_worker_do_read_cb (GInputStream  *input_stream,
 523                            GAsyncResult  *res,
 524                            gpointer       user_data)
 525 {
 526   GDBusWorker *worker = user_data;
 527   GError *error;
 528   gssize bytes_read;
 529
 530   g_mutex_lock (worker->read_lock);
 531
 532   /* If already stopped, don't even process the reply */
 533   if (worker->stopped)
 534     goto out;
 535
 536   error = NULL;
 537   if (worker->socket == NULL)
 538     bytes_read = g_input_stream_read_finish (g_io_stream_get_input_stream (worker->stream),
 539                                              res,
 540                                              &error);
 541   else
 542     bytes_read = _g_socket_read_with_control_messages_finish (worker->socket,
 543                                                               res,
 544                                                               &error);
 545   if (worker->read_num_ancillary_messages > 0)
 546     {
 547       gint n;
 548       for (n = 0; n < worker->read_num_ancillary_messages; n++)
 549         {
 550           GSocketControlMessage *control_message = G_SOCKET_CONTROL_MESSAGE (worker->read_ancillary_messages[n]);
 551
 552           if (FALSE)
 553             {
 554             }
 555 #ifdef G_OS_UNIX
 556           else if (G_IS_UNIX_FD_MESSAGE (control_message))
 557             {
 558               GUnixFDMessage *fd_message;
 559               gint *fds;
 560               gint num_fds;
 561
 562               fd_message = G_UNIX_FD_MESSAGE (control_message);
 563               fds = g_unix_fd_message_steal_fds (fd_message, &num_fds);
 564               if (worker->read_fd_list == NULL)
 565                 {
 566                   worker->read_fd_list = g_unix_fd_list_new_from_array (fds, num_fds);
 567                 }
 568               else
 569                 {
 570                   gint n;
 571                   for (n = 0; n < num_fds; n++)
 572                     {
 573                       /* TODO: really want a append_steal() */
 574                       g_unix_fd_list_append (worker->read_fd_list, fds[n], NULL);
 575                       close (fds[n]);
 576                     }
 577                 }
 578               g_free (fds);
 579             }
 580           else if (G_IS_UNIX_CREDENTIALS_MESSAGE (control_message))
 581             {
 582               /* do nothing */
 583             }
 584 #endif
 585           else
 586             {
 587               if (error == NULL)
 588                 {
 589                   g_set_error (&error,
 590                                G_IO_ERROR,
 591                                G_IO_ERROR_FAILED,
 592                                "Unexpected ancillary message of type %s received from peer",
 593                                g_type_name (G_TYPE_FROM_INSTANCE (control_message)));
 594                   _g_dbus_worker_emit_disconnected (worker, TRUE, error);
 595                   g_error_free (error);
 596                   g_object_unref (control_message);
 597                   n++;
 598                   while (n < worker->read_num_ancillary_messages)
 599                     g_object_unref (worker->read_ancillary_messages[n++]);
 600                   g_free (worker->read_ancillary_messages);
 601                   goto out;
 602                 }
 603             }
 604           g_object_unref (control_message);
 605         }
 606       g_free (worker->read_ancillary_messages);
 607     }
 608
 609   if (bytes_read == -1)
 610     {
 611       _g_dbus_worker_emit_disconnected (worker, TRUE, error);
 612       g_error_free (error);
 613       goto out;
 614     }
 615
 616 #if 0
 617   g_debug ("read %d bytes (is_closed=%d blocking=%d condition=0x%02x) stream %p, %p",
 618            (gint) bytes_read,
 619            g_socket_is_closed (g_socket_connection_get_socket (G_SOCKET_CONNECTION (worker->stream))),
 620            g_socket_get_blocking (g_socket_connection_get_socket (G_SOCKET_CONNECTION (worker->stream))),
 621            g_socket_condition_check (g_socket_connection_get_socket (G_SOCKET_CONNECTION (worker->stream)),
 622                                      G_IO_IN | G_IO_OUT | G_IO_HUP),
 623            worker->stream,
 624            worker);
 625 #endif
 626
 627   /* TODO: hmm, hmm... */
 628   if (bytes_read == 0)
 629     {
 630       g_set_error (&error,
 631                    G_IO_ERROR,
 632                    G_IO_ERROR_FAILED,
 633                    "Underlying GIOStream returned 0 bytes on an async read");
 634       _g_dbus_worker_emit_disconnected (worker, TRUE, error);
 635       g_error_free (error);
 636       goto out;
 637     }
 638
 639   worker->read_buffer_cur_size += bytes_read;
 640   if (worker->read_buffer_bytes_wanted == worker->read_buffer_cur_size)
 641     {
 642       /* OK, got what we asked for! */
 643       if (worker->read_buffer_bytes_wanted == 16)
 644         {
 645           gssize message_len;
 646           /* OK, got the header - determine how many more bytes are needed */
 647           error = NULL;
 648           message_len = g_dbus_message_bytes_needed ((guchar *) worker->read_buffer,
 649                                                      16,
 650                                                      &error);
 651           if (message_len == -1)
 652             {
 653               g_warning ("_g_dbus_worker_do_read_cb: error determing bytes needed: %s", error->message);
 654               _g_dbus_worker_emit_disconnected (worker, FALSE, error);
 655               g_error_free (error);
 656               goto out;
 657             }
 658
 659           worker->read_buffer_bytes_wanted = message_len;
 660           _g_dbus_worker_do_read_unlocked (worker);
 661         }
 662       else
 663         {
 664           GDBusMessage *message;
 665           error = NULL;
 666
 667           /* TODO: use connection->priv->auth to decode the message */
 668
 669           message = g_dbus_message_new_from_blob ((guchar *) worker->read_buffer,
 670                                                   worker->read_buffer_cur_size,
 671                                                   worker->capabilities,
 672                                                   &error);
 673           if (message == NULL)
 674             {
 675               gchar *s;
 676               s = _g_dbus_hexdump (worker->read_buffer, worker->read_buffer_cur_size, 2);
 677               g_warning ("Error decoding D-Bus message of %" G_GSIZE_FORMAT " bytes\n"
 678                          "The error is: %s\n"
 679                          "The payload is as follows:\n"
 680                          "%s\n",
 681                          worker->read_buffer_cur_size,
 682                          error->message,
 683                          s);
 684               g_free (s);
 685               _g_dbus_worker_emit_disconnected (worker, FALSE, error);
 686               g_error_free (error);
 687               goto out;
 688             }
 689
 690 #ifdef G_OS_UNIX
 691           if (worker->read_fd_list != NULL)
 692             {
 693               g_dbus_message_set_unix_fd_list (message, worker->read_fd_list);
 694               worker->read_fd_list = NULL;
 695             }
 696 #endif
 697
 698           if (G_UNLIKELY (_g_dbus_debug_message ()))
 699             {
 700               gchar *s;
 701               _g_dbus_debug_print_lock ();
 702               g_print ("========================================================================\n"
 703                        "GDBus-debug:Message:\n"
 704                        "  <<<< RECEIVED D-Bus message (%" G_GSIZE_FORMAT " bytes)\n",
 705                        worker->read_buffer_cur_size);
 706               s = g_dbus_message_print (message, 2);
 707               g_print ("%s", s);
 708               g_free (s);
 709               if (G_UNLIKELY (_g_dbus_debug_payload ()))
 710                 {
 711                   s = _g_dbus_hexdump (worker->read_buffer, worker->read_buffer_cur_size, 2);
 712                   g_print ("%s\n", s);
 713                   g_free (s);
 714                 }
 715               _g_dbus_debug_print_unlock ();
 716             }
 717
 718           /* yay, got a message, go deliver it */
 719           _g_dbus_worker_queue_or_deliver_received_message (worker, message);
 720
 721           /* start reading another message! */
 722           worker->read_buffer_bytes_wanted = 0;
 723           worker->read_buffer_cur_size = 0;
 724           _g_dbus_worker_do_read_unlocked (worker);
 725         }
 726     }
 727   else
 728     {
 729       /* didn't get all the bytes we requested - so repeat the request... */
 730       _g_dbus_worker_do_read_unlocked (worker);
 731     }
 732
 733  out:
 734   g_mutex_unlock (worker->read_lock);
 735
 736   /* gives up the reference acquired when calling g_input_stream_read_async() */
 737   _g_dbus_worker_unref (worker);
 738 }
 739
 740 /* called in private thread shared by all GDBusConnection instances (with read-lock held) */
 741 static void
 742 _g_dbus_worker_do_read_unlocked (GDBusWorker *worker)
 743 {
 744   /* if bytes_wanted is zero, it means start reading a message */
 745   if (worker->read_buffer_bytes_wanted == 0)
 746     {
 747       worker->read_buffer_cur_size = 0;
 748       worker->read_buffer_bytes_wanted = 16;
 749     }
 750
 751   /* ensure we have a (big enough) buffer */
 752   if (worker->read_buffer == NULL || worker->read_buffer_bytes_wanted > worker->read_buffer_allocated_size)
 753     {
 754       /* TODO: 4096 is randomly chosen; might want a better chosen default minimum */
 755       worker->read_buffer_allocated_size = MAX (worker->read_buffer_bytes_wanted, 4096);
 756       worker->read_buffer = g_realloc (worker->read_buffer, worker->read_buffer_allocated_size);
 757     }
 758
 759   if (worker->socket == NULL)
 760     g_input_stream_read_async (g_io_stream_get_input_stream (worker->stream),
 761                                worker->read_buffer + worker->read_buffer_cur_size,
 762                                worker->read_buffer_bytes_wanted - worker->read_buffer_cur_size,
 763                                G_PRIORITY_DEFAULT,
 764                                worker->cancellable,
 765                                (GAsyncReadyCallback) _g_dbus_worker_do_read_cb,
 766                                _g_dbus_worker_ref (worker));
 767   else
 768     {
 769       worker->read_ancillary_messages = NULL;
 770       worker->read_num_ancillary_messages = 0;
 771       _g_socket_read_with_control_messages (worker->socket,
 772                                             worker->read_buffer + worker->read_buffer_cur_size,
 773                                             worker->read_buffer_bytes_wanted - worker->read_buffer_cur_size,
 774                                             &worker->read_ancillary_messages,
 775                                             &worker->read_num_ancillary_messages,
 776                                             G_PRIORITY_DEFAULT,
 777                                             worker->cancellable,
 778                                             (GAsyncReadyCallback) _g_dbus_worker_do_read_cb,
 779                                             _g_dbus_worker_ref (worker));
 780     }
 781 }
 782
 783 /* called in private thread shared by all GDBusConnection instances (without read-lock held) */
 784 static void
 785 _g_dbus_worker_do_read (GDBusWorker *worker)
 786 {
 787   g_mutex_lock (worker->read_lock);
 788   _g_dbus_worker_do_read_unlocked (worker);
 789   g_mutex_unlock (worker->read_lock);
 790 }
 791
 792 /* ---------------------------------------------------------------------------------------------------- */
 793
 794 struct _MessageToWriteData
 795 {
 796   GDBusMessage *message;
 797   gchar        *blob;
 798   gsize         blob_size;
 799 };
 800
 801 static void
 802 message_to_write_data_free (MessageToWriteData *data)
 803 {
 804   g_object_unref (data->message);
 805   g_free (data->blob);
 806   g_free (data);
 807 }
 808
 809 /* ---------------------------------------------------------------------------------------------------- */
 810
 811 /* called in private thread shared by all GDBusConnection instances (without write-lock held) */
 812 static gboolean
 813 write_message (GDBusWorker         *worker,
 814                MessageToWriteData  *data,
 815                GError             **error)
 816 {
 817   gboolean ret;
 818
 819   g_return_val_if_fail (data->blob_size > 16, FALSE);
 820
 821   ret = FALSE;
 822
 823   /* First, the initial 16 bytes - special case UNIX sockets here
 824    * since it may involve writing an ancillary message with file
 825    * descriptors
 826    */
 827 #ifdef G_OS_UNIX
 828   {
 829     GOutputVector vector;
 830     GSocketControlMessage *message;
 831     GUnixFDList *fd_list;
 832     gssize bytes_written;
 833
 834     fd_list = g_dbus_message_get_unix_fd_list (data->message);
 835
 836     message = NULL;
 837     if (fd_list != NULL)
 838       {
 839         if (!G_IS_UNIX_CONNECTION (worker->stream))
 840           {
 841             g_set_error (error,
 842                          G_IO_ERROR,
 843                          G_IO_ERROR_INVALID_ARGUMENT,
 844                          "Tried sending a file descriptor on unsupported stream of type %s",
 845                          g_type_name (G_TYPE_FROM_INSTANCE (worker->stream)));
 846             goto out;
 847           }
 848         else if (!(worker->capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING))
 849           {
 850             g_set_error_literal (error,
 851                                  G_IO_ERROR,
 852                                  G_IO_ERROR_INVALID_ARGUMENT,
 853                                  "Tried sending a file descriptor but remote peer does not support this capability");
 854             goto out;
 855           }
 856         message = g_unix_fd_message_new_with_fd_list (fd_list);
 857       }
 858
 859     vector.buffer = data->blob;
 860     vector.size = 16;
 861
 862     bytes_written = g_socket_send_message (worker->socket,
 863                                            NULL, /* address */
 864                                            &vector,
 865                                            1,
 866                                            message != NULL ? &message : NULL,
 867                                            message != NULL ? 1 : 0,
 868                                            G_SOCKET_MSG_NONE,
 869                                            worker->cancellable,
 870                                            error);
 871     if (bytes_written == -1)
 872       {
 873         g_prefix_error (error, _("Error writing first 16 bytes of message to socket: "));
 874         if (message != NULL)
 875           g_object_unref (message);
 876         goto out;
 877       }
 878     if (message != NULL)
 879       g_object_unref (message);
 880
 881     if (bytes_written < 16)
 882       {
 883         /* TODO: I think this needs to be handled ... are we guaranteed that the ancillary
 884          * messages are sent?
 885          */
 886         g_assert_not_reached ();
 887       }
 888   }
 889 #else
 890   /* write the first 16 bytes (guaranteed to return an error if everything can't be written) */
 891   if (!g_output_stream_write_all (g_io_stream_get_output_stream (worker->stream),
 892                                   (const gchar *) data->blob,
 893                                   16,
 894                                   NULL, /* bytes_written */
 895                                   worker->cancellable, /* cancellable */
 896                                   error))
 897     goto out;
 898 #endif
 899
 900   /* Then write the rest of the message (guaranteed to return an error if everything can't be written) */
 901   if (!g_output_stream_write_all (g_io_stream_get_output_stream (worker->stream),
 902                                   (const gchar *) data->blob + 16,
 903                                   data->blob_size - 16,
 904                                   NULL, /* bytes_written */
 905                                   worker->cancellable, /* cancellable */
 906                                   error))
 907     goto out;
 908
 909   ret = TRUE;
 910
 911   if (G_UNLIKELY (_g_dbus_debug_message ()))
 912     {
 913       gchar *s;
 914       _g_dbus_debug_print_lock ();
 915       g_print ("========================================================================\n"
 916                "GDBus-debug:Message:\n"
 917                "  >>>> SENT D-Bus message (%" G_GSIZE_FORMAT " bytes)\n",
 918                data->blob_size);
 919       s = g_dbus_message_print (data->message, 2);
 920       g_print ("%s", s);
 921       g_free (s);
 922       if (G_UNLIKELY (_g_dbus_debug_payload ()))
 923         {
 924           s = _g_dbus_hexdump (data->blob, data->blob_size, 2);
 925           g_print ("%s\n", s);
 926           g_free (s);
 927         }
 928       _g_dbus_debug_print_unlock ();
 929     }
 930
 931  out:
 932   return ret;
 933 }
 934
 935 /* ---------------------------------------------------------------------------------------------------- */
 936
 937 /* called in private thread shared by all GDBusConnection instances (without write-lock held) */
 938 static gboolean
 939 write_message_in_idle_cb (gpointer user_data)
 940 {
 941   GDBusWorker *worker = user_data;
 942   gboolean more_writes_are_pending;
 943   MessageToWriteData *data;
 944   gboolean message_was_dropped;
 945   GError *error;
 946
 947   g_mutex_lock (worker->write_lock);
 948   data = g_queue_pop_head (worker->write_queue);
 949   g_assert (data != NULL);
 950   more_writes_are_pending = (g_queue_get_length (worker->write_queue) > 0);
 951   worker->write_is_pending = more_writes_are_pending;
 952   g_mutex_unlock (worker->write_lock);
 953
 954   /* Note that write_lock is only used for protecting the @write_queue
 955    * and @write_is_pending fields of the GDBusWorker struct ... which we
 956    * need to modify from arbitrary threads in _g_dbus_worker_send_message().
 957    *
 958    * Therefore, it's fine to drop it here when calling back into user
 959    * code and then writing the message out onto the GIOStream since this
 960    * function only runs on the worker thread.
 961    */
 962   message_was_dropped = _g_dbus_worker_emit_message_about_to_be_sent (worker, data->message);
 963   if (G_LIKELY (!message_was_dropped))
 964     {
 965       error = NULL;
 966       if (!write_message (worker,
 967                           data,
 968                           &error))
 969         {
 970           /* TODO: handle */
 971           _g_dbus_worker_emit_disconnected (worker, TRUE, error);
 972           g_error_free (error);
 973         }
 974     }
 975   message_to_write_data_free (data);
 976
 977   return more_writes_are_pending;
 978 }
 979
 980 /* ---------------------------------------------------------------------------------------------------- */
 981
 982 /* can be called from any thread - steals blob */
 983 void
 984 _g_dbus_worker_send_message (GDBusWorker    *worker,
 985                              GDBusMessage   *message,
 986                              gchar          *blob,
 987                              gsize           blob_len)
 988 {
 989   MessageToWriteData *data;
 990
 991   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 992   g_return_if_fail (blob != NULL);
 993   g_return_if_fail (blob_len > 16);
 994
 995   data = g_new0 (MessageToWriteData, 1);
 996   data->message = g_object_ref (message);
 997   data->blob = blob; /* steal! */
 998   data->blob_size = blob_len;
 999
1000   g_mutex_lock (worker->write_lock);
1001   g_queue_push_tail (worker->write_queue, data);
1002   if (!worker->write_is_pending)
1003     {
1004       GSource *idle_source;
1005
1006       worker->write_is_pending = TRUE;
1007
1008       idle_source = g_idle_source_new ();
1009       g_source_set_priority (idle_source, G_PRIORITY_DEFAULT);
1010       g_source_set_callback (idle_source,
1011                              write_message_in_idle_cb,
1012                              _g_dbus_worker_ref (worker),
1013                              (GDestroyNotify) _g_dbus_worker_unref);
1014       g_source_attach (idle_source, shared_thread_data->context);
1015       g_source_unref (idle_source);
1016     }
1017   g_mutex_unlock (worker->write_lock);
1018 }
1019
1020 /* ---------------------------------------------------------------------------------------------------- */
1021
1022 static void
1023 _g_dbus_worker_thread_begin_func (gpointer user_data)
1024 {
1025   GDBusWorker *worker = user_data;
1026
1027   worker->thread = g_thread_self ();
1028
1029   /* begin reading */
1030   _g_dbus_worker_do_read (worker);
1031 }
1032
1033 GDBusWorker *
1034 _g_dbus_worker_new (GIOStream                              *stream,
1035                     GDBusCapabilityFlags                    capabilities,
1036                     gboolean                                initially_frozen,
1037                     GDBusWorkerMessageReceivedCallback      message_received_callback,
1038                     GDBusWorkerMessageAboutToBeSentCallback message_about_to_be_sent_callback,
1039                     GDBusWorkerDisconnectedCallback         disconnected_callback,
1040                     gpointer                                user_data)
1041 {
1042   GDBusWorker *worker;
1043
1044   g_return_val_if_fail (G_IS_IO_STREAM (stream), NULL);
1045   g_return_val_if_fail (message_received_callback != NULL, NULL);
1046   g_return_val_if_fail (message_about_to_be_sent_callback != NULL, NULL);
1047   g_return_val_if_fail (disconnected_callback != NULL, NULL);
1048
1049   worker = g_new0 (GDBusWorker, 1);
1050   worker->ref_count = 1;
1051
1052   worker->read_lock = g_mutex_new ();
1053   worker->message_received_callback = message_received_callback;
1054   worker->message_about_to_be_sent_callback = message_about_to_be_sent_callback;
1055   worker->disconnected_callback = disconnected_callback;
1056   worker->user_data = user_data;
1057   worker->stream = g_object_ref (stream);
1058   worker->capabilities = capabilities;
1059   worker->cancellable = g_cancellable_new ();
1060
1061   worker->frozen = initially_frozen;
1062   worker->received_messages_while_frozen = g_queue_new ();
1063
1064   worker->write_lock = g_mutex_new ();
1065   worker->write_queue = g_queue_new ();
1066
1067   if (G_IS_SOCKET_CONNECTION (worker->stream))
1068     worker->socket = g_socket_connection_get_socket (G_SOCKET_CONNECTION (worker->stream));
1069
1070   _g_dbus_shared_thread_ref (_g_dbus_worker_thread_begin_func, worker);
1071
1072   return worker;
1073 }
1074
1075 /* This can be called from any thread - frees worker - guarantees no callbacks
1076  * will ever be issued again
1077  */
1078 void
1079 _g_dbus_worker_stop (GDBusWorker *worker)
1080 {
1081   /* If we're called in the worker thread it means we are called from
1082    * a worker callback. This is fine, we just can't lock in that case since
1083    * we're already holding the lock...
1084    */
1085   if (g_thread_self () != worker->thread)
1086     g_mutex_lock (worker->read_lock);
1087   worker->stopped = TRUE;
1088   if (g_thread_self () != worker->thread)
1089     g_mutex_unlock (worker->read_lock);
1090
1091   g_cancellable_cancel (worker->cancellable);
1092   _g_dbus_worker_unref (worker);
1093 }
1094
1095 #define G_DBUS_DEBUG_AUTHENTICATION (1<<0)
1096 #define G_DBUS_DEBUG_MESSAGE        (1<<1)
1097 #define G_DBUS_DEBUG_PAYLOAD        (1<<2)
1098 #define G_DBUS_DEBUG_CALL           (1<<3)
1099 #define G_DBUS_DEBUG_SIGNAL         (1<<4)
1100 #define G_DBUS_DEBUG_INCOMING       (1<<5)
1101 #define G_DBUS_DEBUG_EMISSION       (1<<6)
1102 #define G_DBUS_DEBUG_ADDRESS        (1<<7)
1103 #define G_DBUS_DEBUG_ALL            0xffffffff
1104 static gint _gdbus_debug_flags = 0;
1105
1106 gboolean
1107 _g_dbus_debug_authentication (void)
1108 {
1109   _g_dbus_initialize ();
1110   return (_gdbus_debug_flags & G_DBUS_DEBUG_AUTHENTICATION) != 0;
1111 }
1112
1113 gboolean
1114 _g_dbus_debug_message (void)
1115 {
1116   _g_dbus_initialize ();
1117   return (_gdbus_debug_flags & G_DBUS_DEBUG_MESSAGE) != 0;
1118 }
1119
1120 gboolean
1121 _g_dbus_debug_payload (void)
1122 {
1123   _g_dbus_initialize ();
1124   return (_gdbus_debug_flags & G_DBUS_DEBUG_PAYLOAD) != 0;
1125 }
1126
1127 gboolean
1128 _g_dbus_debug_call (void)
1129 {
1130   _g_dbus_initialize ();
1131   return (_gdbus_debug_flags & G_DBUS_DEBUG_CALL) != 0;
1132 }
1133
1134 gboolean
1135 _g_dbus_debug_signal (void)
1136 {
1137   _g_dbus_initialize ();
1138   return (_gdbus_debug_flags & G_DBUS_DEBUG_SIGNAL) != 0;
1139 }
1140
1141 gboolean
1142 _g_dbus_debug_incoming (void)
1143 {
1144   _g_dbus_initialize ();
1145   return (_gdbus_debug_flags & G_DBUS_DEBUG_INCOMING) != 0;
1146 }
1147
1148 gboolean
1149 _g_dbus_debug_emission (void)
1150 {
1151   _g_dbus_initialize ();
1152   return (_gdbus_debug_flags & G_DBUS_DEBUG_EMISSION) != 0;
1153 }
1154
1155 gboolean
1156 _g_dbus_debug_address (void)
1157 {
1158   _g_dbus_initialize ();
1159   return (_gdbus_debug_flags & G_DBUS_DEBUG_ADDRESS) != 0;
1160 }
1161
1162 G_LOCK_DEFINE_STATIC (print_lock);
1163
1164 void
1165 _g_dbus_debug_print_lock (void)
1166 {
1167   G_LOCK (print_lock);
1168 }
1169
1170 void
1171 _g_dbus_debug_print_unlock (void)
1172 {
1173   G_UNLOCK (print_lock);
1174 }
1175
1176 /*
1177  * _g_dbus_initialize:
1178  *
1179  * Does various one-time init things such as
1180  *
1181  *  - registering the G_DBUS_ERROR error domain
1182  *  - parses the G_DBUS_DEBUG environment variable
1183  */
1184 void
1185 _g_dbus_initialize (void)
1186 {
1187   static volatile gsize initialized = 0;
1188
1189   if (g_once_init_enter (&initialized))
1190     {
1191       volatile GQuark g_dbus_error_domain;
1192       const gchar *debug;
1193
1194       g_dbus_error_domain = G_DBUS_ERROR;
1195
1196       debug = g_getenv ("G_DBUS_DEBUG");
1197       if (debug != NULL)
1198         {
1199           gchar **tokens;
1200           guint n;
1201           tokens = g_strsplit (debug, ",", 0);
1202           for (n = 0; tokens[n] != NULL; n++)
1203             {
1204               if (g_strcmp0 (tokens[n], "authentication") == 0)
1205                 _gdbus_debug_flags |= G_DBUS_DEBUG_AUTHENTICATION;
1206               else if (g_strcmp0 (tokens[n], "message") == 0)
1207                 _gdbus_debug_flags |= G_DBUS_DEBUG_MESSAGE;
1208               else if (g_strcmp0 (tokens[n], "payload") == 0) /* implies `message' */
1209                 _gdbus_debug_flags |= (G_DBUS_DEBUG_MESSAGE | G_DBUS_DEBUG_PAYLOAD);
1210               else if (g_strcmp0 (tokens[n], "call") == 0)
1211                 _gdbus_debug_flags |= G_DBUS_DEBUG_CALL;
1212               else if (g_strcmp0 (tokens[n], "signal") == 0)
1213                 _gdbus_debug_flags |= G_DBUS_DEBUG_SIGNAL;
1214               else if (g_strcmp0 (tokens[n], "incoming") == 0)
1215                 _gdbus_debug_flags |= G_DBUS_DEBUG_INCOMING;
1216               else if (g_strcmp0 (tokens[n], "emission") == 0)
1217                 _gdbus_debug_flags |= G_DBUS_DEBUG_EMISSION;
1218               else if (g_strcmp0 (tokens[n], "address") == 0)
1219                 _gdbus_debug_flags |= G_DBUS_DEBUG_ADDRESS;
1220               else if (g_strcmp0 (tokens[n], "all") == 0)
1221                 _gdbus_debug_flags |= G_DBUS_DEBUG_ALL;
1222             }
1223           g_strfreev (tokens);
1224         }
1225
1226       g_once_init_leave (&initialized, 1);
1227     }
1228 }
1229
1230 /* ---------------------------------------------------------------------------------------------------- */
1231
1232 GVariantType *
1233 _g_dbus_compute_complete_signature (GDBusArgInfo **args)
1234 {
1235   const GVariantType *arg_types[256];
1236   guint n;
1237
1238   if (args)
1239     for (n = 0; args[n] != NULL; n++)
1240       {
1241         /* DBus places a hard limit of 255 on signature length.
1242          * therefore number of args must be less than 256.
1243          */
1244         g_assert (n < 256);
1245
1246         arg_types[n] = G_VARIANT_TYPE (args[n]->signature);
1247
1248         if G_UNLIKELY (arg_types[n] == NULL)
1249           return NULL;
1250       }
1251   else
1252     n = 0;
1253
1254   return g_variant_type_new_tuple (arg_types, n);
1255 }
1256
1257 /* ---------------------------------------------------------------------------------------------------- */
1258
1259 #ifdef G_OS_WIN32
1260
1261 extern BOOL WINAPI ConvertSidToStringSidA (PSID Sid, LPSTR *StringSid);
1262
1263 gchar *
1264 _g_dbus_win32_get_user_sid (void)
1265 {
1266   HANDLE h;
1267   TOKEN_USER *user;
1268   DWORD token_information_len;
1269   PSID psid;
1270   gchar *sid;
1271   gchar *ret;
1272
1273   ret = NULL;
1274   user = NULL;
1275   h = INVALID_HANDLE_VALUE;
1276
1277   if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &h))
1278     {
1279       g_warning ("OpenProcessToken failed with error code %d", (gint) GetLastError ());
1280       goto out;
1281     }
1282
1283   /* Get length of buffer */
1284   token_information_len = 0;
1285   if (!GetTokenInformation (h, TokenUser, NULL, 0, &token_information_len))
1286     {
1287       if (GetLastError () != ERROR_INSUFFICIENT_BUFFER)
1288         {
1289           g_warning ("GetTokenInformation() failed with error code %d", (gint) GetLastError ());
1290           goto out;
1291         }
1292     }
1293   user = g_malloc (token_information_len);
1294   if (!GetTokenInformation (h, TokenUser, user, token_information_len, &token_information_len))
1295     {
1296       g_warning ("GetTokenInformation() failed with error code %d", (gint) GetLastError ());
1297       goto out;
1298     }
1299
1300   psid = user->User.Sid;
1301   if (!IsValidSid (psid))
1302     {
1303       g_warning ("Invalid SID");
1304       goto out;
1305     }
1306
1307   if (!ConvertSidToStringSidA (psid, &sid))
1308     {
1309       g_warning ("Invalid SID");
1310       goto out;
1311     }
1312
1313   ret = g_strdup (sid);
1314   LocalFree (sid);
1315
1316 out:
1317   g_free (user);
1318   if (h != INVALID_HANDLE_VALUE)
1319     CloseHandle (h);
1320   return ret;
1321 }
1322 #endif
1323
1324 /* ---------------------------------------------------------------------------------------------------- */
1325
1326 gchar *
1327 _g_dbus_get_machine_id (GError **error)
1328 {
1329   gchar *ret;
1330   /* TODO: use PACKAGE_LOCALSTATEDIR ? */
1331   ret = NULL;
1332   if (!g_file_get_contents ("/var/lib/dbus/machine-id",
1333                             &ret,
1334                             NULL,
1335                             error))
1336     {
1337       g_prefix_error (error, _("Unable to load /var/lib/dbus/machine-id: "));
1338     }
1339   else
1340     {
1341       /* TODO: validate value */
1342       g_strstrip (ret);
1343     }
1344   return ret;
1345 }
1346
1347 /* ---------------------------------------------------------------------------------------------------- */
1348
1349 gchar *
1350 _g_dbus_enum_to_string (GType enum_type, gint value)
1351 {
1352   gchar *ret;
1353   GEnumClass *klass;
1354   GEnumValue *enum_value;
1355
1356   klass = g_type_class_ref (enum_type);
1357   enum_value = g_enum_get_value (klass, value);
1358   if (enum_value != NULL)
1359     ret = g_strdup (enum_value->value_nick);
1360   else
1361     ret = g_strdup_printf ("unknown (value %d)", value);
1362   g_type_class_unref (klass);
1363   return ret;
1364 }
1365
1366 /* ---------------------------------------------------------------------------------------------------- */
1367
1368 #define __G_DBUS_PRIVATE_C__
1369 #include "gioaliasdef.c"