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 BusClientPolicy *policy; 389 BusService *service; 390 BusActivation *activation; 391 BusSELinuxID *sid; 392 BusOwner *primary_owner; 393 394 retval = FALSE; 395 396 if (!_dbus_validate_bus_name (service_name, 0, 397 _dbus_string_get_length (service_name))) 398 { 399 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 400 "Requested bus name \"%s\" is not valid", 401 _dbus_string_get_const_data (service_name)); 402 403 _dbus_verbose ("Attempt to acquire invalid service name\n"); 404 405 goto out; 406 } 407 408 if (_dbus_string_get_byte (service_name, 0) == ':') 409 { 410 /* Not allowed; only base services can start with ':' */ 411 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 412 "Cannot acquire a service starting with ':' such as \"%s\"", 413 _dbus_string_get_const_data (service_name)); 414 415 _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"", 416 _dbus_string_get_const_data (service_name)); 417 418 goto out; 419 } 420 421 if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS)) 422 { 423 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 424 "Connection \"%s\" is not allowed to own the service \"%s\"because " 425 "it is reserved for D-Bus' use only", 426 bus_connection_is_active (connection) ? 427 bus_connection_get_name (connection) : 428 "(inactive)", 429 DBUS_SERVICE_DBUS); 430 goto out; 431 } 432 433 policy = bus_connection_get_policy (connection); 434 _dbus_assert (policy != NULL); 435 436 /* Note that if sid is #NULL then the bus's own context gets used 437 * in bus_connection_selinux_allows_acquire_service() 438 */ 439 sid = bus_selinux_id_table_lookup (registry->service_sid_table, 440 service_name); 441 442 if (!bus_selinux_allows_acquire_service (connection, sid, 443 _dbus_string_get_const_data (service_name), error)) 444 { 445 446 if (dbus_error_is_set (error) && 447 dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY)) 448 { 449 goto out; 450 } 451 452 dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED, 453 "Connection \"%s\" is not allowed to own the service \"%s\" due " 454 "to SELinux policy", 455 bus_connection_is_active (connection) ? 456 bus_connection_get_name (connection) : 457 "(inactive)", 458 _dbus_string_get_const_data (service_name)); 459 goto out; 460 } 461 462 if (!bus_client_policy_check_can_own (policy, 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 if (old_owner_conn == NULL) 513 { 514 _dbus_assert (primary_owner->conn == connection); 515 516 *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER; 517 } 518 else if (old_owner_conn == connection) 519 { 520 bus_owner_set_flags (primary_owner, flags); 521 *result = DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER; 522 } 523 else if (((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) && 524 !(bus_service_get_allow_replacement (service))) || 525 ((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) && 526 !(flags & DBUS_NAME_FLAG_REPLACE_EXISTING))) 527 { 528 DBusList *link; 529 BusOwner *temp_owner; 530 /* Since we can't be queued if we are already in the queue 531 remove us */ 532 533 link = _bus_service_find_owner_link (service, connection); 534 if (link != NULL) 535 { 536 _dbus_list_unlink (&service->owners, link); 537 temp_owner = (BusOwner *)link->data; 538 bus_owner_unref (temp_owner); 539 _dbus_list_free_link (link); 540 } 541 542 *result = DBUS_REQUEST_NAME_REPLY_EXISTS; 543 } 544 else if (!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) && 545 (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) || 546 !(bus_service_get_allow_replacement (service)))) 547 { 548 /* Queue the connection */ 549 if (!bus_service_add_owner (service, connection, 550 flags, 551 transaction, error)) 552 goto out; 553 554 *result = DBUS_REQUEST_NAME_REPLY_IN_QUEUE; 555 } 556 else 557 { 558 /* Replace the current owner */ 559 560 /* We enqueue the new owner and remove the first one because 561 * that will cause NameAcquired and NameLost messages to 562 * be sent. 563 */ 564 565 if (!bus_service_add_owner (service, connection, 566 flags, 567 transaction, error)) 568 goto out; 569 570 if (primary_owner->do_not_queue) 571 { 572 if (!bus_service_remove_owner (service, old_owner_conn, 573 transaction, error)) 574 goto out; 575 } 576 else 577 { 578 if (!bus_service_swap_owner (service, old_owner_conn, 579 transaction, error)) 580 goto out; 581 } 582 583 584 _dbus_assert (connection == bus_service_get_primary_owner (service)->conn); 585 *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER; 586 } 587 588 activation = bus_context_get_activation (registry->context); 589 retval = bus_activation_send_pending_auto_activation_messages (activation, 590 service, 591 transaction, 592 error); 593 594 out: 595 return retval; 596 } 597 598 dbus_bool_t 599 bus_registry_release_service (BusRegistry *registry, 600 DBusConnection *connection, 601 const DBusString *service_name, 602 dbus_uint32_t *result, 603 BusTransaction *transaction, 604 DBusError *error) 605 { 606 dbus_bool_t retval; 607 BusService *service; 608 609 retval = FALSE; 610 611 if (!_dbus_validate_bus_name (service_name, 0, 612 _dbus_string_get_length (service_name))) 613 { 614 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 615 "Given bus name \"%s\" is not valid", 616 _dbus_string_get_const_data (service_name)); 617 618 _dbus_verbose ("Attempt to release invalid service name\n"); 619 620 goto out; 621 } 622 623 if (_dbus_string_get_byte (service_name, 0) == ':') 624 { 625 /* Not allowed; the base service name cannot be created or released */ 626 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 627 "Cannot release a service starting with ':' such as \"%s\"", 628 _dbus_string_get_const_data (service_name)); 629 630 _dbus_verbose ("Attempt to release invalid base service name \"%s\"", 631 _dbus_string_get_const_data (service_name)); 632 633 goto out; 634 } 635 636 if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS)) 637 { 638 /* Not allowed; the base service name cannot be created or released */ 639 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 640 "Cannot release the %s service because it is owned by the bus", 641 DBUS_SERVICE_DBUS); 642 643 _dbus_verbose ("Attempt to release service name \"%s\"", 644 DBUS_SERVICE_DBUS); 645 646 goto out; 647 } 648 649 service = bus_registry_lookup (registry, service_name); 650 651 if (service == NULL) 652 { 653 *result = DBUS_RELEASE_NAME_REPLY_NON_EXISTENT; 654 } 655 else if (!bus_service_has_owner (service, connection)) 656 { 657 *result = DBUS_RELEASE_NAME_REPLY_NOT_OWNER; 658 } 659 else 660 { 661 if (!bus_service_remove_owner (service, connection, 662 transaction, error)) 663 goto out; 664 665 _dbus_assert (!bus_service_has_owner (service, connection)); 666 *result = DBUS_RELEASE_NAME_REPLY_RELEASED; 667 } 668 669 retval = TRUE; 670 671 out: 672 return retval; 673 } 674 675 dbus_bool_t 676 bus_registry_set_service_context_table (BusRegistry *registry, 677 DBusHashTable *table) 678 { 679 DBusHashTable *new_table; 680 DBusHashIter iter; 681 682 new_table = bus_selinux_id_table_new (); 683 if (!new_table) 684 return FALSE; 685 686 _dbus_hash_iter_init (table, &iter); 687 while (_dbus_hash_iter_next (&iter)) 688 { 689 const char *service = _dbus_hash_iter_get_string_key (&iter); 690 const char *context = _dbus_hash_iter_get_value (&iter); 691 692 if (!bus_selinux_id_table_insert (new_table, 693 service, 694 context)) 695 return FALSE; 696 } 697 698 if (registry->service_sid_table) 699 _dbus_hash_table_unref (registry->service_sid_table); 700 registry->service_sid_table = new_table; 701 return TRUE; 702 } 703 704 static void 705 bus_service_unlink_owner (BusService *service, 706 BusOwner *owner) 707 { 708 _dbus_list_remove_last (&service->owners, owner); 709 bus_owner_unref (owner); 710 } 711 712 static void 713 bus_service_unlink (BusService *service) 714 { 715 _dbus_assert (service->owners == NULL); 716 717 /* the service may not be in the hash, if 718 * the failure causing transaction cancel 719 * was in the right place, but that's OK 720 */ 721 _dbus_hash_table_remove_string (service->registry->service_hash, 722 service->name); 723 724 bus_service_unref (service); 725 } 726 727 static void 728 bus_service_relink (BusService *service, 729 DBusPreallocatedHash *preallocated) 730 { 731 _dbus_assert (service->owners == NULL); 732 _dbus_assert (preallocated != NULL); 733 734 _dbus_hash_table_insert_string_preallocated (service->registry->service_hash, 735 preallocated, 736 service->name, 737 service); 738 739 bus_service_ref (service); 740 } 741 742 /** 743 * Data used to represent an ownership cancellation in 744 * a bus transaction. 745 */ 746 typedef struct 747 { 748 BusOwner *owner; /**< the owner */ 749 BusService *service; /**< service to cancel ownership of */ 750 } OwnershipCancelData; 751 752 static void 753 cancel_ownership (void *data) 754 { 755 OwnershipCancelData *d = data; 756 757 /* We don't need to send messages notifying of these 758 * changes, since we're reverting something that was 759 * cancelled (effectively never really happened) 760 */ 761 bus_service_unlink_owner (d->service, d->owner); 762 763 if (d->service->owners == NULL) 764 bus_service_unlink (d->service); 765 } 766 767 static void 768 free_ownership_cancel_data (void *data) 769 { 770 OwnershipCancelData *d = data; 771 772 dbus_connection_unref (d->owner->conn); 773 bus_owner_unref (d->owner); 774 bus_service_unref (d->service); 775 776 dbus_free (d); 777 } 778 779 static dbus_bool_t 780 add_cancel_ownership_to_transaction (BusTransaction *transaction, 781 BusService *service, 782 BusOwner *owner) 783 { 784 OwnershipCancelData *d; 785 786 d = dbus_new (OwnershipCancelData, 1); 787 if (d == NULL) 788 return FALSE; 789 790 d->service = service; 791 d->owner = owner; 792 793 if (!bus_transaction_add_cancel_hook (transaction, cancel_ownership, d, 794 free_ownership_cancel_data)) 795 { 796 dbus_free (d); 797 return FALSE; 798 } 799 800 bus_service_ref (d->service); 801 bus_owner_ref (owner); 802 dbus_connection_ref (d->owner->conn); 803 804 return TRUE; 805 } 806 807 /* this function is self-cancelling if you cancel the transaction */ 808 dbus_bool_t 809 bus_service_add_owner (BusService *service, 810 DBusConnection *connection, 811 dbus_uint32_t flags, 812 BusTransaction *transaction, 813 DBusError *error) 814 { 815 BusOwner *bus_owner; 816 DBusList *bus_owner_link; 817 818 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 819 820 /* Send service acquired message first, OOM will result 821 * in cancelling the transaction 822 */ 823 if (service->owners == NULL) 824 { 825 if (!bus_driver_send_service_acquired (connection, service->name, transaction, error)) 826 return FALSE; 827 } 828 829 bus_owner_link = _bus_service_find_owner_link (service, connection); 830 831 if (bus_owner_link == NULL) 832 { 833 bus_owner = bus_owner_new (service, connection, flags); 834 if (bus_owner == NULL) 835 { 836 BUS_SET_OOM (error); 837 return FALSE; 838 } 839 840 bus_owner_set_flags (bus_owner, flags); 841 if (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) || service->owners == NULL) 842 { 843 if (!_dbus_list_append (&service->owners, 844 bus_owner)) 845 { 846 bus_owner_unref (bus_owner); 847 BUS_SET_OOM (error); 848 return FALSE; 849 } 850 } 851 else 852 { 853 if (!_dbus_list_insert_after (&service->owners, 854 _dbus_list_get_first_link (&service->owners), 855 bus_owner)) 856 { 857 bus_owner_unref (bus_owner); 858 BUS_SET_OOM (error); 859 return FALSE; 860 } 861 } 862 } 863 else 864 { 865 /* Update the link since we are already in the queue 866 * No need for operations that can produce OOM 867 */ 868 869 bus_owner = (BusOwner *) bus_owner_link->data; 870 if (flags & DBUS_NAME_FLAG_REPLACE_EXISTING) 871 { 872 DBusList *link; 873 _dbus_list_unlink (&service->owners, bus_owner_link); 874 link = _dbus_list_get_first_link (&service->owners); 875 _dbus_assert (link != NULL); 876 877 _dbus_list_insert_after_link (&service->owners, link, bus_owner_link); 878 } 879 880 bus_owner_set_flags (bus_owner, flags); 881 return TRUE; 882 } 883 884 if (!add_cancel_ownership_to_transaction (transaction, 885 service, 886 bus_owner)) 887 { 888 bus_service_unlink_owner (service, bus_owner); 889 BUS_SET_OOM (error); 890 return FALSE; 891 } 892 893 return TRUE; 894 } 895 896 typedef struct 897 { 898 BusOwner *owner; 899 BusService *service; 900 BusOwner *before_owner; /* restore to position before this connection in owners list */ 901 DBusList *owner_link; 902 DBusList *service_link; 903 DBusPreallocatedHash *hash_entry; 904 } OwnershipRestoreData; 905 906 static void 907 restore_ownership (void *data) 908 { 909 OwnershipRestoreData *d = data; 910 DBusList *link; 911 912 _dbus_assert (d->service_link != NULL); 913 _dbus_assert (d->owner_link != NULL); 914 915 if (d->service->owners == NULL) 916 { 917 _dbus_assert (d->hash_entry != NULL); 918 bus_service_relink (d->service, d->hash_entry); 919 } 920 else 921 { 922 _dbus_assert (d->hash_entry == NULL); 923 } 924 925 /* We don't need to send messages notifying of these 926 * changes, since we're reverting something that was 927 * cancelled (effectively never really happened) 928 */ 929 link = _dbus_list_get_first_link (&d->service->owners); 930 while (link != NULL) 931 { 932 if (link->data == d->before_owner) 933 break; 934 935 link = _dbus_list_get_next_link (&d->service->owners, link); 936 } 937 938 _dbus_list_insert_before_link (&d->service->owners, link, d->owner_link); 939 940 /* Note that removing then restoring this changes the order in which 941 * ServiceDeleted messages are sent on destruction of the 942 * connection. This should be OK as the only guarantee there is 943 * that the base service is destroyed last, and we never even 944 * tentatively remove the base service. 945 */ 946 bus_connection_add_owned_service_link (d->owner->conn, d->service_link); 947 948 d->hash_entry = NULL; 949 d->service_link = NULL; 950 d->owner_link = NULL; 951 } 952 953 static void 954 free_ownership_restore_data (void *data) 955 { 956 OwnershipRestoreData *d = data; 957 958 if (d->service_link) 959 _dbus_list_free_link (d->service_link); 960 if (d->owner_link) 961 _dbus_list_free_link (d->owner_link); 962 if (d->hash_entry) 963 _dbus_hash_table_free_preallocated_entry (d->service->registry->service_hash, 964 d->hash_entry); 965 966 dbus_connection_unref (d->owner->conn); 967 bus_owner_unref (d->owner); 968 bus_service_unref (d->service); 969 970 dbus_free (d); 971 } 972 973 static dbus_bool_t 974 add_restore_ownership_to_transaction (BusTransaction *transaction, 975 BusService *service, 976 BusOwner *owner) 977 { 978 OwnershipRestoreData *d; 979 DBusList *link; 980 981 d = dbus_new (OwnershipRestoreData, 1); 982 if (d == NULL) 983 return FALSE; 984 985 d->service = service; 986 d->owner = owner; 987 d->service_link = _dbus_list_alloc_link (service); 988 d->owner_link = _dbus_list_alloc_link (owner); 989 d->hash_entry = _dbus_hash_table_preallocate_entry (service->registry->service_hash); 990 991 bus_service_ref (d->service); 992 bus_owner_ref (d->owner); 993 dbus_connection_ref (d->owner->conn); 994 995 d->before_owner = NULL; 996 link = _dbus_list_get_first_link (&service->owners); 997 while (link != NULL) 998 { 999 if (link->data == owner) 1000 { 1001 link = _dbus_list_get_next_link (&service->owners, link); 1002 1003 if (link) 1004 d->before_owner = link->data; 1005 1006 break; 1007 } 1008 1009 link = _dbus_list_get_next_link (&service->owners, link); 1010 } 1011 1012 if (d->service_link == NULL || 1013 d->owner_link == NULL || 1014 d->hash_entry == NULL || 1015 !bus_transaction_add_cancel_hook (transaction, restore_ownership, d, 1016 free_ownership_restore_data)) 1017 { 1018 free_ownership_restore_data (d); 1019 return FALSE; 1020 } 1021 1022 return TRUE; 1023 } 1024 1025 dbus_bool_t 1026 bus_service_swap_owner (BusService *service, 1027 DBusConnection *connection, 1028 BusTransaction *transaction, 1029 DBusError *error) 1030 { 1031 DBusList *swap_link; 1032 BusOwner *primary_owner; 1033 1034 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1035 1036 /* We send out notifications before we do any work we 1037 * might have to undo if the notification-sending failed 1038 */ 1039 1040 /* Send service lost message */ 1041 primary_owner = bus_service_get_primary_owner (service); 1042 if (primary_owner == NULL || primary_owner->conn != connection) 1043 _dbus_assert_not_reached ("Tried to swap a non primary owner"); 1044 1045 1046 if (!bus_driver_send_service_lost (connection, service->name, 1047 transaction, error)) 1048 return FALSE; 1049 1050 if (service->owners == NULL) 1051 { 1052 _dbus_assert_not_reached ("Tried to swap owner of a service that has no owners"); 1053 } 1054 else if (_dbus_list_length_is_one (&service->owners)) 1055 { 1056 _dbus_assert_not_reached ("Tried to swap owner of a service that has no other owners in the queue"); 1057 } 1058 else 1059 { 1060 DBusList *link; 1061 BusOwner *new_owner; 1062 DBusConnection *new_owner_conn; 1063 link = _dbus_list_get_first_link (&service->owners); 1064 _dbus_assert (link != NULL); 1065 link = _dbus_list_get_next_link (&service->owners, link); 1066 _dbus_assert (link != NULL); 1067 1068 new_owner = (BusOwner *)link->data; 1069 new_owner_conn = new_owner->conn; 1070 1071 if (!bus_driver_send_service_owner_changed (service->name, 1072 bus_connection_get_name (connection), 1073 bus_connection_get_name (new_owner_conn), 1074 transaction, error)) 1075 return FALSE; 1076 1077 /* This will be our new owner */ 1078 if (!bus_driver_send_service_acquired (new_owner_conn, 1079 service->name, 1080 transaction, 1081 error)) 1082 return FALSE; 1083 } 1084 1085 if (!add_restore_ownership_to_transaction (transaction, service, primary_owner)) 1086 { 1087 BUS_SET_OOM (error); 1088 return FALSE; 1089 } 1090 1091 /* unlink the primary and make it the second link */ 1092 swap_link = _dbus_list_get_first_link (&service->owners); 1093 _dbus_list_unlink (&service->owners, swap_link); 1094 1095 _dbus_list_insert_after_link (&service->owners, 1096 _dbus_list_get_first_link (&service->owners), 1097 swap_link); 1098 1099 return TRUE; 1100 } 1101 1102 /* this function is self-cancelling if you cancel the transaction */ 1103 dbus_bool_t 1104 bus_service_remove_owner (BusService *service, 1105 DBusConnection *connection, 1106 BusTransaction *transaction, 1107 DBusError *error) 1108 { 1109 BusOwner *primary_owner; 1110 1111 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1112 1113 /* We send out notifications before we do any work we 1114 * might have to undo if the notification-sending failed 1115 */ 1116 1117 /* Send service lost message */ 1118 primary_owner = bus_service_get_primary_owner (service); 1119 if (primary_owner != NULL && primary_owner->conn == connection) 1120 { 1121 if (!bus_driver_send_service_lost (connection, service->name, 1122 transaction, error)) 1123 return FALSE; 1124 } 1125 else 1126 { 1127 /* if we are not the primary owner then just remove us from the queue */ 1128 DBusList *link; 1129 BusOwner *temp_owner; 1130 1131 link = _bus_service_find_owner_link (service, connection); 1132 _dbus_list_unlink (&service->owners, link); 1133 temp_owner = (BusOwner *)link->data; 1134 bus_owner_unref (temp_owner); 1135 _dbus_list_free_link (link); 1136 1137 return TRUE; 1138 } 1139 1140 if (service->owners == NULL) 1141 { 1142 _dbus_assert_not_reached ("Tried to remove owner of a service that has no owners"); 1143 } 1144 else if (_dbus_list_length_is_one (&service->owners)) 1145 { 1146 if (!bus_driver_send_service_owner_changed (service->name, 1147 bus_connection_get_name (connection), 1148 NULL, 1149 transaction, error)) 1150 return FALSE; 1151 } 1152 else 1153 { 1154 DBusList *link; 1155 BusOwner *new_owner; 1156 DBusConnection *new_owner_conn; 1157 link = _dbus_list_get_first_link (&service->owners); 1158 _dbus_assert (link != NULL); 1159 link = _dbus_list_get_next_link (&service->owners, link); 1160 _dbus_assert (link != NULL); 1161 1162 new_owner = (BusOwner *)link->data; 1163 new_owner_conn = new_owner->conn; 1164 1165 if (!bus_driver_send_service_owner_changed (service->name, 1166 bus_connection_get_name (connection), 1167 bus_connection_get_name (new_owner_conn), 1168 transaction, error)) 1169 return FALSE; 1170 1171 /* This will be our new owner */ 1172 if (!bus_driver_send_service_acquired (new_owner_conn, 1173 service->name, 1174 transaction, 1175 error)) 1176 return FALSE; 1177 } 1178 1179 if (!add_restore_ownership_to_transaction (transaction, service, primary_owner)) 1180 { 1181 BUS_SET_OOM (error); 1182 return FALSE; 1183 } 1184 1185 bus_service_unlink_owner (service, primary_owner); 1186 1187 if (service->owners == NULL) 1188 bus_service_unlink (service); 1189 1190 return TRUE; 1191 } 1192 1193 BusService * 1194 bus_service_ref (BusService *service) 1195 { 1196 _dbus_assert (service->refcount > 0); 1197 1198 service->refcount += 1; 1199 1200 return service; 1201 } 1202 1203 void 1204 bus_service_unref (BusService *service) 1205 { 1206 _dbus_assert (service->refcount > 0); 1207 1208 service->refcount -= 1; 1209 1210 if (service->refcount == 0) 1211 { 1212 _dbus_assert (service->owners == NULL); 1213 1214 dbus_free (service->name); 1215 _dbus_mem_pool_dealloc (service->registry->service_pool, service); 1216 } 1217 } 1218 1219 DBusConnection * 1220 bus_service_get_primary_owners_connection (BusService *service) 1221 { 1222 BusOwner *owner; 1223 1224 owner = bus_service_get_primary_owner (service); 1225 1226 if (owner != NULL) 1227 return owner->conn; 1228 else 1229 return NULL; 1230 } 1231 1232 BusOwner* 1233 bus_service_get_primary_owner (BusService *service) 1234 { 1235 return _dbus_list_get_first (&service->owners); 1236 } 1237 1238 const char* 1239 bus_service_get_name (BusService *service) 1240 { 1241 return service->name; 1242 } 1243 1244 dbus_bool_t 1245 bus_service_get_allow_replacement (BusService *service) 1246 { 1247 BusOwner *owner; 1248 DBusList *link; 1249 1250 _dbus_assert (service->owners != NULL); 1251 1252 link = _dbus_list_get_first_link (&service->owners); 1253 owner = (BusOwner *) link->data; 1254 1255 return owner->allow_replacement; 1256 } 1257 1258 dbus_bool_t 1259 bus_service_has_owner (BusService *service, 1260 DBusConnection *connection) 1261 { 1262 DBusList *link; 1263 1264 link = _bus_service_find_owner_link (service, connection); 1265 1266 if (link == NULL) 1267 return FALSE; 1268 else 1269 return TRUE; 1270 } 1271 1272 dbus_bool_t 1273 bus_service_list_queued_owners (BusService *service, 1274 DBusList **return_list, 1275 DBusError *error) 1276 { 1277 DBusList *link; 1278 1279 _dbus_assert (*return_list == NULL); 1280 1281 link = _dbus_list_get_first_link (&service->owners); 1282 _dbus_assert (link != NULL); 1283 1284 while (link != NULL) 1285 { 1286 BusOwner *owner; 1287 const char *uname; 1288 1289 owner = (BusOwner *) link->data; 1290 uname = bus_connection_get_name (owner->conn); 1291 1292 if (!_dbus_list_append (return_list, (char *)uname)) 1293 goto oom; 1294 1295 link = _dbus_list_get_next_link (&service->owners, link); 1296 } 1297 1298 return TRUE; 1299 1300 oom: 1301 _dbus_list_clear (return_list); 1302 BUS_SET_OOM (error); 1303 return FALSE; 1304 } 1305
