bus/services.c

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