gio/gdbusdaemon.c

   1 #include "config.h"
   2
   3 #include <string.h>
   4 #include <stdlib.h>
   5
   6 #include <gstdio.h>
   7 #include <gio/gio.h>
   8 #include <gio/gunixsocketaddress.h>
   9 #include "gdbusdaemon.h"
  10 #include "glibintl.h"
  11
  12 #include "gdbus-daemon-generated.h"
  13
  14 #define DBUS_SERVICE_NAME  "org.freedesktop.DBus"
  15
  16 /* Owner flags */
  17 #define DBUS_NAME_FLAG_ALLOW_REPLACEMENT 0x1 /**< Allow another service to become the primary owner if requested */
  18 #define DBUS_NAME_FLAG_REPLACE_EXISTING  0x2 /**< Request to replace the current primary owner */
  19 #define DBUS_NAME_FLAG_DO_NOT_QUEUE      0x4 /**< If we can not become the primary owner do not place us in the queue */
  20
  21 /* Replies to request for a name */
  22 #define DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER  1 /**< Service has become the primary owner of the requested name */
  23 #define DBUS_REQUEST_NAME_REPLY_IN_QUEUE       2 /**< Service could not become the primary owner and has been placed in the queue */
  24 #define DBUS_REQUEST_NAME_REPLY_EXISTS         3 /**< Service is already in the queue */
  25 #define DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER  4 /**< Service is already the primary owner */
  26
  27 /* Replies to releasing a name */
  28 #define DBUS_RELEASE_NAME_REPLY_RELEASED        1 /**< Service was released from the given name */
  29 #define DBUS_RELEASE_NAME_REPLY_NON_EXISTENT    2 /**< The given name does not exist on the bus */
  30 #define DBUS_RELEASE_NAME_REPLY_NOT_OWNER       3 /**< Service is not an owner of the given name */
  31
  32 /* Replies to service starts */
  33 #define DBUS_START_REPLY_SUCCESS         1 /**< Service was auto started */
  34 #define DBUS_START_REPLY_ALREADY_RUNNING 2 /**< Service was already running */
  35
  36 #define IDLE_TIMEOUT_MSEC 3000
  37
  38 struct _GDBusDaemon
  39 {
  40   _GFreedesktopDBusSkeleton parent_instance;
  41
  42   gchar *address;
  43   guint timeout;
  44   gchar *tmpdir;
  45   GDBusServer *server;
  46   gchar *guid;
  47   GHashTable *clients;
  48   GHashTable *names;
  49   guint32 next_major_id;
  50   guint32 next_minor_id;
  51 };
  52
  53 struct _GDBusDaemonClass
  54 {
  55   _GFreedesktopDBusSkeletonClass parent_class;
  56 };
  57
  58 enum {
  59   PROP_0,
  60   PROP_ADDRESS,
  61 };
  62
  63 enum
  64 {
  65   SIGNAL_IDLE_TIMEOUT,
  66   NR_SIGNALS
  67 };
  68
  69 static guint g_dbus_daemon_signals[NR_SIGNALS];
  70
  71
  72 static void initable_iface_init      (GInitableIface         *initable_iface);
  73 static void g_dbus_daemon_iface_init (_GFreedesktopDBusIface *iface);
  74
  75 #define g_dbus_daemon_get_type _g_dbus_daemon_get_type
  76 G_DEFINE_TYPE_WITH_CODE (GDBusDaemon, g_dbus_daemon, _G_TYPE_FREEDESKTOP_DBUS_SKELETON,
  77                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init)
  78                          G_IMPLEMENT_INTERFACE (_G_TYPE_FREEDESKTOP_DBUS, g_dbus_daemon_iface_init))
  79
  80 typedef struct {
  81   GDBusDaemon *daemon;
  82   char *id;
  83   GDBusConnection *connection;
  84   GList *matches;
  85 } Client;
  86
  87 typedef struct {
  88   Client *client;
  89   guint32 flags;
  90 } NameOwner;
  91
  92 typedef struct {
  93   int refcount;
  94
  95   char *name;
  96   GDBusDaemon *daemon;
  97
  98   NameOwner *owner;
  99   GList *queue;
 100 } Name;
 101
 102 enum {
 103   MATCH_ELEMENT_TYPE,
 104   MATCH_ELEMENT_SENDER,
 105   MATCH_ELEMENT_INTERFACE,
 106   MATCH_ELEMENT_MEMBER,
 107   MATCH_ELEMENT_PATH,
 108   MATCH_ELEMENT_PATH_NAMESPACE,
 109   MATCH_ELEMENT_DESTINATION,
 110   MATCH_ELEMENT_ARG0NAMESPACE,
 111   MATCH_ELEMENT_EAVESDROP,
 112   MATCH_ELEMENT_ARGN,
 113   MATCH_ELEMENT_ARGNPATH,
 114 };
 115
 116 typedef struct {
 117   guint16 type;
 118   guint16 arg;
 119   char *value;
 120 } MatchElement;
 121
 122 typedef struct {
 123   gboolean eavesdrop;
 124   GDBusMessageType type;
 125   int n_elements;
 126   MatchElement *elements;
 127 } Match;
 128
 129 static GDBusMessage *filter_function   (GDBusConnection *connection,
 130                                         GDBusMessage    *message,
 131                                         gboolean         incoming,
 132                                         gpointer         user_data);
 133 static void          connection_closed (GDBusConnection *connection,
 134                                         gboolean         remote_peer_vanished,
 135                                         GError          *error,
 136                                         Client          *client);
 137
 138 static NameOwner *
 139 name_owner_new (Client *client, guint32 flags)
 140 {
 141   NameOwner *owner;
 142
 143   owner = g_new0 (NameOwner, 1);
 144   owner->client = client;
 145   owner->flags = flags;
 146   return owner;
 147 }
 148
 149 static void
 150 name_owner_free (NameOwner *owner)
 151 {
 152   g_free (owner);
 153 }
 154
 155 static Name *
 156 name_new (GDBusDaemon *daemon, const char *str)
 157 {
 158   Name *name;
 159
 160   name = g_new0 (Name, 1);
 161   name->refcount = 1;
 162   name->daemon = daemon;
 163   name->name = g_strdup (str);
 164
 165   g_hash_table_insert (daemon->names, name->name, name);
 166
 167   return name;
 168 }
 169
 170 static Name *
 171 name_ref (Name *name)
 172 {
 173   name->refcount++;
 174   return name;
 175 }
 176
 177 static void
 178 name_unref (Name *name)
 179 {
 180   if (--name->refcount == 0)
 181     {
 182       g_hash_table_remove (name->daemon->names, name->name);
 183       g_free (name->name);
 184       g_free (name);
 185     }
 186 }
 187
 188 static Name *
 189 name_ensure (GDBusDaemon *daemon, const char *str)
 190 {
 191   Name *name;
 192
 193   name = g_hash_table_lookup (daemon->names, str);
 194
 195   if (name != NULL)
 196     return name_ref (name);
 197   return name_new (daemon, str);
 198 }
 199
 200 static Name *
 201 name_lookup (GDBusDaemon *daemon, const char *str)
 202 {
 203   return g_hash_table_lookup (daemon->names, str);
 204 }
 205
 206 static gboolean
 207 is_key (const char *key_start, const char *key_end, const char *value)
 208 {
 209   gsize len = strlen (value);
 210
 211   if (len != key_end - key_start)
 212     return FALSE;
 213
 214   return strncmp (key_start, value, len) == 0;
 215 }
 216
 217 static gboolean
 218 parse_key (MatchElement *element, const char *key_start, const char *key_end)
 219 {
 220   gboolean res = TRUE;
 221
 222   if (is_key (key_start, key_end, "type"))
 223     {
 224       element->type = MATCH_ELEMENT_TYPE;
 225     }
 226   else if (is_key (key_start, key_end, "sender"))
 227     {
 228       element->type = MATCH_ELEMENT_SENDER;
 229     }
 230   else if (is_key (key_start, key_end, "interface"))
 231     {
 232       element->type = MATCH_ELEMENT_INTERFACE;
 233     }
 234   else if (is_key (key_start, key_end, "member"))
 235     {
 236       element->type = MATCH_ELEMENT_MEMBER;
 237     }
 238   else if (is_key (key_start, key_end, "path"))
 239     {
 240       element->type = MATCH_ELEMENT_PATH;
 241     }
 242   else if (is_key (key_start, key_end, "path_namespace"))
 243     {
 244       element->type = MATCH_ELEMENT_PATH_NAMESPACE;
 245     }
 246   else if (is_key (key_start, key_end, "destination"))
 247     {
 248       element->type = MATCH_ELEMENT_DESTINATION;
 249     }
 250   else if (is_key (key_start, key_end, "arg0namespace"))
 251     {
 252       element->type = MATCH_ELEMENT_ARG0NAMESPACE;
 253     }
 254   else if (is_key (key_start, key_end, "eavesdrop"))
 255     {
 256       element->type = MATCH_ELEMENT_EAVESDROP;
 257     }
 258   else if (key_end - key_start > 3 && is_key (key_start, key_start + 3, "arg"))
 259     {
 260       const char *digits = key_start + 3;
 261       const char *end_digits = digits;
 262
 263       while (end_digits < key_end && g_ascii_isdigit (*end_digits))
 264         end_digits++;
 265
 266       if (end_digits == key_end) /* argN */
 267         {
 268           element->type = MATCH_ELEMENT_ARGN;
 269           element->arg = atoi (digits);
 270         }
 271       else if (is_key (end_digits, key_end, "path")) /* argNpath */
 272         {
 273           element->type = MATCH_ELEMENT_ARGNPATH;
 274           element->arg = atoi (digits);
 275         }
 276       else
 277         res = FALSE;
 278     }
 279   else
 280     res = FALSE;
 281
 282   return res;
 283 }
 284
 285 static const char *
 286 parse_value (MatchElement *element, const char *s)
 287 {
 288   char quote_char;
 289   GString *value;
 290
 291   value = g_string_new ("");
 292
 293   quote_char = 0;
 294
 295   for (;*s; s++)
 296     {
 297       if (quote_char == 0)
 298         {
 299           switch (*s)
 300             {
 301             case '\'':
 302               quote_char = '\'';
 303               break;
 304
 305             case ',':
 306               s++;
 307               goto out;
 308
 309             case '\\':
 310               quote_char = '\\';
 311               break;
 312
 313             default:
 314               g_string_append_c (value, *s);
 315               break;
 316             }
 317         }
 318       else if (quote_char == '\\')
 319         {
 320           /* \ only counts as an escape if escaping a quote mark */
 321           if (*s != '\'')
 322             g_string_append_c (value, '\\');
 323
 324           g_string_append_c (value, *s);
 325           quote_char = 0;
 326         }
 327       else /* quote_char == ' */
 328         {
 329           if (*s == '\'')
 330             quote_char = 0;
 331           else
 332             g_string_append_c (value, *s);
 333         }
 334     }
 335
 336  out:
 337
 338   if (quote_char == '\\')
 339     g_string_append_c (value, '\\');
 340   else if (quote_char == '\'')
 341     {
 342       g_string_free (value, TRUE);
 343       return NULL;
 344     }
 345
 346   element->value = g_string_free (value, FALSE);
 347   return s;
 348 }
 349
 350 static Match *
 351 match_new (const char *str)
 352 {
 353   Match *match;
 354   GArray *elements;
 355   const char *p;
 356   const char *key_start;
 357   const char *key_end;
 358   MatchElement element;
 359   gboolean eavesdrop;
 360   GDBusMessageType type;
 361   int i;
 362
 363   eavesdrop = FALSE;
 364   type = G_DBUS_MESSAGE_TYPE_INVALID;
 365   elements = g_array_new (TRUE, TRUE, sizeof (MatchElement));
 366
 367   p = str;
 368
 369   while (*p != 0)
 370     {
 371       memset (&element, 0, sizeof (element));
 372
 373       /* Skip initial whitespace */
 374       while (*p && g_ascii_isspace (*p))
 375         p++;
 376
 377       key_start = p;
 378
 379       /* Read non-whitespace non-equals chars */
 380       while (*p && *p != '=' && !g_ascii_isspace (*p))
 381         p++;
 382
 383       key_end = p;
 384
 385       /* Skip any whitespace after key */
 386       while (*p && g_ascii_isspace (*p))
 387         p++;
 388
 389       if (key_start == key_end)
 390         continue; /* Allow trailing whitespace */
 391
 392       if (*p != '=')
 393         goto error;
 394
 395       ++p;
 396
 397       if (!parse_key (&element, key_start, key_end))
 398         goto error;
 399
 400       p = parse_value (&element, p);
 401       if (p == NULL)
 402         goto error;
 403
 404       if (element.type == MATCH_ELEMENT_EAVESDROP)
 405         {
 406           if (strcmp (element.value, "true") == 0)
 407             eavesdrop = TRUE;
 408           else if (strcmp (element.value, "false") == 0)
 409             eavesdrop = FALSE;
 410           else
 411             {
 412               g_free (element.value);
 413               goto error;
 414             }
 415           g_free (element.value);
 416         }
 417       else if (element.type == MATCH_ELEMENT_TYPE)
 418         {
 419           if (strcmp (element.value, "signal") == 0)
 420             type = G_DBUS_MESSAGE_TYPE_SIGNAL;
 421           else if (strcmp (element.value, "method_call") == 0)
 422             type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
 423           else if (strcmp (element.value, "method_return") == 0)
 424             type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
 425           else if (strcmp (element.value, "error") == 0)
 426             type = G_DBUS_MESSAGE_TYPE_ERROR;
 427           else
 428             {
 429               g_free (element.value);
 430               goto error;
 431             }
 432           g_free (element.value);
 433         }
 434       else
 435         g_array_append_val (elements, element);
 436     }
 437
 438   match = g_new0 (Match, 1);
 439   match->n_elements = elements->len;
 440   match->elements = (MatchElement *)g_array_free (elements, FALSE);
 441   match->eavesdrop = eavesdrop;
 442   match->type = type;
 443
 444   return match;
 445
 446  error:
 447   for (i = 0; i < elements->len; i++)
 448     g_free (g_array_index (elements, MatchElement, i).value);
 449   g_array_free (elements, TRUE);
 450   return NULL;
 451 }
 452
 453 static void
 454 match_free (Match *match)
 455 {
 456   int i;
 457   for (i = 0; i < match->n_elements; i++)
 458     g_free (match->elements[i].value);
 459   g_free (match->elements);
 460   g_free (match);
 461 }
 462
 463 static gboolean
 464 match_equal (Match *a, Match *b)
 465 {
 466   int i;
 467
 468   if (a->eavesdrop != b->eavesdrop)
 469     return FALSE;
 470   if (a->type != b->type)
 471     return FALSE;
 472  if (a->n_elements != b->n_elements)
 473     return FALSE;
 474   for (i = 0; i < a->n_elements; i++)
 475     {
 476       if (a->elements[i].type != b->elements[i].type ||
 477           a->elements[i].arg != b->elements[i].arg ||
 478           strcmp (a->elements[i].value, b->elements[i].value) != 0)
 479         return FALSE;
 480     }
 481   return TRUE;
 482 }
 483
 484 static const gchar *
 485 message_get_argN (GDBusMessage *message, int n, gboolean allow_path)
 486 {
 487   const gchar *ret;
 488   GVariant *body;
 489
 490   ret = NULL;
 491
 492   body = g_dbus_message_get_body (message);
 493
 494   if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE))
 495     {
 496       GVariant *item;
 497       item = g_variant_get_child_value (body, n);
 498       if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING) ||
 499           (allow_path && g_variant_is_of_type (item, G_VARIANT_TYPE_OBJECT_PATH)))
 500         ret = g_variant_get_string (item, NULL);
 501       g_variant_unref (item);
 502     }
 503
 504   return ret;
 505 }
 506
 507 enum {
 508   CHECK_TYPE_STRING,
 509   CHECK_TYPE_NAME,
 510   CHECK_TYPE_PATH_PREFIX,
 511   CHECK_TYPE_PATH_RELATED,
 512   CHECK_TYPE_NAMESPACE_PREFIX
 513 };
 514
 515 static gboolean
 516 match_matches (GDBusDaemon *daemon,
 517                Match *match, GDBusMessage *message,
 518                gboolean has_destination)
 519 {
 520   MatchElement *element;
 521   Name *name;
 522   int i, len, len2;
 523   const char *value;
 524   int check_type;
 525
 526   if (has_destination && !match->eavesdrop)
 527     return FALSE;
 528
 529   if (match->type != G_DBUS_MESSAGE_TYPE_INVALID &&
 530       g_dbus_message_get_message_type (message) != match->type)
 531     return FALSE;
 532
 533   for (i = 0; i < match->n_elements; i++)
 534     {
 535       element = &match->elements[i];
 536       check_type = CHECK_TYPE_STRING;
 537       switch (element->type)
 538         {
 539         case MATCH_ELEMENT_SENDER:
 540           check_type = CHECK_TYPE_NAME;
 541           value = g_dbus_message_get_sender (message);
 542           if (value == NULL)
 543             value = DBUS_SERVICE_NAME;
 544           break;
 545         case MATCH_ELEMENT_DESTINATION:
 546           check_type = CHECK_TYPE_NAME;
 547           value = g_dbus_message_get_destination (message);
 548           break;
 549         case MATCH_ELEMENT_INTERFACE:
 550           value = g_dbus_message_get_interface (message);
 551           break;
 552         case MATCH_ELEMENT_MEMBER:
 553           value = g_dbus_message_get_member (message);
 554           break;
 555         case MATCH_ELEMENT_PATH:
 556           value = g_dbus_message_get_path (message);
 557           break;
 558         case MATCH_ELEMENT_PATH_NAMESPACE:
 559           check_type = CHECK_TYPE_PATH_PREFIX;
 560           value = g_dbus_message_get_path (message);
 561           break;
 562         case MATCH_ELEMENT_ARG0NAMESPACE:
 563           check_type = CHECK_TYPE_NAMESPACE_PREFIX;
 564           value = message_get_argN (message, 0, FALSE);
 565           break;
 566         case MATCH_ELEMENT_ARGN:
 567           value = message_get_argN (message, element->arg, FALSE);
 568           break;
 569         case MATCH_ELEMENT_ARGNPATH:
 570           check_type = CHECK_TYPE_PATH_RELATED;
 571           value = message_get_argN (message, element->arg, TRUE);
 572           break;
 573         default:
 574         case MATCH_ELEMENT_TYPE:
 575         case MATCH_ELEMENT_EAVESDROP:
 576           g_assert_not_reached ();
 577         }
 578
 579       if (value == NULL)
 580         return FALSE;
 581
 582       switch (check_type)
 583         {
 584         case CHECK_TYPE_STRING:
 585           if (strcmp (element->value, value) != 0)
 586             return FALSE;
 587           break;
 588         case CHECK_TYPE_NAME:
 589           name = name_lookup (daemon, element->value);
 590           if (name != NULL && name->owner != NULL)
 591             {
 592               if (strcmp (name->owner->client->id, value) != 0)
 593                 return FALSE;
 594             }
 595           else if (strcmp (element->value, value) != 0)
 596             return FALSE;
 597           break;
 598         case CHECK_TYPE_PATH_PREFIX:
 599           len = strlen (element->value);
 600
 601           /* Make sure to handle the case of element->value == '/'. */
 602           if (len == 1)
 603             break;
 604
 605           /* Fail if there's no prefix match, or if the prefix match doesn't
 606            * finish at the end of or at a separator in the @value. */
 607           if (!g_str_has_prefix (value, element->value))
 608             return FALSE;
 609           if (value[len] != 0 && value[len] != '/')
 610             return FALSE;
 611
 612           break;
 613         case CHECK_TYPE_PATH_RELATED:
 614           len = strlen (element->value);
 615           len2 = strlen (value);
 616
 617           if (!(strcmp (value, element->value) == 0 ||
 618                 (len2 > 0 && value[len2-1] == '/' && g_str_has_prefix (element->value, value)) ||
 619                 (len > 0 && element->value[len-1] == '/' && g_str_has_prefix (value, element->value))))
 620             return FALSE;
 621           break;
 622         case CHECK_TYPE_NAMESPACE_PREFIX:
 623           len = strlen (element->value);
 624           if (!(g_str_has_prefix (value, element->value) &&
 625                 (value[len] == 0 || value[len] == '.')))
 626             return FALSE;
 627           break;
 628         default:
 629           g_assert_not_reached ();
 630         }
 631     }
 632
 633   return TRUE;
 634 }
 635
 636 static void
 637 broadcast_message (GDBusDaemon *daemon,
 638                    GDBusMessage *message,
 639                    gboolean has_destination,
 640                    gboolean preserve_serial,
 641                    Client *not_to)
 642 {
 643   GList *clients, *l, *ll;
 644   GDBusMessage *copy;
 645
 646   clients = g_hash_table_get_values (daemon->clients);
 647   for (l = clients; l != NULL; l = l->next)
 648     {
 649       Client *client = l->data;
 650
 651       if (client == not_to)
 652         continue;
 653
 654       for (ll = client->matches; ll != NULL; ll = ll->next)
 655         {
 656           Match *match = ll->data;
 657
 658           if (match_matches (daemon, match, message, has_destination))
 659             break;
 660         }
 661
 662       if (ll != NULL)
 663         {
 664           copy = g_dbus_message_copy (message, NULL);
 665           if (copy)
 666             {
 667               g_dbus_connection_send_message (client->connection, copy,
 668                                               preserve_serial?G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL:0, NULL, NULL);
 669               g_object_unref (copy);
 670             }
 671         }
 672     }
 673
 674   g_list_free (clients);
 675 }
 676
 677 static void
 678 send_name_owner_changed (GDBusDaemon *daemon,
 679                          const char *name,
 680                          const char *old_owner,
 681                          const char *new_owner)
 682 {
 683   GDBusMessage *signal_message;
 684
 685   signal_message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
 686                                               "org.freedesktop.DBus",
 687                                               "NameOwnerChanged");
 688   g_dbus_message_set_body (signal_message,
 689                            g_variant_new ("(sss)",
 690                                           name,
 691                                           old_owner ? old_owner : "",
 692                                           new_owner ? new_owner : ""));
 693
 694   broadcast_message (daemon, signal_message, FALSE, FALSE, NULL);
 695   g_object_unref (signal_message);
 696
 697 }
 698
 699 static gboolean
 700 name_unqueue_owner (Name *name, Client *client)
 701 {
 702   GList *l;
 703
 704   for (l = name->queue; l != NULL; l = l->next)
 705     {
 706       NameOwner *other = l->data;
 707
 708       if (other->client == client)
 709         {
 710           name->queue = g_list_delete_link (name->queue, l);
 711           name_unref (name);
 712           name_owner_free (other);
 713           return TRUE;
 714         }
 715     }
 716
 717   return FALSE;
 718 }
 719
 720 static void
 721 name_replace_owner (Name *name, NameOwner *owner)
 722 {
 723   GDBusDaemon *daemon = name->daemon;
 724   NameOwner *old_owner;
 725   char *old_name = NULL, *new_name = NULL;
 726   Client *new_client = NULL;
 727
 728   if (owner)
 729     new_client = owner->client;
 730
 731   name_ref (name);
 732
 733   old_owner = name->owner;
 734   if (old_owner)
 735     {
 736       Client *old_client = old_owner->client;
 737
 738       g_assert (old_owner->client != new_client);
 739
 740       g_dbus_connection_emit_signal (old_client->connection,
 741                                      NULL, "/org/freedesktop/DBus",
 742                                      "org.freedesktop.DBus", "NameLost",
 743                                      g_variant_new ("(s)",
 744                                                     name->name), NULL);
 745
 746       old_name = g_strdup (old_client->id);
 747       if (old_owner->flags & DBUS_NAME_FLAG_DO_NOT_QUEUE)
 748         {
 749           name_unref (name);
 750           name_owner_free (old_owner);
 751         }
 752       else
 753         name->queue = g_list_prepend (name->queue, old_owner);
 754     }
 755
 756   name->owner = owner;
 757   if (owner)
 758     {
 759       name_unqueue_owner (name, owner->client);
 760       name_ref (name);
 761       new_name = new_client->id;
 762
 763       g_dbus_connection_emit_signal (new_client->connection,
 764                                      NULL, "/org/freedesktop/DBus",
 765                                      "org.freedesktop.DBus", "NameAcquired",
 766                                      g_variant_new ("(s)",
 767                                                     name->name), NULL);
 768     }
 769
 770   send_name_owner_changed (daemon, name->name, old_name, new_name);
 771
 772   g_free (old_name);
 773
 774   name_unref (name);
 775 }
 776
 777 static void
 778 name_release_owner (Name *name)
 779 {
 780   NameOwner *next_owner = NULL;
 781
 782   name_ref (name);
 783
 784   /* Will someone else take over? */
 785   if (name->queue)
 786     {
 787       next_owner = name->queue->data;
 788       name_unref (name);
 789       name->queue = g_list_delete_link (name->queue, name->queue);
 790     }
 791
 792   name->owner->flags |= DBUS_NAME_FLAG_DO_NOT_QUEUE;
 793   name_replace_owner (name, next_owner);
 794
 795   name_unref (name);
 796 }
 797
 798 static void
 799 name_queue_owner (Name *name, NameOwner *owner)
 800 {
 801   GList *l;
 802
 803   for (l = name->queue; l != NULL; l = l->next)
 804     {
 805       NameOwner *other = l->data;
 806
 807       if (other->client == owner->client)
 808         {
 809           other->flags = owner->flags;
 810           name_owner_free (owner);
 811           return;
 812         }
 813     }
 814
 815   name->queue = g_list_append (name->queue, owner);
 816   name_ref (name);
 817 }
 818
 819 static Client *
 820 client_new (GDBusDaemon *daemon, GDBusConnection *connection)
 821 {
 822   Client *client;
 823   GError *error = NULL;
 824
 825   client = g_new0 (Client, 1);
 826   client->daemon = daemon;
 827   client->id = g_strdup_printf (":%d.%d", daemon->next_major_id, daemon->next_minor_id);
 828   client->connection = g_object_ref (connection);
 829
 830   if (daemon->next_minor_id == G_MAXUINT32)
 831     {
 832       daemon->next_minor_id = 0;
 833       daemon->next_major_id++;
 834     }
 835   else
 836     daemon->next_minor_id++;
 837
 838   g_object_set_data (G_OBJECT (connection), "client", client);
 839   g_hash_table_insert (daemon->clients, client->id, client);
 840
 841   g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (daemon), connection,
 842                                     "/org/freedesktop/DBus", &error);
 843   g_assert_no_error (error);
 844
 845   g_signal_connect (connection, "closed", G_CALLBACK (connection_closed), client);
 846   g_dbus_connection_add_filter (connection,
 847                                 filter_function,
 848                                 client, NULL);
 849
 850   send_name_owner_changed (daemon, client->id, NULL, client->id);
 851
 852   return client;
 853 }
 854
 855 static void
 856 client_free (Client *client)
 857 {
 858   GDBusDaemon *daemon = client->daemon;
 859   GList *l, *names;
 860
 861   g_dbus_interface_skeleton_unexport_from_connection (G_DBUS_INTERFACE_SKELETON (daemon),
 862                                                       client->connection);
 863
 864   g_hash_table_remove (daemon->clients, client->id);
 865
 866   names = g_hash_table_get_values (daemon->names);
 867   for (l = names; l != NULL; l = l->next)
 868     {
 869       Name *name = l->data;
 870
 871       name_ref (name);
 872
 873       if (name->owner && name->owner->client == client)
 874         name_release_owner (name);
 875
 876       name_unqueue_owner (name, client);
 877
 878       name_unref (name);
 879     }
 880   g_list_free (names);
 881
 882   send_name_owner_changed (daemon, client->id, client->id, NULL);
 883
 884   g_object_unref (client->connection);
 885
 886   for (l = client->matches; l != NULL; l = l->next)
 887     match_free (l->data);
 888   g_list_free (client->matches);
 889
 890   g_free (client->id);
 891   g_free (client);
 892 }
 893
 894 static gboolean
 895 idle_timeout_cb (gpointer user_data)
 896 {
 897   GDBusDaemon *daemon = user_data;
 898
 899   daemon->timeout = 0;
 900
 901   g_signal_emit (daemon,
 902                  g_dbus_daemon_signals[SIGNAL_IDLE_TIMEOUT],
 903                  0);
 904
 905   return G_SOURCE_REMOVE;
 906 }
 907
 908 static void
 909 connection_closed (GDBusConnection *connection,
 910                    gboolean remote_peer_vanished,
 911                    GError *error,
 912                    Client *client)
 913 {
 914   GDBusDaemon *daemon = client->daemon;
 915
 916   client_free (client);
 917
 918   if (g_hash_table_size (daemon->clients) == 0)
 919     daemon->timeout = g_timeout_add (IDLE_TIMEOUT_MSEC,
 920                                      idle_timeout_cb,
 921                                      daemon);
 922 }
 923
 924 static gboolean
 925 handle_add_match (_GFreedesktopDBus *object,
 926                   GDBusMethodInvocation *invocation,
 927                   const gchar *arg_rule)
 928 {
 929   Client *client = g_object_get_data (G_OBJECT (g_dbus_method_invocation_get_connection (invocation)), "client");
 930   Match *match;
 931
 932   match = match_new (arg_rule);
 933
 934   if (match == NULL)
 935     g_dbus_method_invocation_return_error (invocation,
 936                                            G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_INVALID,
 937                                            "Invalid rule: %s", arg_rule);
 938   else
 939     {
 940       client->matches = g_list_prepend (client->matches, match);
 941       _g_freedesktop_dbus_complete_add_match (object, invocation);
 942     }
 943   return TRUE;
 944 }
 945
 946 static gboolean
 947 handle_get_connection_selinux_security_context (_GFreedesktopDBus *object,
 948                                                 GDBusMethodInvocation *invocation,
 949                                                 const gchar *arg_name)
 950 {
 951   g_dbus_method_invocation_return_error (invocation,
 952                                          G_DBUS_ERROR, G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN,
 953                                          "selinux context not supported");
 954   _g_freedesktop_dbus_complete_get_connection_selinux_security_context (object, invocation, "");
 955   return TRUE;
 956 }
 957
 958 static gboolean
 959 handle_get_connection_unix_process_id (_GFreedesktopDBus *object,
 960                                        GDBusMethodInvocation *invocation,
 961                                        const gchar *arg_name)
 962 {
 963   g_dbus_method_invocation_return_error (invocation,
 964                                          G_DBUS_ERROR, G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
 965                                          "connection pid not supported");
 966   return TRUE;
 967 }
 968
 969 static gboolean
 970 handle_get_connection_unix_user (_GFreedesktopDBus *object,
 971                                  GDBusMethodInvocation *invocation,
 972                                  const gchar *arg_name)
 973 {
 974   g_dbus_method_invocation_return_error (invocation,
 975                                          G_DBUS_ERROR, G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
 976                                          "connection user not supported");
 977   return TRUE;
 978 }
 979
 980 static gboolean
 981 handle_get_id (_GFreedesktopDBus *object,
 982                GDBusMethodInvocation *invocation)
 983 {
 984   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
 985   _g_freedesktop_dbus_complete_get_id (object, invocation,
 986                                        daemon->guid);
 987   return TRUE;
 988 }
 989
 990 static gboolean
 991 handle_get_name_owner (_GFreedesktopDBus *object,
 992                        GDBusMethodInvocation *invocation,
 993                        const gchar *arg_name)
 994 {
 995   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
 996   Name *name;
 997
 998   if (strcmp (arg_name, DBUS_SERVICE_NAME) == 0)
 999     {
1000       _g_freedesktop_dbus_complete_get_name_owner (object, invocation, DBUS_SERVICE_NAME);
1001       return TRUE;
1002     }
1003
1004   if (arg_name[0] == ':')
1005     {
1006       if (g_hash_table_lookup (daemon->clients, arg_name) == NULL)
1007         g_dbus_method_invocation_return_error (invocation,
1008                                                G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
1009                                                "Could not get owner of name '%s': no such name", arg_name);
1010       else
1011         _g_freedesktop_dbus_complete_get_name_owner (object, invocation, arg_name);
1012       return TRUE;
1013     }
1014
1015   name = name_lookup (daemon, arg_name);
1016   if (name == NULL || name->owner == NULL)
1017     {
1018       g_dbus_method_invocation_return_error (invocation,
1019                                              G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
1020                                              "Could not get owner of name '%s': no such name", arg_name);
1021       return TRUE;
1022     }
1023
1024   _g_freedesktop_dbus_complete_get_name_owner (object, invocation, name->owner->client->id);
1025   return TRUE;
1026 }
1027
1028 static gboolean
1029 handle_hello (_GFreedesktopDBus *object,
1030               GDBusMethodInvocation *invocation)
1031 {
1032   Client *client = g_object_get_data (G_OBJECT (g_dbus_method_invocation_get_connection (invocation)), "client");
1033   _g_freedesktop_dbus_complete_hello (object, invocation, client->id);
1034
1035   g_dbus_connection_emit_signal (client->connection,
1036                                  NULL, "/org/freedesktop/DBus",
1037                                  "org.freedesktop.DBus", "NameAcquired",
1038                                  g_variant_new ("(s)",
1039                                                 client->id), NULL);
1040
1041   return TRUE;
1042 }
1043
1044 static gboolean
1045 handle_list_activatable_names (_GFreedesktopDBus *object,
1046                                GDBusMethodInvocation *invocation)
1047 {
1048   const char *names[] = { NULL };
1049
1050   _g_freedesktop_dbus_complete_list_activatable_names (object,
1051                                                        invocation,
1052                                                        names);
1053   return TRUE;
1054 }
1055
1056 static gboolean
1057 handle_list_names (_GFreedesktopDBus *object,
1058                    GDBusMethodInvocation *invocation)
1059 {
1060   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1061   GPtrArray *array;
1062   GList *clients, *names, *l;
1063
1064   array = g_ptr_array_new ();
1065
1066   clients = g_hash_table_get_values (daemon->clients);
1067   for (l = clients; l != NULL; l = l->next)
1068     {
1069       Client *client = l->data;
1070
1071       g_ptr_array_add (array, client->id);
1072     }
1073
1074   g_list_free (clients);
1075
1076   names = g_hash_table_get_values (daemon->names);
1077   for (l = names; l != NULL; l = l->next)
1078     {
1079       Name *name = l->data;
1080
1081       g_ptr_array_add (array, name->name);
1082     }
1083
1084   g_list_free (names);
1085
1086   g_ptr_array_add (array, NULL);
1087
1088   _g_freedesktop_dbus_complete_list_names (object,
1089                                            invocation,
1090                                            (const gchar * const*)array->pdata);
1091   g_ptr_array_free (array, TRUE);
1092   return TRUE;
1093 }
1094
1095 static gboolean
1096 handle_list_queued_owners (_GFreedesktopDBus *object,
1097                            GDBusMethodInvocation *invocation,
1098                            const gchar *arg_name)
1099 {
1100   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1101   GPtrArray *array;
1102   Name *name;
1103   GList *l;
1104
1105   array = g_ptr_array_new ();
1106
1107   name = name_lookup (daemon, arg_name);
1108   if (name && name->owner)
1109     {
1110       for (l = name->queue; l != NULL; l = l->next)
1111         {
1112           Client *client = l->data;
1113
1114           g_ptr_array_add (array, client->id);
1115         }
1116     }
1117
1118   g_ptr_array_add (array, NULL);
1119
1120   _g_freedesktop_dbus_complete_list_queued_owners (object,
1121                                                    invocation,
1122                                                    (const gchar * const*)array->pdata);
1123   g_ptr_array_free (array, TRUE);
1124   return TRUE;
1125 }
1126
1127 static gboolean
1128 handle_name_has_owner (_GFreedesktopDBus *object,
1129                        GDBusMethodInvocation *invocation,
1130                        const gchar *arg_name)
1131 {
1132   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1133   Name *name;
1134   Client *client;
1135
1136   name = name_lookup (daemon, arg_name);
1137   client = g_hash_table_lookup (daemon->clients, arg_name);
1138
1139   _g_freedesktop_dbus_complete_name_has_owner (object, invocation,
1140                                                name != NULL || client != NULL);
1141   return TRUE;
1142 }
1143
1144 static gboolean
1145 handle_release_name (_GFreedesktopDBus *object,
1146                      GDBusMethodInvocation *invocation,
1147                      const gchar *arg_name)
1148 {
1149   Client *client = g_object_get_data (G_OBJECT (g_dbus_method_invocation_get_connection (invocation)), "client");
1150   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1151   Name *name;
1152   guint32 result;
1153
1154   if (!g_dbus_is_name (arg_name))
1155     {
1156       g_dbus_method_invocation_return_error (invocation,
1157                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1158                                              "Given bus name \"%s\" is not valid", arg_name);
1159       return TRUE;
1160     }
1161
1162   if (*arg_name == ':')
1163     {
1164       g_dbus_method_invocation_return_error (invocation,
1165                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1166                                              "Cannot release a service starting with ':' such as \"%s\"", arg_name);
1167       return TRUE;
1168     }
1169
1170   if (strcmp (arg_name, DBUS_SERVICE_NAME) == 0)
1171     {
1172       g_dbus_method_invocation_return_error (invocation,
1173                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1174                                              "Cannot release a service named " DBUS_SERVICE_NAME ", because that is owned by the bus");
1175       return TRUE;
1176     }
1177
1178   name = name_lookup (daemon, arg_name);
1179
1180   if (name == NULL)
1181     result = DBUS_RELEASE_NAME_REPLY_NON_EXISTENT;
1182   else if (name->owner && name->owner->client == client)
1183     {
1184       name_release_owner (name);
1185       result = DBUS_RELEASE_NAME_REPLY_RELEASED;
1186     }
1187   else if (name_unqueue_owner (name, client))
1188     result = DBUS_RELEASE_NAME_REPLY_RELEASED;
1189   else
1190     result = DBUS_RELEASE_NAME_REPLY_NOT_OWNER;
1191
1192   _g_freedesktop_dbus_complete_release_name (object, invocation, result);
1193   return TRUE;
1194 }
1195
1196 static gboolean
1197 handle_reload_config (_GFreedesktopDBus *object,
1198                       GDBusMethodInvocation *invocation)
1199 {
1200   _g_freedesktop_dbus_complete_reload_config (object, invocation);
1201   return TRUE;
1202 }
1203
1204 static gboolean
1205 handle_update_activation_environment (_GFreedesktopDBus *object,
1206                                       GDBusMethodInvocation *invocation,
1207                                       GVariant *arg_environment)
1208 {
1209   g_dbus_method_invocation_return_error (invocation,
1210                                          G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
1211                                          "UpdateActivationEnvironment not implemented");
1212   return TRUE;
1213 }
1214
1215 static gboolean
1216 handle_remove_match (_GFreedesktopDBus *object,
1217                      GDBusMethodInvocation *invocation,
1218                      const gchar *arg_rule)
1219 {
1220   Client *client = g_object_get_data (G_OBJECT (g_dbus_method_invocation_get_connection (invocation)), "client");
1221   Match *match, *other_match;
1222   GList *l;
1223
1224   match = match_new (arg_rule);
1225
1226   if (match == NULL)
1227     g_dbus_method_invocation_return_error (invocation,
1228                                            G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_INVALID,
1229                                            "Invalid rule: %s", arg_rule);
1230   else
1231     {
1232       for (l = client->matches; l != NULL; l = l->next)
1233         {
1234           other_match = l->data;
1235           if (match_equal (match, other_match))
1236             {
1237               match_free (other_match);
1238               client->matches = g_list_delete_link (client->matches, l);
1239               break;
1240             }
1241         }
1242
1243       if (l == NULL)
1244         g_dbus_method_invocation_return_error (invocation,
1245                                                G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
1246                                                "The given match rule wasn't found and can't be removed");
1247       else
1248         _g_freedesktop_dbus_complete_remove_match (object, invocation);
1249     }
1250   if (match)
1251     match_free (match);
1252
1253   return TRUE;
1254 }
1255
1256 static gboolean
1257 handle_request_name (_GFreedesktopDBus *object,
1258                      GDBusMethodInvocation *invocation,
1259                      const gchar *arg_name,
1260                      guint flags)
1261 {
1262   Client *client = g_object_get_data (G_OBJECT (g_dbus_method_invocation_get_connection (invocation)), "client");
1263   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1264   Name *name;
1265   NameOwner *owner;
1266   guint32 result;
1267
1268   if (!g_dbus_is_name (arg_name))
1269     {
1270       g_dbus_method_invocation_return_error (invocation,
1271                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1272                                              "Requested bus name \"%s\" is not valid", arg_name);
1273       return TRUE;
1274     }
1275
1276   if (*arg_name == ':')
1277     {
1278       g_dbus_method_invocation_return_error (invocation,
1279                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1280                                              "Cannot acquire a service starting with ':' such as \"%s\"", arg_name);
1281       return TRUE;
1282     }
1283
1284   if (strcmp (arg_name, DBUS_SERVICE_NAME) == 0)
1285     {
1286       g_dbus_method_invocation_return_error (invocation,
1287                                              G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
1288                                              "Cannot acquire a service named " DBUS_SERVICE_NAME ", because that is reserved");
1289       return TRUE;
1290     }
1291
1292   name = name_ensure (daemon, arg_name);
1293   if (name->owner == NULL)
1294     {
1295       owner = name_owner_new (client, flags);
1296       name_replace_owner (name, owner);
1297
1298       result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
1299     }
1300   else if (name->owner && name->owner->client == client)
1301     {
1302       name->owner->flags = flags;
1303       result = DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER;
1304     }
1305   else if ((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
1306            (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) ||
1307             !(name->owner->flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT)))
1308     {
1309       /* Unqueue if queued */
1310       name_unqueue_owner (name, client);
1311       result = DBUS_REQUEST_NAME_REPLY_EXISTS;
1312     }
1313   else if (!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
1314            (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) ||
1315             !(name->owner->flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT)))
1316     {
1317       /* Queue the connection */
1318       owner = name_owner_new (client, flags);
1319       name_queue_owner (name, owner);
1320       result = DBUS_REQUEST_NAME_REPLY_IN_QUEUE;
1321     }
1322   else
1323     {
1324       /* Replace the current owner */
1325
1326       owner = name_owner_new (client, flags);
1327       name_replace_owner (name, owner);
1328
1329       result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
1330     }
1331
1332   name_unref (name);
1333
1334   _g_freedesktop_dbus_complete_request_name (object, invocation, result);
1335   return TRUE;
1336 }
1337
1338 static gboolean
1339 handle_start_service_by_name (_GFreedesktopDBus *object,
1340                               GDBusMethodInvocation *invocation,
1341                               const gchar *arg_name,
1342                               guint arg_flags)
1343 {
1344   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1345   Name *name;
1346
1347   name = name_lookup (daemon, arg_name);
1348   if (name)
1349     _g_freedesktop_dbus_complete_start_service_by_name (object, invocation,
1350                                                         DBUS_START_REPLY_ALREADY_RUNNING);
1351   else
1352     g_dbus_method_invocation_return_error (invocation,
1353                                            G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN,
1354                                            "No support for activation for name: %s", arg_name);
1355
1356   return TRUE;
1357 }
1358
1359 G_GNUC_PRINTF(5, 6)
1360 static void
1361 return_error (Client *client, GDBusMessage *message,
1362               GQuark                 domain,
1363               gint                   code,
1364               const gchar           *format,
1365               ...)
1366 {
1367   GDBusMessage *reply;
1368   va_list var_args;
1369   char *error_message;
1370   GError *error;
1371   gchar *dbus_error_name;
1372
1373   va_start (var_args, format);
1374   error_message = g_strdup_vprintf (format, var_args);
1375   va_end (var_args);
1376
1377   error = g_error_new_literal (domain, code, "");
1378   dbus_error_name = g_dbus_error_encode_gerror (error);
1379
1380   reply = g_dbus_message_new_method_error_literal (message,
1381                                                    dbus_error_name,
1382                                                    error_message);
1383
1384   g_error_free (error);
1385   g_free (dbus_error_name);
1386   g_free (error_message);
1387
1388   if (!g_dbus_connection_send_message (client->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL))
1389       g_warning ("Error sending reply");
1390   g_object_unref (reply);
1391 }
1392
1393 static GDBusMessage *
1394 route_message (Client *source_client, GDBusMessage *message)
1395 {
1396   const char *dest;
1397   Client *dest_client;
1398   GDBusDaemon *daemon;
1399
1400   daemon = source_client->daemon;
1401
1402   dest_client = NULL;
1403   dest = g_dbus_message_get_destination (message);
1404   if (dest != NULL && strcmp (dest, DBUS_SERVICE_NAME) != 0)
1405     {
1406       dest_client = g_hash_table_lookup (daemon->clients, dest);
1407
1408       if (dest_client == NULL)
1409         {
1410           Name *name;
1411           name = name_lookup (daemon, dest);
1412           if (name && name->owner)
1413             dest_client = name->owner->client;
1414         }
1415
1416       if (dest_client == NULL)
1417         {
1418           if (g_dbus_message_get_message_type (message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL)
1419             return_error (source_client, message,
1420                           G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN,
1421                           "The name %s is unknown", dest);
1422         }
1423       else
1424         {
1425           GError *error = NULL;
1426
1427           if (!g_dbus_connection_send_message (dest_client->connection, message, G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL, NULL, &error))
1428             {
1429               g_warning ("Error forwarding message: %s", error->message);
1430               g_error_free (error);
1431             }
1432         }
1433     }
1434
1435   broadcast_message (daemon, message, dest_client != NULL, TRUE, dest_client);
1436
1437   /* Swallow messages not for the bus */
1438   if (dest == NULL || strcmp (dest, DBUS_SERVICE_NAME) != 0)
1439     {
1440       g_object_unref (message);
1441       message = NULL;
1442     }
1443
1444   return message;
1445 }
1446
1447 static GDBusMessage *
1448 copy_if_locked (GDBusMessage *message)
1449 {
1450   if (g_dbus_message_get_locked (message))
1451     {
1452       GDBusMessage *copy = g_dbus_message_copy (message, NULL);
1453       g_object_unref (message);
1454       message = copy;
1455     }
1456   return message;
1457 }
1458
1459 static GDBusMessage *
1460 filter_function (GDBusConnection *connection,
1461                  GDBusMessage    *message,
1462                  gboolean         incoming,
1463                  gpointer         user_data)
1464 {
1465   Client *client = user_data;
1466   const char *types[] = {"invalid", "method_call", "method_return", "error", "signal" };
1467
1468   if (0)
1469     g_printerr ("%s%s %s %d(%d) sender: %s destination: %s %s %s.%s\n",
1470                 client->id,
1471                 incoming? "->" : "<-",
1472                 types[g_dbus_message_get_message_type (message)],
1473                 g_dbus_message_get_serial (message),
1474                 g_dbus_message_get_reply_serial (message),
1475                 g_dbus_message_get_sender (message),
1476                 g_dbus_message_get_destination (message),
1477                 g_dbus_message_get_path (message),
1478                 g_dbus_message_get_interface (message),
1479                 g_dbus_message_get_member (message));
1480
1481   if (incoming)
1482     {
1483       /* Ensure its not locked so we can set the sender */
1484       message = copy_if_locked (message);
1485       if (message == NULL)
1486         {
1487           g_warning ("Failed to copy incoming message");
1488           return NULL;
1489         }
1490       g_dbus_message_set_sender (message, client->id);
1491
1492       return route_message (client, message);
1493     }
1494   else
1495     {
1496       if (g_dbus_message_get_sender (message) == NULL)
1497         {
1498           message = copy_if_locked (message);
1499           g_dbus_message_set_sender (message, DBUS_SERVICE_NAME);
1500         }
1501       if (g_dbus_message_get_destination (message) == NULL)
1502         {
1503           message = copy_if_locked (message);
1504           g_dbus_message_set_destination (message, client->id);
1505         }
1506     }
1507
1508   return message;
1509 }
1510
1511 static gboolean
1512 on_new_connection (GDBusServer *server,
1513                    GDBusConnection *connection,
1514                    gpointer user_data)
1515 {
1516   GDBusDaemon *daemon = user_data;
1517
1518   g_dbus_connection_set_exit_on_close (connection, FALSE);
1519
1520   if (daemon->timeout)
1521     {
1522       g_source_remove (daemon->timeout);
1523       daemon->timeout = 0;
1524     }
1525
1526   client_new (daemon, connection);
1527
1528   return TRUE;
1529 }
1530
1531 static gboolean
1532 on_authorize_authenticated_peer (GDBusAuthObserver *observer,
1533                                  GIOStream         *stream,
1534                                  GCredentials      *credentials,
1535                                  gpointer           user_data)
1536 {
1537   gboolean authorized = TRUE;
1538
1539   if (credentials != NULL)
1540     {
1541       GCredentials *own_credentials;
1542
1543       own_credentials = g_credentials_new ();
1544       authorized = g_credentials_is_same_user (credentials, own_credentials, NULL);
1545       g_object_unref (own_credentials);
1546     }
1547
1548   return authorized;
1549 }
1550
1551 static void
1552 g_dbus_daemon_finalize (GObject *object)
1553 {
1554   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1555   GList *clients, *l;
1556
1557   if (daemon->timeout)
1558     g_source_remove (daemon->timeout);
1559
1560   clients = g_hash_table_get_values (daemon->clients);
1561   for (l = clients; l != NULL; l = l->next)
1562     client_free (l->data);
1563   g_list_free (clients);
1564
1565   g_assert (g_hash_table_size (daemon->clients) == 0);
1566   g_assert (g_hash_table_size (daemon->names) == 0);
1567
1568   g_hash_table_destroy (daemon->clients);
1569   g_hash_table_destroy (daemon->names);
1570
1571   g_object_unref (daemon->server);
1572
1573   if (daemon->tmpdir)
1574     {
1575       g_rmdir (daemon->tmpdir);
1576       g_free (daemon->tmpdir);
1577     }
1578
1579   g_free (daemon->guid);
1580   g_free (daemon->address);
1581
1582   G_OBJECT_CLASS (g_dbus_daemon_parent_class)->finalize (object);
1583 }
1584
1585 static void
1586 g_dbus_daemon_init (GDBusDaemon *daemon)
1587 {
1588   daemon->next_major_id = 1;
1589   daemon->clients = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
1590   daemon->names = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
1591   daemon->guid = g_dbus_generate_guid ();
1592 }
1593
1594 static gboolean
1595 initable_init (GInitable     *initable,
1596                GCancellable  *cancellable,
1597                GError       **error)
1598 {
1599   GDBusDaemon *daemon = G_DBUS_DAEMON (initable);
1600   GDBusAuthObserver *observer;
1601   GDBusServerFlags flags;
1602
1603   flags = G_DBUS_SERVER_FLAGS_NONE;
1604   if (daemon->address == NULL)
1605     {
1606 #ifdef G_OS_UNIX
1607       if (g_unix_socket_address_abstract_names_supported ())
1608         daemon->address = g_strdup ("unix:tmpdir=/tmp/gdbus-daemon");
1609       else
1610         {
1611           daemon->tmpdir = g_dir_make_tmp ("gdbus-daemon-XXXXXX", NULL);
1612           daemon->address = g_strdup_printf ("unix:tmpdir=%s", daemon->tmpdir);
1613         }
1614 #else
1615       daemon->address = g_strdup ("nonce-tcp:");
1616       flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
1617 #endif
1618     }
1619
1620   observer = g_dbus_auth_observer_new ();
1621   daemon->server = g_dbus_server_new_sync (daemon->address,
1622                                            flags,
1623                                            daemon->guid,
1624                                            observer,
1625                                            cancellable,
1626                                            error);
1627   if (daemon->server == NULL)
1628     {
1629       g_object_unref (observer);
1630       return FALSE;
1631     }
1632
1633
1634   g_dbus_server_start (daemon->server);
1635
1636   g_signal_connect (daemon->server, "new-connection",
1637                     G_CALLBACK (on_new_connection),
1638                     daemon);
1639   g_signal_connect (observer,
1640                     "authorize-authenticated-peer",
1641                     G_CALLBACK (on_authorize_authenticated_peer),
1642                     daemon);
1643
1644   g_object_unref (observer);
1645
1646   return TRUE;
1647 }
1648
1649 static void
1650 g_dbus_daemon_set_property (GObject      *object,
1651                             guint         prop_id,
1652                             const GValue *value,
1653                             GParamSpec   *pspec)
1654 {
1655   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1656
1657   switch (prop_id)
1658     {
1659     case PROP_ADDRESS:
1660       g_free (daemon->address);
1661       daemon->address = g_value_dup_string (value);
1662       break;
1663
1664     default:
1665       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1666     }
1667 }
1668
1669 static void
1670 g_dbus_daemon_get_property (GObject    *object,
1671                             guint       prop_id,
1672                             GValue     *value,
1673                             GParamSpec *pspec)
1674 {
1675   GDBusDaemon *daemon = G_DBUS_DAEMON (object);
1676
1677   switch (prop_id)
1678     {
1679       case PROP_ADDRESS:
1680         g_value_set_string (value, daemon->address);
1681         break;
1682
1683     default:
1684         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1685     }
1686 }
1687
1688 static void
1689 g_dbus_daemon_class_init (GDBusDaemonClass *klass)
1690 {
1691   GObjectClass *gobject_class;
1692
1693   gobject_class = G_OBJECT_CLASS (klass);
1694   gobject_class->finalize = g_dbus_daemon_finalize;
1695   gobject_class->set_property = g_dbus_daemon_set_property;
1696   gobject_class->get_property = g_dbus_daemon_get_property;
1697
1698   g_dbus_daemon_signals[SIGNAL_IDLE_TIMEOUT] =
1699     g_signal_new (I_("idle-timeout"),
1700                   G_TYPE_DBUS_DAEMON,
1701                   G_SIGNAL_RUN_LAST,
1702                   0,
1703                   NULL, NULL,
1704                   g_cclosure_marshal_VOID__VOID,
1705                   G_TYPE_NONE, 0);
1706
1707   g_object_class_install_property (gobject_class,
1708                                    PROP_ADDRESS,
1709                                    g_param_spec_string ("address",
1710                                                         "Bus Address",
1711                                                         "The address the bus should use",
1712                                                         NULL,
1713                                                         G_PARAM_READWRITE |
1714                                                         G_PARAM_CONSTRUCT_ONLY |
1715                                                         G_PARAM_STATIC_STRINGS));
1716 }
1717
1718 static void
1719 g_dbus_daemon_iface_init (_GFreedesktopDBusIface *iface)
1720 {
1721   iface->handle_add_match = handle_add_match;
1722   iface->handle_get_connection_selinux_security_context = handle_get_connection_selinux_security_context;
1723   iface->handle_get_connection_unix_process_id = handle_get_connection_unix_process_id;
1724   iface->handle_get_connection_unix_user = handle_get_connection_unix_user;
1725   iface->handle_get_id = handle_get_id;
1726   iface->handle_get_name_owner = handle_get_name_owner;
1727   iface->handle_hello = handle_hello;
1728   iface->handle_list_activatable_names = handle_list_activatable_names;
1729   iface->handle_list_names = handle_list_names;
1730   iface->handle_list_queued_owners = handle_list_queued_owners;
1731   iface->handle_name_has_owner = handle_name_has_owner;
1732   iface->handle_release_name = handle_release_name;
1733   iface->handle_reload_config = handle_reload_config;
1734   iface->handle_update_activation_environment = handle_update_activation_environment;
1735   iface->handle_remove_match = handle_remove_match;
1736   iface->handle_request_name = handle_request_name;
1737   iface->handle_start_service_by_name = handle_start_service_by_name;
1738 }
1739
1740 static void
1741 initable_iface_init (GInitableIface *initable_iface)
1742 {
1743   initable_iface->init = initable_init;
1744 }
1745
1746 GDBusDaemon *
1747 _g_dbus_daemon_new (const char *address,
1748                     GCancellable *cancellable,
1749                     GError **error)
1750 {
1751   return g_initable_new (G_TYPE_DBUS_DAEMON,
1752                          cancellable,
1753                          error,
1754                          "address", address,
1755                          NULL);
1756 }
1757
1758 const char *
1759 _g_dbus_daemon_get_address (GDBusDaemon *daemon)
1760 {
1761   return g_dbus_server_get_client_address (daemon->server);
1762 }