bus/services.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* services.c  Service management
   3  *
   4  * Copyright (C) 2003  Red Hat, Inc.
   5  * Copyright (C) 2003  CodeFactory AB
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #include <config.h>
  26 #include <dbus/dbus-hash.h>
  27 #include <dbus/dbus-list.h>
  28 #include <dbus/dbus-mempool.h>
  29 #include <dbus/dbus-marshal-validate.h>
  30
  31 #include "driver.h"
  32 #include "services.h"
  33 #include "connection.h"
  34 #include "utils.h"
  35 #include "activation.h"
  36 #include "policy.h"
  37 #include "bus.h"
  38 #include "selinux.h"
  39
  40 struct BusService
  41 {
  42   int refcount;
  43
  44   BusRegistry *registry;
  45   char *name;
  46   DBusList *owners;
  47 };
  48
  49 struct BusOwner
  50 {
  51   int refcount;
  52
  53   BusService *service;
  54   DBusConnection *conn;
  55
  56   unsigned int allow_replacement : 1;
  57   unsigned int do_not_queue : 1;
  58 };
  59
  60 struct BusRegistry
  61 {
  62   int refcount;
  63
  64   BusContext *context;
  65
  66   DBusHashTable *service_hash;
  67   DBusMemPool   *service_pool;
  68   DBusMemPool   *owner_pool;
  69
  70   DBusHashTable *service_sid_table;
  71 };
  72
  73 BusRegistry*
  74 bus_registry_new (BusContext *context)
  75 {
  76   BusRegistry *registry;
  77
  78   registry = dbus_new0 (BusRegistry, 1);
  79   if (registry == NULL)
  80     return NULL;
  81
  82   registry->refcount = 1;
  83   registry->context = context;
  84
  85   registry->service_hash = _dbus_hash_table_new (DBUS_HASH_STRING,
  86                                                  NULL, NULL);
  87   if (registry->service_hash == NULL)
  88     goto failed;
  89
  90   registry->service_pool = _dbus_mem_pool_new (sizeof (BusService),
  91                                                TRUE);
  92
  93   if (registry->service_pool == NULL)
  94     goto failed;
  95
  96   registry->owner_pool = _dbus_mem_pool_new (sizeof (BusOwner),
  97                                              TRUE);
  98
  99   if (registry->owner_pool == NULL)
 100     goto failed;
 101
 102   registry->service_sid_table = NULL;
 103
 104   return registry;
 105
 106  failed:
 107   bus_registry_unref (registry);
 108   return NULL;
 109 }
 110
 111 BusRegistry *
 112 bus_registry_ref (BusRegistry *registry)
 113 {
 114   _dbus_assert (registry->refcount > 0);
 115   registry->refcount += 1;
 116
 117   return registry;
 118 }
 119
 120 void
 121 bus_registry_unref  (BusRegistry *registry)
 122 {
 123   _dbus_assert (registry->refcount > 0);
 124   registry->refcount -= 1;
 125
 126   if (registry->refcount == 0)
 127     {
 128       if (registry->service_hash)
 129         _dbus_hash_table_unref (registry->service_hash);
 130       if (registry->service_pool)
 131         _dbus_mem_pool_free (registry->service_pool);
 132       if (registry->owner_pool)
 133         _dbus_mem_pool_free (registry->owner_pool);
 134       if (registry->service_sid_table)
 135         _dbus_hash_table_unref (registry->service_sid_table);
 136
 137       dbus_free (registry);
 138     }
 139 }
 140
 141 BusService*
 142 bus_registry_lookup (BusRegistry      *registry,
 143                      const DBusString *service_name)
 144 {
 145   BusService *service;
 146
 147   service = _dbus_hash_table_lookup_string (registry->service_hash,
 148                                             _dbus_string_get_const_data (service_name));
 149
 150   return service;
 151 }
 152
 153 static DBusList *
 154 _bus_service_find_owner_link (BusService *service,
 155                               DBusConnection *connection)
 156 {
 157   DBusList *link;
 158
 159   link = _dbus_list_get_first_link (&service->owners);
 160
 161   while (link != NULL)
 162     {
 163       BusOwner *bus_owner;
 164
 165       bus_owner = (BusOwner *) link->data;
 166       if (bus_owner->conn == connection)
 167         break;
 168
 169       link = _dbus_list_get_next_link (&service->owners, link);
 170     }
 171
 172   return link;
 173 }
 174
 175 static void
 176 bus_owner_set_flags (BusOwner *owner,
 177                      dbus_uint32_t flags)
 178 {
 179    owner->allow_replacement =
 180         (flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT) != FALSE;
 181
 182    owner->do_not_queue =
 183         (flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) != FALSE;
 184 }
 185
 186 static BusOwner *
 187 bus_owner_new (BusService *service,
 188                DBusConnection *conn,
 189                dbus_uint32_t flags)
 190 {
 191   BusOwner *result;
 192
 193   result = _dbus_mem_pool_alloc (service->registry->owner_pool);
 194   if (result != NULL)
 195     {
 196       result->refcount = 1;
 197       /* don't ref the connection because we don't want
 198          to block the connection from going away.
 199          transactions take care of reffing the connection
 200          but we need to use refcounting on the owner
 201          so that the owner does not get freed before
 202          we can deref the connection in the transaction
 203        */
 204       result->conn = conn;
 205       result->service = service;
 206
 207       if (!bus_connection_add_owned_service (conn, service))
 208         {
 209           _dbus_mem_pool_dealloc (service->registry->owner_pool, result);
 210           return NULL;
 211         }
 212
 213       bus_owner_set_flags (result, flags);
 214     }
 215   return result;
 216 }
 217
 218 static BusOwner *
 219 bus_owner_ref (BusOwner *owner)
 220 {
 221   _dbus_assert (owner->refcount > 0);
 222   owner->refcount += 1;
 223
 224   return owner;
 225 }
 226
 227 static void
 228 bus_owner_unref  (BusOwner *owner)
 229 {
 230   _dbus_assert (owner->refcount > 0);
 231   owner->refcount -= 1;
 232
 233   if (owner->refcount == 0)
 234     {
 235       bus_connection_remove_owned_service (owner->conn, owner->service);
 236       _dbus_mem_pool_dealloc (owner->service->registry->owner_pool, owner);
 237     }
 238 }
 239
 240 BusService*
 241 bus_registry_ensure (BusRegistry               *registry,
 242                      const DBusString          *service_name,
 243                      DBusConnection            *owner_connection_if_created,
 244                      dbus_uint32_t              flags,
 245                      BusTransaction            *transaction,
 246                      DBusError                 *error)
 247 {
 248   BusService *service;
 249
 250   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 251
 252   _dbus_assert (owner_connection_if_created != NULL);
 253   _dbus_assert (transaction != NULL);
 254
 255   service = _dbus_hash_table_lookup_string (registry->service_hash,
 256                                             _dbus_string_get_const_data (service_name));
 257   if (service != NULL)
 258     return service;
 259
 260   service = _dbus_mem_pool_alloc (registry->service_pool);
 261   if (service == NULL)
 262     {
 263       BUS_SET_OOM (error);
 264       return NULL;
 265     }
 266
 267   service->registry = registry;
 268   service->refcount = 1;
 269
 270   _dbus_verbose ("copying string %p '%s' to service->name\n",
 271                  service_name, _dbus_string_get_const_data (service_name));
 272   if (!_dbus_string_copy_data (service_name, &service->name))
 273     {
 274       _dbus_mem_pool_dealloc (registry->service_pool, service);
 275       BUS_SET_OOM (error);
 276       return NULL;
 277     }
 278   _dbus_verbose ("copied string %p '%s' to '%s'\n",
 279                  service_name, _dbus_string_get_const_data (service_name),
 280                  service->name);
 281
 282   if (!bus_driver_send_service_owner_changed (service->name,
 283                                               NULL,
 284                                               bus_connection_get_name (owner_connection_if_created),
 285                                               transaction, error))
 286     {
 287       bus_service_unref (service);
 288       return NULL;
 289     }
 290
 291   if (!bus_activation_service_created (bus_context_get_activation (registry->context),
 292                                        service->name, transaction, error))
 293     {
 294       bus_service_unref (service);
 295       return NULL;
 296     }
 297
 298   if (!bus_service_add_owner (service, owner_connection_if_created, flags,
 299                                               transaction, error))
 300     {
 301       bus_service_unref (service);
 302       return NULL;
 303     }
 304
 305   if (!_dbus_hash_table_insert_string (registry->service_hash,
 306                                        service->name,
 307                                        service))
 308     {
 309       /* The add_owner gets reverted on transaction cancel */
 310       BUS_SET_OOM (error);
 311       return NULL;
 312     }
 313
 314   return service;
 315 }
 316
 317 void
 318 bus_registry_foreach (BusRegistry               *registry,
 319                       BusServiceForeachFunction  function,
 320                       void                      *data)
 321 {
 322   DBusHashIter iter;
 323
 324   _dbus_hash_iter_init (registry->service_hash, &iter);
 325   while (_dbus_hash_iter_next (&iter))
 326     {
 327       BusService *service = _dbus_hash_iter_get_value (&iter);
 328
 329       (* function) (service, data);
 330     }
 331 }
 332
 333 dbus_bool_t
 334 bus_registry_list_services (BusRegistry *registry,
 335                             char      ***listp,
 336                             int         *array_len)
 337 {
 338   int i, j, len;
 339   char **retval;
 340   DBusHashIter iter;
 341
 342   len = _dbus_hash_table_get_n_entries (registry->service_hash);
 343   retval = dbus_new (char *, len + 1);
 344
 345   if (retval == NULL)
 346     return FALSE;
 347
 348   _dbus_hash_iter_init (registry->service_hash, &iter);
 349   i = 0;
 350   while (_dbus_hash_iter_next (&iter))
 351     {
 352       BusService *service = _dbus_hash_iter_get_value (&iter);
 353
 354       retval[i] = _dbus_strdup (service->name);
 355       if (retval[i] == NULL)
 356         goto error;
 357
 358       i++;
 359     }
 360
 361   retval[i] = NULL;
 362
 363   if (array_len)
 364     *array_len = len;
 365
 366   *listp = retval;
 367   return TRUE;
 368
 369  error:
 370   for (j = 0; j < i; j++)
 371     dbus_free (retval[i]);
 372   dbus_free (retval);
 373
 374   return FALSE;
 375 }
 376
 377 dbus_bool_t
 378 bus_registry_acquire_service (BusRegistry      *registry,
 379                               DBusConnection   *connection,
 380                               const DBusString *service_name,
 381                               dbus_uint32_t     flags,
 382                               dbus_uint32_t    *result,
 383                               BusTransaction   *transaction,
 384                               DBusError        *error)
 385 {
 386   dbus_bool_t retval;
 387   DBusConnection *old_owner_conn;
 388   DBusConnection *current_owner_conn;
 389   BusClientPolicy *policy;
 390   BusService *service;
 391   BusActivation  *activation;
 392   BusSELinuxID *sid;
 393   BusOwner *primary_owner;
 394
 395   retval = FALSE;
 396
 397   if (!_dbus_validate_bus_name (service_name, 0,
 398                                 _dbus_string_get_length (service_name)))
 399     {
 400       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 401                       "Requested bus name \"%s\" is not valid",
 402                       _dbus_string_get_const_data (service_name));
 403
 404       _dbus_verbose ("Attempt to acquire invalid service name\n");
 405
 406       goto out;
 407     }
 408
 409   if (_dbus_string_get_byte (service_name, 0) == ':')
 410     {
 411       /* Not allowed; only base services can start with ':' */
 412       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 413                       "Cannot acquire a service starting with ':' such as \"%s\"",
 414                       _dbus_string_get_const_data (service_name));
 415
 416       _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"",
 417                      _dbus_string_get_const_data (service_name));
 418
 419       goto out;
 420     }
 421
 422   if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
 423     {
 424       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 425                       "Connection \"%s\" is not allowed to own the service \"%s\"because "
 426                       "it is reserved for D-Bus' use only",
 427                       bus_connection_is_active (connection) ?
 428                       bus_connection_get_name (connection) :
 429                       "(inactive)",
 430                       DBUS_SERVICE_DBUS);
 431       goto out;
 432     }
 433
 434   policy = bus_connection_get_policy (connection);
 435   _dbus_assert (policy != NULL);
 436
 437   /* Note that if sid is #NULL then the bus's own context gets used
 438    * in bus_connection_selinux_allows_acquire_service()
 439    */
 440   sid = bus_selinux_id_table_lookup (registry->service_sid_table,
 441                                      service_name);
 442
 443   if (!bus_selinux_allows_acquire_service (connection, sid,
 444                                            _dbus_string_get_const_data (service_name), error))
 445     {
 446
 447       if (dbus_error_is_set (error) &&
 448           dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY))
 449         {
 450           goto out;
 451         }
 452
 453       dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
 454                       "Connection \"%s\" is not allowed to own the service \"%s\" due "
 455                       "to SELinux policy",
 456                       bus_connection_is_active (connection) ?
 457                       bus_connection_get_name (connection) :
 458                       "(inactive)",
 459                       _dbus_string_get_const_data (service_name));
 460       goto out;
 461     }
 462
 463   if (!bus_client_policy_check_can_own (policy, connection,
 464                                         service_name))
 465     {
 466       dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
 467                       "Connection \"%s\" is not allowed to own the service \"%s\" due "
 468                       "to security policies in the configuration file",
 469                       bus_connection_is_active (connection) ?
 470                       bus_connection_get_name (connection) :
 471                       "(inactive)",
 472                       _dbus_string_get_const_data (service_name));
 473       goto out;
 474     }
 475
 476   if (bus_connection_get_n_services_owned (connection) >=
 477       bus_context_get_max_services_per_connection (registry->context))
 478     {
 479       dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
 480                       "Connection \"%s\" is not allowed to own more services "
 481                       "(increase limits in configuration file if required)",
 482                       bus_connection_is_active (connection) ?
 483                       bus_connection_get_name (connection) :
 484                       "(inactive)");
 485       goto out;
 486     }
 487
 488   service = bus_registry_lookup (registry, service_name);
 489
 490   if (service != NULL)
 491     {
 492       primary_owner = bus_service_get_primary_owner (service);
 493       if (primary_owner != NULL)
 494         old_owner_conn = primary_owner->conn;
 495       else
 496         old_owner_conn = NULL;
 497     }
 498   else
 499     old_owner_conn = NULL;
 500
 501   if (service == NULL)
 502     {
 503       service = bus_registry_ensure (registry,
 504                                      service_name, connection, flags,
 505                                      transaction, error);
 506       if (service == NULL)
 507         goto out;
 508     }
 509
 510   primary_owner = bus_service_get_primary_owner (service);
 511   if (primary_owner == NULL)
 512     goto out;
 513
 514   current_owner_conn = primary_owner->conn;
 515
 516   if (old_owner_conn == NULL)
 517     {
 518       _dbus_assert (current_owner_conn == connection);
 519
 520       *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
 521     }
 522   else if (old_owner_conn == connection)
 523     {
 524       bus_owner_set_flags (primary_owner, flags);
 525       *result = DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER;
 526     }
 527   else if (((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
 528            !(bus_service_get_allow_replacement (service))) ||
 529            ((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
 530            !(flags & DBUS_NAME_FLAG_REPLACE_EXISTING)))
 531     {
 532       DBusList *link;
 533       BusOwner *temp_owner;
 534     /* Since we can't be queued if we are already in the queue
 535        remove us */
 536
 537       link = _bus_service_find_owner_link (service, connection);
 538       if (link != NULL)
 539         {
 540           _dbus_list_unlink (&service->owners, link);
 541           temp_owner = (BusOwner *)link->data;
 542           bus_owner_unref (temp_owner);
 543           _dbus_list_free_link (link);
 544         }
 545
 546       *result = DBUS_REQUEST_NAME_REPLY_EXISTS;
 547     }
 548   else if (!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
 549            (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) ||
 550             !(bus_service_get_allow_replacement (service))))
 551     {
 552       /* Queue the connection */
 553       if (!bus_service_add_owner (service, connection,
 554                                   flags,
 555                                   transaction, error))
 556         goto out;
 557
 558       *result = DBUS_REQUEST_NAME_REPLY_IN_QUEUE;
 559     }
 560   else
 561     {
 562       /* Replace the current owner */
 563
 564       /* We enqueue the new owner and remove the first one because
 565        * that will cause NameAcquired and NameLost messages to
 566        * be sent.
 567        */
 568
 569       if (!bus_service_add_owner (service, connection,
 570                                   flags,
 571                                   transaction, error))
 572         goto out;
 573
 574       if (primary_owner->do_not_queue)
 575         {
 576           if (!bus_service_remove_owner (service, old_owner_conn,
 577                                          transaction, error))
 578             goto out;
 579         }
 580       else
 581         {
 582           if (!bus_service_swap_owner (service, old_owner_conn,
 583                                        transaction, error))
 584             goto out;
 585         }
 586
 587
 588       _dbus_assert (connection == bus_service_get_primary_owner (service)->conn);
 589       *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
 590     }
 591
 592   activation = bus_context_get_activation (registry->context);
 593   retval = bus_activation_send_pending_auto_activation_messages (activation,
 594                                                                  service,
 595                                                                  transaction,
 596                                                                  error);
 597
 598  out:
 599   return retval;
 600 }
 601
 602 dbus_bool_t
 603 bus_registry_release_service (BusRegistry      *registry,
 604                               DBusConnection   *connection,
 605                               const DBusString *service_name,
 606                               dbus_uint32_t    *result,
 607                               BusTransaction   *transaction,
 608                               DBusError        *error)
 609 {
 610   dbus_bool_t retval;
 611   BusService *service;
 612
 613   retval = FALSE;
 614
 615   if (!_dbus_validate_bus_name (service_name, 0,
 616                                 _dbus_string_get_length (service_name)))
 617     {
 618       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 619                       "Given bus name \"%s\" is not valid",
 620                       _dbus_string_get_const_data (service_name));
 621
 622       _dbus_verbose ("Attempt to release invalid service name\n");
 623
 624       goto out;
 625     }
 626
 627   if (_dbus_string_get_byte (service_name, 0) == ':')
 628     {
 629       /* Not allowed; the base service name cannot be created or released */
 630       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 631                       "Cannot release a service starting with ':' such as \"%s\"",
 632                       _dbus_string_get_const_data (service_name));
 633
 634       _dbus_verbose ("Attempt to release invalid base service name \"%s\"",
 635                      _dbus_string_get_const_data (service_name));
 636
 637       goto out;
 638     }
 639
 640    if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
 641     {
 642       /* Not allowed; the base service name cannot be created or released */
 643       dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 644                       "Cannot release the %s service because it is owned by the bus",
 645                      DBUS_SERVICE_DBUS);
 646
 647       _dbus_verbose ("Attempt to release service name \"%s\"",
 648                      DBUS_SERVICE_DBUS);
 649
 650       goto out;
 651     }
 652
 653   service = bus_registry_lookup (registry, service_name);
 654
 655   if (service == NULL)
 656     {
 657       *result = DBUS_RELEASE_NAME_REPLY_NON_EXISTENT;
 658     }
 659   else if (!bus_service_has_owner (service, connection))
 660     {
 661       *result = DBUS_RELEASE_NAME_REPLY_NOT_OWNER;
 662     }
 663   else
 664     {
 665       if (!bus_service_remove_owner (service, connection,
 666                                      transaction, error))
 667         goto out;
 668
 669       _dbus_assert (!bus_service_has_owner (service, connection));
 670       *result = DBUS_RELEASE_NAME_REPLY_RELEASED;
 671     }
 672
 673   retval = TRUE;
 674
 675  out:
 676   return retval;
 677 }
 678
 679 dbus_bool_t
 680 bus_registry_set_service_context_table (BusRegistry   *registry,
 681                                         DBusHashTable *table)
 682 {
 683   DBusHashTable *new_table;
 684   DBusHashIter iter;
 685
 686   new_table = bus_selinux_id_table_new ();
 687   if (!new_table)
 688     return FALSE;
 689
 690   _dbus_hash_iter_init (table, &iter);
 691   while (_dbus_hash_iter_next (&iter))
 692     {
 693       const char *service = _dbus_hash_iter_get_string_key (&iter);
 694       const char *context = _dbus_hash_iter_get_value (&iter);
 695
 696       if (!bus_selinux_id_table_insert (new_table,
 697                                         service,
 698                                         context))
 699         return FALSE;
 700     }
 701
 702   if (registry->service_sid_table)
 703     _dbus_hash_table_unref (registry->service_sid_table);
 704   registry->service_sid_table = new_table;
 705   return TRUE;
 706 }
 707
 708 static void
 709 bus_service_unlink_owner (BusService      *service,
 710                           BusOwner        *owner)
 711 {
 712   _dbus_list_remove_last (&service->owners, owner);
 713   bus_owner_unref (owner);
 714 }
 715
 716 static void
 717 bus_service_unlink (BusService *service)
 718 {
 719   _dbus_assert (service->owners == NULL);
 720
 721   /* the service may not be in the hash, if
 722    * the failure causing transaction cancel
 723    * was in the right place, but that's OK
 724    */
 725   _dbus_hash_table_remove_string (service->registry->service_hash,
 726                                   service->name);
 727
 728   bus_service_unref (service);
 729 }
 730
 731 static void
 732 bus_service_relink (BusService           *service,
 733                     DBusPreallocatedHash *preallocated)
 734 {
 735   _dbus_assert (service->owners == NULL);
 736   _dbus_assert (preallocated != NULL);
 737
 738   _dbus_hash_table_insert_string_preallocated (service->registry->service_hash,
 739                                                preallocated,
 740                                                service->name,
 741                                                service);
 742
 743   bus_service_ref (service);
 744 }
 745
 746 /**
 747  * Data used to represent an ownership cancellation in
 748  * a bus transaction.
 749  */
 750 typedef struct
 751 {
 752   BusOwner *owner;            /**< the owner */
 753   BusService *service;        /**< service to cancel ownership of */
 754 } OwnershipCancelData;
 755
 756 static void
 757 cancel_ownership (void *data)
 758 {
 759   OwnershipCancelData *d = data;
 760
 761   /* We don't need to send messages notifying of these
 762    * changes, since we're reverting something that was
 763    * cancelled (effectively never really happened)
 764    */
 765   bus_service_unlink_owner (d->service, d->owner);
 766
 767   if (d->service->owners == NULL)
 768     bus_service_unlink (d->service);
 769 }
 770
 771 static void
 772 free_ownership_cancel_data (void *data)
 773 {
 774   OwnershipCancelData *d = data;
 775
 776   dbus_connection_unref (d->owner->conn);
 777   bus_owner_unref (d->owner);
 778   bus_service_unref (d->service);
 779
 780   dbus_free (d);
 781 }
 782
 783 static dbus_bool_t
 784 add_cancel_ownership_to_transaction (BusTransaction *transaction,
 785                                      BusService     *service,
 786                                      BusOwner       *owner)
 787 {
 788   OwnershipCancelData *d;
 789
 790   d = dbus_new (OwnershipCancelData, 1);
 791   if (d == NULL)
 792     return FALSE;
 793
 794   d->service = service;
 795   d->owner = owner;
 796
 797   if (!bus_transaction_add_cancel_hook (transaction, cancel_ownership, d,
 798                                         free_ownership_cancel_data))
 799     {
 800       dbus_free (d);
 801       return FALSE;
 802     }
 803
 804   bus_service_ref (d->service);
 805   bus_owner_ref (owner);
 806   dbus_connection_ref (d->owner->conn);
 807
 808   return TRUE;
 809 }
 810
 811 /* this function is self-cancelling if you cancel the transaction */
 812 dbus_bool_t
 813 bus_service_add_owner (BusService     *service,
 814                        DBusConnection *connection,
 815                        dbus_uint32_t  flags,
 816                        BusTransaction *transaction,
 817                        DBusError      *error)
 818 {
 819   BusOwner *bus_owner;
 820   DBusList *bus_owner_link;
 821
 822   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 823
 824  /* Send service acquired message first, OOM will result
 825   * in cancelling the transaction
 826   */
 827   if (service->owners == NULL)
 828     {
 829       if (!bus_driver_send_service_acquired (connection, service->name, transaction, error))
 830         return FALSE;
 831     }
 832
 833   bus_owner_link = _bus_service_find_owner_link (service, connection);
 834
 835   if (bus_owner_link == NULL)
 836     {
 837       bus_owner = bus_owner_new (service, connection, flags);
 838       if (bus_owner == NULL)
 839         {
 840           BUS_SET_OOM (error);
 841           return FALSE;
 842         }
 843
 844       bus_owner_set_flags (bus_owner, flags);
 845       if (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) || service->owners == NULL)
 846         {
 847           if (!_dbus_list_append (&service->owners,
 848                                   bus_owner))
 849             {
 850               bus_owner_unref (bus_owner);
 851               BUS_SET_OOM (error);
 852               return FALSE;
 853             }
 854         }
 855       else
 856         {
 857           if (!_dbus_list_insert_after (&service->owners,
 858                                          _dbus_list_get_first_link (&service->owners),
 859                                          bus_owner))
 860             {
 861               bus_owner_unref (bus_owner);
 862               BUS_SET_OOM (error);
 863               return FALSE;
 864             }
 865         }
 866     }
 867   else
 868     {
 869       /* Update the link since we are already in the queue
 870        * No need for operations that can produce OOM
 871        */
 872
 873       bus_owner = (BusOwner *) bus_owner_link->data;
 874       if (flags & DBUS_NAME_FLAG_REPLACE_EXISTING)
 875         {
 876           DBusList *link;
 877           _dbus_list_unlink (&service->owners, bus_owner_link);
 878           link = _dbus_list_get_first_link (&service->owners);
 879           _dbus_assert (link != NULL);
 880
 881           _dbus_list_insert_after_link (&service->owners, link, bus_owner_link);
 882         }
 883
 884       bus_owner_set_flags (bus_owner, flags);
 885       return TRUE;
 886     }
 887
 888   if (!add_cancel_ownership_to_transaction (transaction,
 889                                             service,
 890                                             bus_owner))
 891     {
 892       bus_service_unlink_owner (service, bus_owner);
 893       BUS_SET_OOM (error);
 894       return FALSE;
 895     }
 896
 897   return TRUE;
 898 }
 899
 900 typedef struct
 901 {
 902   BusOwner       *owner;
 903   BusService     *service;
 904   BusOwner       *before_owner; /* restore to position before this connection in owners list */
 905   DBusList       *owner_link;
 906   DBusList       *service_link;
 907   DBusPreallocatedHash *hash_entry;
 908 } OwnershipRestoreData;
 909
 910 static void
 911 restore_ownership (void *data)
 912 {
 913   OwnershipRestoreData *d = data;
 914   DBusList *link;
 915
 916   _dbus_assert (d->service_link != NULL);
 917   _dbus_assert (d->owner_link != NULL);
 918
 919   if (d->service->owners == NULL)
 920     {
 921       _dbus_assert (d->hash_entry != NULL);
 922       bus_service_relink (d->service, d->hash_entry);
 923     }
 924   else
 925     {
 926       _dbus_assert (d->hash_entry == NULL);
 927     }
 928
 929   /* We don't need to send messages notifying of these
 930    * changes, since we're reverting something that was
 931    * cancelled (effectively never really happened)
 932    */
 933   link = _dbus_list_get_first_link (&d->service->owners);
 934   while (link != NULL)
 935     {
 936       if (link->data == d->before_owner)
 937         break;
 938
 939       link = _dbus_list_get_next_link (&d->service->owners, link);
 940     }
 941
 942   _dbus_list_insert_before_link (&d->service->owners, link, d->owner_link);
 943
 944   /* Note that removing then restoring this changes the order in which
 945    * ServiceDeleted messages are sent on destruction of the
 946    * connection.  This should be OK as the only guarantee there is
 947    * that the base service is destroyed last, and we never even
 948    * tentatively remove the base service.
 949    */
 950   bus_connection_add_owned_service_link (d->owner->conn, d->service_link);
 951
 952   d->hash_entry = NULL;
 953   d->service_link = NULL;
 954   d->owner_link = NULL;
 955 }
 956
 957 static void
 958 free_ownership_restore_data (void *data)
 959 {
 960   OwnershipRestoreData *d = data;
 961
 962   if (d->service_link)
 963     _dbus_list_free_link (d->service_link);
 964   if (d->owner_link)
 965     _dbus_list_free_link (d->owner_link);
 966   if (d->hash_entry)
 967     _dbus_hash_table_free_preallocated_entry (d->service->registry->service_hash,
 968                                               d->hash_entry);
 969
 970   dbus_connection_unref (d->owner->conn);
 971   bus_owner_unref (d->owner);
 972   bus_service_unref (d->service);
 973
 974   dbus_free (d);
 975 }
 976
 977 static dbus_bool_t
 978 add_restore_ownership_to_transaction (BusTransaction *transaction,
 979                                       BusService     *service,
 980                                       BusOwner       *owner)
 981 {
 982   OwnershipRestoreData *d;
 983   DBusList *link;
 984
 985   d = dbus_new (OwnershipRestoreData, 1);
 986   if (d == NULL)
 987     return FALSE;
 988
 989   d->service = service;
 990   d->owner = owner;
 991   d->service_link = _dbus_list_alloc_link (service);
 992   d->owner_link = _dbus_list_alloc_link (owner);
 993   d->hash_entry = _dbus_hash_table_preallocate_entry (service->registry->service_hash);
 994
 995   bus_service_ref (d->service);
 996   bus_owner_ref (d->owner);
 997   dbus_connection_ref (d->owner->conn);
 998
 999   d->before_owner = NULL;
1000   link = _dbus_list_get_first_link (&service->owners);
1001   while (link != NULL)
1002     {
1003       if (link->data == owner)
1004         {
1005           link = _dbus_list_get_next_link (&service->owners, link);
1006
1007           if (link)
1008             d->before_owner = link->data;
1009
1010           break;
1011         }
1012
1013       link = _dbus_list_get_next_link (&service->owners, link);
1014     }
1015
1016   if (d->service_link == NULL ||
1017       d->owner_link == NULL ||
1018       d->hash_entry == NULL ||
1019       !bus_transaction_add_cancel_hook (transaction, restore_ownership, d,
1020                                         free_ownership_restore_data))
1021     {
1022       free_ownership_restore_data (d);
1023       return FALSE;
1024     }
1025
1026   return TRUE;
1027 }
1028
1029 dbus_bool_t
1030 bus_service_swap_owner (BusService     *service,
1031                         DBusConnection *connection,
1032                         BusTransaction *transaction,
1033                         DBusError      *error)
1034 {
1035   DBusList *swap_link;
1036   BusOwner *primary_owner;
1037
1038   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1039
1040   /* We send out notifications before we do any work we
1041    * might have to undo if the notification-sending failed
1042    */
1043
1044   /* Send service lost message */
1045   primary_owner = bus_service_get_primary_owner (service);
1046   if (primary_owner == NULL || primary_owner->conn != connection)
1047     _dbus_assert_not_reached ("Tried to swap a non primary owner");
1048
1049
1050   if (!bus_driver_send_service_lost (connection, service->name,
1051                                      transaction, error))
1052     return FALSE;
1053
1054   if (service->owners == NULL)
1055     {
1056       _dbus_assert_not_reached ("Tried to swap owner of a service that has no owners");
1057     }
1058   else if (_dbus_list_length_is_one (&service->owners))
1059     {
1060       _dbus_assert_not_reached ("Tried to swap owner of a service that has no other owners in the queue");
1061     }
1062   else
1063     {
1064       DBusList *link;
1065       BusOwner *new_owner;
1066       DBusConnection *new_owner_conn;
1067       link = _dbus_list_get_first_link (&service->owners);
1068       _dbus_assert (link != NULL);
1069       link = _dbus_list_get_next_link (&service->owners, link);
1070       _dbus_assert (link != NULL);
1071
1072       new_owner = (BusOwner *)link->data;
1073       new_owner_conn = new_owner->conn;
1074
1075       if (!bus_driver_send_service_owner_changed (service->name,
1076                                                   bus_connection_get_name (connection),
1077                                                   bus_connection_get_name (new_owner_conn),
1078                                                   transaction, error))
1079         return FALSE;
1080
1081       /* This will be our new owner */
1082       if (!bus_driver_send_service_acquired (new_owner_conn,
1083                                              service->name,
1084                                              transaction,
1085                                              error))
1086         return FALSE;
1087     }
1088
1089   if (!add_restore_ownership_to_transaction (transaction, service, primary_owner))
1090     {
1091       BUS_SET_OOM (error);
1092       return FALSE;
1093     }
1094
1095   /* unlink the primary and make it the second link */
1096   swap_link = _dbus_list_get_first_link (&service->owners);
1097   _dbus_list_unlink (&service->owners, swap_link);
1098
1099   _dbus_list_insert_after_link (&service->owners,
1100                                 _dbus_list_get_first_link (&service->owners),
1101                                 swap_link);
1102
1103   return TRUE;
1104 }
1105
1106 /* this function is self-cancelling if you cancel the transaction */
1107 dbus_bool_t
1108 bus_service_remove_owner (BusService     *service,
1109                           DBusConnection *connection,
1110                           BusTransaction *transaction,
1111                           DBusError      *error)
1112 {
1113   BusOwner *primary_owner;
1114
1115   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1116
1117   /* We send out notifications before we do any work we
1118    * might have to undo if the notification-sending failed
1119    */
1120
1121   /* Send service lost message */
1122   primary_owner = bus_service_get_primary_owner (service);
1123   if (primary_owner != NULL && primary_owner->conn == connection)
1124     {
1125       if (!bus_driver_send_service_lost (connection, service->name,
1126                                          transaction, error))
1127         return FALSE;
1128     }
1129   else
1130     {
1131       /* if we are not the primary owner then just remove us from the queue */
1132       DBusList *link;
1133       BusOwner *temp_owner;
1134
1135       link = _bus_service_find_owner_link (service, connection);
1136       _dbus_list_unlink (&service->owners, link);
1137       temp_owner = (BusOwner *)link->data;
1138       bus_owner_unref (temp_owner);
1139       _dbus_list_free_link (link);
1140
1141       return TRUE;
1142     }
1143
1144   if (service->owners == NULL)
1145     {
1146       _dbus_assert_not_reached ("Tried to remove owner of a service that has no owners");
1147     }
1148   else if (_dbus_list_length_is_one (&service->owners))
1149     {
1150       if (!bus_driver_send_service_owner_changed (service->name,
1151                                                   bus_connection_get_name (connection),
1152                                                   NULL,
1153                                                   transaction, error))
1154         return FALSE;
1155     }
1156   else
1157     {
1158       DBusList *link;
1159       BusOwner *new_owner;
1160       DBusConnection *new_owner_conn;
1161       link = _dbus_list_get_first_link (&service->owners);
1162       _dbus_assert (link != NULL);
1163       link = _dbus_list_get_next_link (&service->owners, link);
1164       _dbus_assert (link != NULL);
1165
1166       new_owner = (BusOwner *)link->data;
1167       new_owner_conn = new_owner->conn;
1168
1169       if (!bus_driver_send_service_owner_changed (service->name,
1170                                                   bus_connection_get_name (connection),
1171                                                   bus_connection_get_name (new_owner_conn),
1172                                                   transaction, error))
1173         return FALSE;
1174
1175       /* This will be our new owner */
1176       if (!bus_driver_send_service_acquired (new_owner_conn,
1177                                              service->name,
1178                                              transaction,
1179                                              error))
1180         return FALSE;
1181     }
1182
1183   if (!add_restore_ownership_to_transaction (transaction, service, primary_owner))
1184     {
1185       BUS_SET_OOM (error);
1186       return FALSE;
1187     }
1188
1189   bus_service_unlink_owner (service, primary_owner);
1190
1191   if (service->owners == NULL)
1192     bus_service_unlink (service);
1193
1194   return TRUE;
1195 }
1196
1197 BusService *
1198 bus_service_ref (BusService *service)
1199 {
1200   _dbus_assert (service->refcount > 0);
1201
1202   service->refcount += 1;
1203
1204   return service;
1205 }
1206
1207 void
1208 bus_service_unref (BusService *service)
1209 {
1210   _dbus_assert (service->refcount > 0);
1211
1212   service->refcount -= 1;
1213
1214   if (service->refcount == 0)
1215     {
1216       _dbus_assert (service->owners == NULL);
1217
1218       dbus_free (service->name);
1219       _dbus_mem_pool_dealloc (service->registry->service_pool, service);
1220     }
1221 }
1222
1223 DBusConnection *
1224 bus_service_get_primary_owners_connection (BusService *service)
1225 {
1226   BusOwner *owner;
1227
1228   owner = bus_service_get_primary_owner (service);
1229
1230   if (owner != NULL)
1231     return owner->conn;
1232   else
1233     return NULL;
1234 }
1235
1236 BusOwner*
1237 bus_service_get_primary_owner (BusService *service)
1238 {
1239   return _dbus_list_get_first (&service->owners);
1240 }
1241
1242 const char*
1243 bus_service_get_name (BusService *service)
1244 {
1245   return service->name;
1246 }
1247
1248 dbus_bool_t
1249 bus_service_get_allow_replacement (BusService *service)
1250 {
1251   BusOwner *owner;
1252   DBusList *link;
1253
1254   _dbus_assert (service->owners != NULL);
1255
1256   link = _dbus_list_get_first_link (&service->owners);
1257   owner = (BusOwner *) link->data;
1258
1259   return owner->allow_replacement;
1260 }
1261
1262 dbus_bool_t
1263 bus_service_has_owner (BusService     *service,
1264                        DBusConnection *connection)
1265 {
1266   DBusList *link;
1267
1268   link = _bus_service_find_owner_link (service, connection);
1269
1270   if (link == NULL)
1271     return FALSE;
1272   else
1273     return TRUE;
1274 }
1275
1276 dbus_bool_t
1277 bus_service_list_queued_owners (BusService *service,
1278                                 DBusList  **return_list,
1279                                 DBusError  *error)
1280 {
1281   DBusList *link;
1282
1283   _dbus_assert (*return_list == NULL);
1284
1285   link = _dbus_list_get_first_link (&service->owners);
1286   _dbus_assert (link != NULL);
1287
1288   while (link != NULL)
1289     {
1290       BusOwner *owner;
1291       const char *uname;
1292
1293       owner = (BusOwner *) link->data;
1294       uname = bus_connection_get_name (owner->conn);
1295
1296       if (!_dbus_list_append (return_list, (char *)uname))
1297         goto oom;
1298
1299       link = _dbus_list_get_next_link (&service->owners, link);
1300     }
1301
1302   return TRUE;
1303
1304  oom:
1305   _dbus_list_clear (return_list);
1306   BUS_SET_OOM (error);
1307   return FALSE;
1308 }