1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2/* activation.c Activation of services 3 * 4 * Copyright (C) 2003 CodeFactory AB 5 * Copyright (C) 2003 Red Hat, Inc. 6 * Copyright (C) 2004 Imendio HB 7 * 8 * Licensed under the Academic Free License version 2.1 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 * 24 */ 25 26#include <config.h> 27#include "activation.h" 28#include "activation-exit-codes.h" 29#include "desktop-file.h" 30#include "dispatch.h" 31#include "services.h" 32#include "test.h" 33#include "utils.h" 34#include <dbus/dbus-internals.h> 35#include <dbus/dbus-hash.h> 36#include <dbus/dbus-list.h> 37#include <dbus/dbus-shell.h> 38#include <dbus/dbus-spawn.h> 39#include <dbus/dbus-timeout.h> 40#include <dbus/dbus-sysdeps.h> 41#ifdef HAVE_ERRNO_H 42#include <errno.h> 43#endif 44 45struct BusActivation 46{ 47 int refcount; 48 DBusHashTable *entries; 49 DBusHashTable *pending_activations; 50 char *server_address; 51 BusContext *context; 52 int n_pending_activations; /**< This is in fact the number of BusPendingActivationEntry, 53 * i.e. number of pending activation requests, not pending 54 * activations per se 55 */ 56 DBusHashTable *directories; 57 DBusHashTable *environment; 58}; 59 60typedef struct 61{ 62 int refcount; 63 char *dir_c; 64 DBusHashTable *entries; 65} BusServiceDirectory; 66 67typedef struct 68{ 69 int refcount; 70 char *name; 71 char *exec; 72 char *user; 73 char *systemd_service; 74 unsigned long mtime; 75 BusServiceDirectory *s_dir; 76 char *filename; 77} BusActivationEntry; 78 79typedef struct BusPendingActivationEntry BusPendingActivationEntry; 80 81struct BusPendingActivationEntry 82{ 83 DBusMessage *activation_message; 84 DBusConnection *connection; 85 86 dbus_bool_t auto_activation; 87}; 88 89typedef struct 90{ 91 int refcount; 92 BusActivation *activation; 93 char *service_name; 94 char *exec; 95 char *systemd_service; 96 DBusList *entries; 97 int n_entries; 98 DBusBabysitter *babysitter; 99 DBusTimeout *timeout; 100 unsigned int timeout_added : 1; 101} BusPendingActivation; 102 103#if 0 104static BusServiceDirectory * 105bus_service_directory_ref (BusServiceDirectory *dir) 106{ 107 _dbus_assert (dir->refcount); 108 109 dir->refcount++; 110 111 return dir; 112} 113#endif 114 115static void 116bus_service_directory_unref (BusServiceDirectory *dir) 117{ 118 if (dir == NULL) 119 return; 120 121 _dbus_assert (dir->refcount > 0); 122 dir->refcount--; 123 124 if (dir->refcount > 0) 125 return; 126 127 if (dir->entries) 128 _dbus_hash_table_unref (dir->entries); 129 130 dbus_free (dir->dir_c); 131 dbus_free (dir); 132} 133 134static void 135bus_pending_activation_entry_free (BusPendingActivationEntry *entry) 136{ 137 if (entry->activation_message) 138 dbus_message_unref (entry->activation_message); 139 140 if (entry->connection) 141 dbus_connection_unref (entry->connection); 142 143 dbus_free (entry); 144} 145 146static void 147handle_timeout_callback (DBusTimeout *timeout, 148 void *data) 149{ 150 BusPendingActivation *pending_activation = data; 151 152 while (!dbus_timeout_handle (pending_activation->timeout)) 153 _dbus_wait_for_memory (); 154} 155 156static BusPendingActivation * 157bus_pending_activation_ref (BusPendingActivation *pending_activation) 158{ 159 _dbus_assert (pending_activation->refcount > 0); 160 pending_activation->refcount += 1; 161 162 return pending_activation; 163} 164 165static void 166bus_pending_activation_unref (BusPendingActivation *pending_activation) 167{ 168 DBusList *link; 169 170 if (pending_activation == NULL) /* hash table requires this */ 171 return; 172 173 _dbus_assert (pending_activation->refcount > 0); 174 pending_activation->refcount -= 1; 175 176 if (pending_activation->refcount > 0) 177 return; 178 179 if (pending_activation->timeout_added) 180 { 181 _dbus_loop_remove_timeout (bus_context_get_loop (pending_activation->activation->context), 182 pending_activation->timeout, 183 handle_timeout_callback, pending_activation); 184 pending_activation->timeout_added = FALSE; 185 } 186 187 if (pending_activation->timeout) 188 _dbus_timeout_unref (pending_activation->timeout); 189 190 if (pending_activation->babysitter) 191 { 192 if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter, 193 NULL, NULL, NULL, 194 pending_activation->babysitter, 195 NULL)) 196 _dbus_assert_not_reached ("setting watch functions to NULL failed"); 197 198 _dbus_babysitter_unref (pending_activation->babysitter); 199 } 200 201 dbus_free (pending_activation->service_name); 202 dbus_free (pending_activation->exec); 203 dbus_free (pending_activation->systemd_service); 204 205 link = _dbus_list_get_first_link (&pending_activation->entries); 206 207 while (link != NULL) 208 { 209 BusPendingActivationEntry *entry = link->data; 210 211 bus_pending_activation_entry_free (entry); 212 213 link = _dbus_list_get_next_link (&pending_activation->entries, link); 214 } 215 _dbus_list_clear (&pending_activation->entries); 216 217 pending_activation->activation->n_pending_activations -= 218 pending_activation->n_entries; 219 220 _dbus_assert (pending_activation->activation->n_pending_activations >= 0); 221 222 dbus_free (pending_activation); 223} 224 225static BusActivationEntry * 226bus_activation_entry_ref (BusActivationEntry *entry) 227{ 228 _dbus_assert (entry->refcount > 0); 229 entry->refcount++; 230 231 return entry; 232} 233 234static void 235bus_activation_entry_unref (BusActivationEntry *entry) 236{ 237 if (entry == NULL) /* hash table requires this */ 238 return; 239 240 _dbus_assert (entry->refcount > 0); 241 entry->refcount--; 242 243 if (entry->refcount > 0) 244 return; 245 246 dbus_free (entry->name); 247 dbus_free (entry->exec); 248 dbus_free (entry->user); 249 dbus_free (entry->filename); 250 dbus_free (entry->systemd_service); 251 252 dbus_free (entry); 253} 254 255static dbus_bool_t 256update_desktop_file_entry (BusActivation *activation, 257 BusServiceDirectory *s_dir, 258 DBusString *filename, 259 BusDesktopFile *desktop_file, 260 DBusError *error) 261{ 262 char *name, *exec, *user, *exec_tmp, *systemd_service; 263 BusActivationEntry *entry; 264 DBusStat stat_buf; 265 DBusString file_path; 266 DBusError tmp_error; 267 268 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 269 270 name = NULL; 271 exec = NULL; 272 user = NULL; 273 exec_tmp = NULL; 274 entry = NULL; 275 systemd_service = NULL; 276 277 dbus_error_init (&tmp_error); 278 279 if (!_dbus_string_init (&file_path)) 280 { 281 BUS_SET_OOM (error); 282 return FALSE; 283 } 284 285 if (!_dbus_string_append (&file_path, s_dir->dir_c) || 286 !_dbus_concat_dir_and_file (&file_path, filename)) 287 { 288 BUS_SET_OOM (error); 289 goto failed; 290 } 291 292 if (!_dbus_stat (&file_path, &stat_buf, NULL)) 293 { 294 dbus_set_error (error, DBUS_ERROR_FAILED, 295 "Can't stat the service file\n"); 296 goto failed; 297 } 298 299 if (!bus_desktop_file_get_string (desktop_file, 300 DBUS_SERVICE_SECTION, 301 DBUS_SERVICE_NAME, 302 &name, 303 error)) 304 goto failed; 305 306 if (!bus_desktop_file_get_string (desktop_file, 307 DBUS_SERVICE_SECTION, 308 DBUS_SERVICE_EXEC, 309 &exec_tmp, 310 error)) 311 goto failed; 312 313 /* user is not _required_ unless we are using system activation */ 314 if (!bus_desktop_file_get_string (desktop_file, 315 DBUS_SERVICE_SECTION, 316 DBUS_SERVICE_USER, 317 &user, &tmp_error)) 318 { 319 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); 320 /* if we got OOM, then exit */ 321 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 322 { 323 dbus_move_error (&tmp_error, error); 324 goto failed; 325 } 326 else 327 { 328 /* if we have error because we didn't find anything then continue */ 329 dbus_error_free (&tmp_error); 330 dbus_free (user); 331 user = NULL; 332 } 333 } 334 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 335 336 /* systemd service is never required */ 337 if (!bus_desktop_file_get_string (desktop_file, 338 DBUS_SERVICE_SECTION, 339 DBUS_SERVICE_SYSTEMD_SERVICE, 340 &systemd_service, &tmp_error)) 341 { 342 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); 343 /* if we got OOM, then exit */ 344 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 345 { 346 dbus_move_error (&tmp_error, error); 347 goto failed; 348 } 349 else 350 { 351 /* if we have error because we didn't find anything then continue */ 352 dbus_error_free (&tmp_error); 353 dbus_free (systemd_service); 354 systemd_service = NULL; 355 } 356 } 357 358 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 359 360 entry = _dbus_hash_table_lookup_string (s_dir->entries, 361 _dbus_string_get_const_data (filename)); 362 363 exec = strdup (_dbus_replace_install_prefix (exec_tmp)); 364 365 if (entry == NULL) /* New file */ 366 { 367 /* FIXME we need a better-defined algorithm for which service file to 368 * pick than "whichever one is first in the directory listing" 369 */ 370 if (_dbus_hash_table_lookup_string (activation->entries, name)) 371 { 372 dbus_set_error (error, DBUS_ERROR_FAILED, 373 "Service %s already exists in activation entry list\n", name); 374 goto failed; 375 } 376 377 entry = dbus_new0 (BusActivationEntry, 1); 378 if (entry == NULL) 379 { 380 BUS_SET_OOM (error); 381 goto failed; 382 } 383 384 entry->name = name; 385 entry->exec = exec; 386 entry->user = user; 387 entry->systemd_service = systemd_service; 388 entry->refcount = 1; 389 390 entry->s_dir = s_dir; 391 entry->filename = _dbus_strdup (_dbus_string_get_const_data (filename)); 392 if (!entry->filename) 393 { 394 BUS_SET_OOM (error); 395 goto failed; 396 } 397 398 if (!_dbus_hash_table_insert_string (activation->entries, entry->name, bus_activation_entry_ref (entry))) 399 { 400 BUS_SET_OOM (error); 401 goto failed; 402 } 403 404 if (!_dbus_hash_table_insert_string (s_dir->entries, entry->filename, bus_activation_entry_ref (entry))) 405 { 406 /* Revert the insertion in the entries table */ 407 _dbus_hash_table_remove_string (activation->entries, entry->name); 408 BUS_SET_OOM (error); 409 goto failed; 410 } 411 412 _dbus_verbose ("Added \"%s\" to list of services\n", entry->name); 413 } 414 else /* Just update the entry */ 415 { 416 bus_activation_entry_ref (entry); 417 _dbus_hash_table_remove_string (activation->entries, entry->name); 418 419 if (_dbus_hash_table_lookup_string (activation->entries, name)) 420 { 421 _dbus_verbose ("The new service name \"%s\" of service file \"%s\" already in cache, ignoring\n", 422 name, _dbus_string_get_const_data (&file_path)); 423 goto failed; 424 } 425 426 dbus_free (entry->name); 427 dbus_free (entry->exec); 428 dbus_free (entry->user); 429 dbus_free (entry->systemd_service); 430 entry->systemd_service = systemd_service; 431 entry->name = name; 432 entry->exec = exec; 433 entry->user = user; 434 if (!_dbus_hash_table_insert_string (activation->entries, 435 entry->name, bus_activation_entry_ref(entry))) 436 { 437 BUS_SET_OOM (error); 438 /* Also remove path to entries hash since we want this in sync with 439 * the entries hash table */ 440 _dbus_hash_table_remove_string (entry->s_dir->entries, 441 entry->filename); 442 bus_activation_entry_unref (entry); 443 return FALSE; 444 } 445 } 446 447 entry->mtime = stat_buf.mtime; 448 449 _dbus_string_free (&file_path); 450 bus_activation_entry_unref (entry); 451 452 return TRUE; 453 454failed: 455 dbus_free (name); 456 dbus_free (exec_tmp); 457 dbus_free (user); 458 dbus_free (systemd_service); 459 _dbus_string_free (&file_path); 460 461 if (entry) 462 bus_activation_entry_unref (entry); 463 464 return FALSE; 465} 466 467static dbus_bool_t 468check_service_file (BusActivation *activation, 469 BusActivationEntry *entry, 470 BusActivationEntry **updated_entry, 471 DBusError *error) 472{ 473 DBusStat stat_buf; 474 dbus_bool_t retval; 475 BusActivationEntry *tmp_entry; 476 DBusString file_path; 477 DBusString filename; 478 479 retval = TRUE; 480 tmp_entry = entry; 481 482 _dbus_string_init_const (&filename, entry->filename); 483 484 if (!_dbus_string_init (&file_path)) 485 { 486 BUS_SET_OOM (error); 487 return FALSE; 488 } 489 490 if (!_dbus_string_append (&file_path, entry->s_dir->dir_c) || 491 !_dbus_concat_dir_and_file (&file_path, &filename)) 492 { 493 BUS_SET_OOM (error); 494 retval = FALSE; 495 goto out; 496 } 497 498 if (!_dbus_stat (&file_path, &stat_buf, NULL)) 499 { 500 _dbus_verbose ("****** Can't stat file \"%s\", removing from cache\n", 501 _dbus_string_get_const_data (&file_path)); 502 503 _dbus_hash_table_remove_string (activation->entries, entry->name); 504 _dbus_hash_table_remove_string (entry->s_dir->entries, entry->filename); 505 506 tmp_entry = NULL; 507 retval = TRUE; 508 goto out; 509 } 510 else 511 { 512 if (stat_buf.mtime > entry->mtime) 513 { 514 BusDesktopFile *desktop_file; 515 DBusError tmp_error; 516 517 dbus_error_init (&tmp_error); 518 519 desktop_file = bus_desktop_file_load (&file_path, &tmp_error); 520 if (desktop_file == NULL) 521 { 522 _dbus_verbose ("Could not load %s: %s\n", 523 _dbus_string_get_const_data (&file_path), 524 tmp_error.message); 525 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 526 { 527 dbus_move_error (&tmp_error, error); 528 retval = FALSE; 529 goto out; 530 } 531 dbus_error_free (&tmp_error); 532 retval = TRUE; 533 goto out; 534 } 535 536 /* @todo We can return OOM or a DBUS_ERROR_FAILED error 537 * Handle these both better 538 */ 539 if (!update_desktop_file_entry (activation, entry->s_dir, &filename, desktop_file, &tmp_error)) 540 { 541 bus_desktop_file_free (desktop_file); 542 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 543 { 544 dbus_move_error (&tmp_error, error); 545 retval = FALSE; 546 goto out; 547 } 548 dbus_error_free (&tmp_error); 549 retval = TRUE; 550 goto out; 551 } 552 553 bus_desktop_file_free (desktop_file); 554 retval = TRUE; 555 } 556 } 557 558out: 559 _dbus_string_free (&file_path); 560 561 if (updated_entry != NULL) 562 *updated_entry = tmp_entry; 563 return retval; 564} 565 566 567/* warning: this doesn't fully "undo" itself on failure, i.e. doesn't strip 568 * hash entries it already added. 569 */ 570static dbus_bool_t 571update_directory (BusActivation *activation, 572 BusServiceDirectory *s_dir, 573 DBusError *error) 574{ 575 DBusDirIter *iter; 576 DBusString dir, filename; 577 BusDesktopFile *desktop_file; 578 DBusError tmp_error; 579 dbus_bool_t retval; 580 BusActivationEntry *entry; 581 DBusString full_path; 582 583 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 584 585 iter = NULL; 586 desktop_file = NULL; 587 588 _dbus_string_init_const (&dir, s_dir->dir_c); 589 590 if (!_dbus_string_init (&filename)) 591 { 592 BUS_SET_OOM (error); 593 return FALSE; 594 } 595 596 if (!_dbus_string_init (&full_path)) 597 { 598 BUS_SET_OOM (error); 599 _dbus_string_free (&filename); 600 return FALSE; 601 } 602 603 retval = FALSE; 604 605 /* from this point it's safe to "goto out" */ 606 607 iter = _dbus_directory_open (&dir, error); 608 if (iter == NULL) 609 { 610 _dbus_verbose ("Failed to open directory %s: %s\n", 611 s_dir->dir_c, 612 error ? error->message : "unknown"); 613 goto out; 614 } 615 616 /* Now read the files */ 617 dbus_error_init (&tmp_error); 618 while (_dbus_directory_get_next_file (iter, &filename, &tmp_error)) 619 { 620 _dbus_assert (!dbus_error_is_set (&tmp_error)); 621 622 _dbus_string_set_length (&full_path, 0); 623 624 if (!_dbus_string_ends_with_c_str (&filename, ".service")) 625 { 626 _dbus_verbose ("Skipping non-.service file %s\n", 627 _dbus_string_get_const_data (&filename)); 628 continue; 629 } 630 631 entry = _dbus_hash_table_lookup_string (s_dir->entries, _dbus_string_get_const_data (&filename)); 632 if (entry) /* Already has this service file in the cache */ 633 { 634 if (!check_service_file (activation, entry, NULL, error)) 635 goto out; 636 637 continue; 638 } 639 640 if (!_dbus_string_append (&full_path, s_dir->dir_c) || 641 !_dbus_concat_dir_and_file (&full_path, &filename)) 642 { 643 BUS_SET_OOM (error); 644 goto out; 645 } 646 647 /* New file */ 648 desktop_file = bus_desktop_file_load (&full_path, &tmp_error); 649 if (desktop_file == NULL) 650 { 651 _dbus_verbose ("Could not load %s: %s\n", 652 _dbus_string_get_const_data (&full_path), 653 tmp_error.message); 654 655 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 656 { 657 dbus_move_error (&tmp_error, error); 658 goto out; 659 } 660 661 dbus_error_free (&tmp_error); 662 continue; 663 } 664 665 /* @todo We can return OOM or a DBUS_ERROR_FAILED error 666 * Handle these both better 667 */ 668 if (!update_desktop_file_entry (activation, s_dir, &filename, desktop_file, &tmp_error)) 669 { 670 bus_desktop_file_free (desktop_file); 671 desktop_file = NULL; 672 673 _dbus_verbose ("Could not add %s to activation entry list: %s\n", 674 _dbus_string_get_const_data (&full_path), tmp_error.message); 675 676 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 677 { 678 dbus_move_error (&tmp_error, error); 679 goto out; 680 } 681 682 dbus_error_free (&tmp_error); 683 continue; 684 } 685 else 686 { 687 bus_desktop_file_free (desktop_file); 688 desktop_file = NULL; 689 continue; 690 } 691 } 692 693 if (dbus_error_is_set (&tmp_error)) 694 { 695 dbus_move_error (&tmp_error, error); 696 goto out; 697 } 698 699 retval = TRUE; 700 701 out: 702 if (!retval) 703 _DBUS_ASSERT_ERROR_IS_SET (error); 704 else 705 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 706 707 if (iter != NULL) 708 _dbus_directory_close (iter); 709 _dbus_string_free (&filename); 710 _dbus_string_free (&full_path); 711 712 return retval; 713} 714 715static dbus_bool_t 716populate_environment (BusActivation *activation) 717{ 718 DBusString key; 719 DBusString value; 720 int i; 721 char **environment; 722 dbus_bool_t retval = FALSE; 723 724 environment = _dbus_get_environment (); 725 726 if (environment == NULL) 727 return FALSE; 728 729 if (!_dbus_string_init (&key)) 730 { 731 dbus_free_string_array (environment); 732 return FALSE; 733 } 734 735 if (!_dbus_string_init (&value)) 736 { 737 _dbus_string_free (&key); 738 dbus_free_string_array (environment); 739 return FALSE; 740 } 741 742 for (i = 0; environment[i] != NULL; i++) 743 { 744 if (!_dbus_string_append (&key, environment[i])) 745 break; 746 747 if (_dbus_string_split_on_byte (&key, '=', &value)) 748 { 749 char *hash_key, *hash_value; 750 751 if (!_dbus_string_steal_data (&key, &hash_key)) 752 break; 753 754 if (!_dbus_string_steal_data (&value, &hash_value)) 755 break; 756 757 if (!_dbus_hash_table_insert_string (activation->environment, 758 hash_key, hash_value)) 759 break; 760 } 761 _dbus_string_set_length (&key, 0); 762 _dbus_string_set_length (&value, 0); 763 } 764 765 if (environment[i] != NULL) 766 goto out; 767 768 retval = TRUE; 769out: 770 771 _dbus_string_free (&key); 772 _dbus_string_free (&value); 773 dbus_free_string_array (environment); 774 775 return retval; 776} 777 778dbus_bool_t 779bus_activation_reload (BusActivation *activation, 780 const DBusString *address, 781 DBusList **directories, 782 DBusError *error) 783{ 784 DBusList *link; 785 char *dir; 786 787 if (activation->server_address != NULL) 788 dbus_free (activation->server_address); 789 if (!_dbus_string_copy_data (address, &activation->server_address)) 790 { 791 BUS_SET_OOM (error); 792 goto failed; 793 } 794 795 if (activation->entries != NULL) 796 _dbus_hash_table_unref (activation->entries); 797 activation->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, 798 (DBusFreeFunction)bus_activation_entry_unref); 799 if (activation->entries == NULL) 800 { 801 BUS_SET_OOM (error); 802 goto failed; 803 } 804 805 if (activation->directories != NULL) 806 _dbus_hash_table_unref (activation->directories); 807 activation->directories = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, 808 (DBusFreeFunction)bus_service_directory_unref); 809 810 if (activation->directories == NULL) 811 { 812 BUS_SET_OOM (error); 813 goto failed; 814 } 815 816 link = _dbus_list_get_first_link (directories); 817 while (link != NULL) 818 { 819 BusServiceDirectory *s_dir; 820 821 dir = _dbus_strdup ((const char *) link->data); 822 if (!dir) 823 { 824 BUS_SET_OOM (error); 825 goto failed; 826 } 827 828 s_dir = dbus_new0 (BusServiceDirectory, 1); 829 if (!s_dir) 830 { 831 dbus_free (dir); 832 BUS_SET_OOM (error); 833 goto failed; 834 } 835 836 s_dir->refcount = 1; 837 s_dir->dir_c = dir; 838 839 s_dir->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, 840 (DBusFreeFunction)bus_activation_entry_unref); 841 842 if (!s_dir->entries) 843 { 844 bus_service_directory_unref (s_dir); 845 BUS_SET_OOM (error); 846 goto failed; 847 } 848 849 if (!_dbus_hash_table_insert_string (activation->directories, s_dir->dir_c, s_dir)) 850 { 851 bus_service_directory_unref (s_dir); 852 BUS_SET_OOM (error); 853 goto failed; 854 } 855 856 /* only fail on OOM, it is ok if we can't read the directory */ 857 if (!update_directory (activation, s_dir, error)) 858 { 859 if (dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY)) 860 goto failed; 861 else 862 dbus_error_free (error); 863 } 864 865 link = _dbus_list_get_next_link (directories, link); 866 } 867 868 return TRUE; 869 failed: 870 return FALSE; 871} 872 873BusActivation* 874bus_activation_new (BusContext *context, 875 const DBusString *address, 876 DBusList **directories, 877 DBusError *error) 878{ 879 BusActivation *activation; 880 DBusList *link; 881 char *dir; 882 883 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 884 885 activation = dbus_new0 (BusActivation, 1); 886 if (activation == NULL) 887 { 888 BUS_SET_OOM (error); 889 return NULL; 890 } 891 892 activation->refcount = 1; 893 activation->context = context; 894 activation->n_pending_activations = 0; 895 896 if (!bus_activation_reload (activation, address, directories, error)) 897 goto failed; 898 899 /* Initialize this hash table once, we don't want to lose pending 900 * activations on reload. */ 901 activation->pending_activations = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, 902 (DBusFreeFunction)bus_pending_activation_unref); 903 904 if (activation->pending_activations == NULL) 905 { 906 BUS_SET_OOM (error); 907 goto failed; 908 } 909 910 activation->environment = _dbus_hash_table_new (DBUS_HASH_STRING, 911 (DBusFreeFunction) dbus_free, 912 (DBusFreeFunction) dbus_free); 913 914 if (activation->environment == NULL) 915 { 916 BUS_SET_OOM (error); 917 goto failed; 918 } 919 920 if (!populate_environment (activation)) 921 { 922 BUS_SET_OOM (error); 923 goto failed; 924 } 925 926 return activation; 927 928 failed: 929 bus_activation_unref (activation); 930 return NULL; 931} 932 933BusActivation * 934bus_activation_ref (BusActivation *activation) 935{ 936 _dbus_assert (activation->refcount > 0); 937 938 activation->refcount += 1; 939 940 return activation; 941} 942 943void 944bus_activation_unref (BusActivation *activation) 945{ 946 _dbus_assert (activation->refcount > 0); 947 948 activation->refcount -= 1; 949 950 if (activation->refcount > 0) 951 return; 952 953 dbus_free (activation->server_address); 954 if (activation->entries) 955 _dbus_hash_table_unref (activation->entries); 956 if (activation->pending_activations) 957 _dbus_hash_table_unref (activation->pending_activations); 958 if (activation->directories) 959 _dbus_hash_table_unref (activation->directories); 960 if (activation->environment) 961 _dbus_hash_table_unref (activation->environment); 962 963 dbus_free (activation); 964} 965 966static dbus_bool_t 967add_bus_environment (BusActivation *activation, 968 DBusError *error) 969{ 970 const char *type; 971 972 if (!bus_activation_set_environment_variable (activation, 973 "DBUS_STARTER_ADDRESS", 974 activation->server_address, 975 error)) 976 return FALSE; 977 978 type = bus_context_get_type (activation->context); 979 if (type != NULL) 980 { 981 if (!bus_activation_set_environment_variable (activation, 982 "DBUS_STARTER_BUS_TYPE", type, 983 error)) 984 return FALSE; 985 986 if (strcmp (type, "session") == 0) 987 { 988 if (!bus_activation_set_environment_variable (activation, 989 "DBUS_SESSION_BUS_ADDRESS", 990 activation->server_address, 991 error)) 992 return FALSE; 993 } 994 else if (strcmp (type, "system") == 0) 995 { 996 if (!bus_activation_set_environment_variable (activation, 997 "DBUS_SYSTEM_BUS_ADDRESS", 998 activation->server_address, 999 error)) 1000 return FALSE; 1001 } 1002 } 1003 1004 return TRUE; 1005} 1006 1007typedef struct 1008{ 1009 BusPendingActivation *pending_activation; 1010 DBusPreallocatedHash *hash_entry; 1011} RestorePendingData; 1012 1013static void 1014restore_pending (void *data) 1015{ 1016 RestorePendingData *d = data; 1017 1018 _dbus_assert (d->pending_activation != NULL); 1019 _dbus_assert (d->hash_entry != NULL); 1020 1021 _dbus_verbose ("Restoring pending activation for service %s, has timeout = %d\n", 1022 d->pending_activation->service_name, 1023 d->pending_activation->timeout_added); 1024 1025 _dbus_hash_table_insert_string_preallocated (d->pending_activation->activation->pending_activations, 1026 d->hash_entry, 1027 d->pending_activation->service_name, d->pending_activation); 1028 1029 bus_pending_activation_ref (d->pending_activation); 1030 1031 d->hash_entry = NULL; 1032} 1033 1034static void 1035free_pending_restore_data (void *data) 1036{ 1037 RestorePendingData *d = data; 1038 1039 if (d->hash_entry) 1040 _dbus_hash_table_free_preallocated_entry (d->pending_activation->activation->pending_activations, 1041 d->hash_entry); 1042 1043 bus_pending_activation_unref (d->pending_activation); 1044 1045 dbus_free (d); 1046} 1047 1048static dbus_bool_t 1049add_restore_pending_to_transaction (BusTransaction *transaction, 1050 BusPendingActivation *pending_activation) 1051{ 1052 RestorePendingData *d; 1053 1054 d = dbus_new (RestorePendingData, 1); 1055 if (d == NULL) 1056 return FALSE; 1057 1058 d->pending_activation = pending_activation; 1059 d->hash_entry = _dbus_hash_table_preallocate_entry (d->pending_activation->activation->pending_activations); 1060 1061 bus_pending_activation_ref (d->pending_activation); 1062 1063 if (d->hash_entry == NULL || 1064 !bus_transaction_add_cancel_hook (transaction, restore_pending, d, 1065 free_pending_restore_data)) 1066 { 1067 free_pending_restore_data (d); 1068 return FALSE; 1069 } 1070 1071 _dbus_verbose ("Saved pending activation to be restored if the transaction fails\n"); 1072 1073 return TRUE; 1074} 1075 1076dbus_bool_t 1077bus_activation_service_created (BusActivation *activation, 1078 const char *service_name, 1079 BusTransaction *transaction, 1080 DBusError *error) 1081{ 1082 BusPendingActivation *pending_activation; 1083 DBusMessage *message; 1084 DBusList *link; 1085 1086 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1087 1088 /* Check if it's a pending activation */ 1089 pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, service_name); 1090 1091 if (!pending_activation) 1092 return TRUE; 1093 1094 link = _dbus_list_get_first_link (&pending_activation->entries); 1095 while (link != NULL) 1096 { 1097 BusPendingActivationEntry *entry = link->data; 1098 DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link); 1099 1100 if (dbus_connection_get_is_connected (entry->connection)) 1101 { 1102 /* Only send activation replies to regular activation requests. */ 1103 if (!entry->auto_activation) 1104 { 1105 dbus_uint32_t result; 1106 1107 message = dbus_message_new_method_return (entry->activation_message); 1108 if (!message) 1109 { 1110 BUS_SET_OOM (error); 1111 goto error; 1112 } 1113 1114 result = DBUS_START_REPLY_SUCCESS; 1115 1116 if (!dbus_message_append_args (message, 1117 DBUS_TYPE_UINT32, &result, 1118 DBUS_TYPE_INVALID)) 1119 { 1120 dbus_message_unref (message); 1121 BUS_SET_OOM (error); 1122 goto error; 1123 } 1124 1125 if (!bus_transaction_send_from_driver (transaction, entry->connection, message)) 1126 { 1127 dbus_message_unref (message); 1128 BUS_SET_OOM (error); 1129 goto error; 1130 } 1131 1132 dbus_message_unref (message); 1133 } 1134 } 1135 1136 link = next; 1137 } 1138 1139 return TRUE; 1140 1141 error: 1142 return FALSE; 1143} 1144 1145dbus_bool_t 1146bus_activation_send_pending_auto_activation_messages (BusActivation *activation, 1147 BusService *service, 1148 BusTransaction *transaction, 1149 DBusError *error) 1150{ 1151 BusPendingActivation *pending_activation; 1152 DBusList *link; 1153 1154 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1155 1156 /* Check if it's a pending activation */ 1157 pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, 1158 bus_service_get_name (service)); 1159 1160 if (!pending_activation) 1161 return TRUE; 1162 1163 link = _dbus_list_get_first_link (&pending_activation->entries); 1164 while (link != NULL) 1165 { 1166 BusPendingActivationEntry *entry = link->data; 1167 DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link); 1168 1169 if (entry->auto_activation && dbus_connection_get_is_connected (entry->connection)) 1170 { 1171 DBusConnection *addressed_recipient; 1172 1173 addressed_recipient = bus_service_get_primary_owners_connection (service); 1174 1175 /* Resume dispatching where we left off in bus_dispatch() */ 1176 if (!bus_dispatch_matches (transaction, 1177 entry->connection, 1178 addressed_recipient, 1179 entry->activation_message, error)) 1180 goto error; 1181 } 1182 1183 link = next; 1184 } 1185 1186 if (!add_restore_pending_to_transaction (transaction, pending_activation)) 1187 { 1188 _dbus_verbose ("Could not add cancel hook to transaction to revert removing pending activation\n"); 1189 BUS_SET_OOM (error); 1190 goto error; 1191 } 1192 1193 _dbus_hash_table_remove_string (activation->pending_activations, bus_service_get_name (service)); 1194 1195 return TRUE; 1196 1197 error: 1198 return FALSE; 1199} 1200 1201/** 1202 * FIXME @todo the error messages here would ideally be preallocated 1203 * so we don't need to allocate memory to send them. 1204 * Using the usual tactic, prealloc an OOM message, then 1205 * if we can't alloc the real error send the OOM error instead. 1206 */ 1207static dbus_bool_t 1208try_send_activation_failure (BusPendingActivation *pending_activation, 1209 const DBusError *how) 1210{ 1211 BusActivation *activation; 1212 DBusList *link; 1213 BusTransaction *transaction; 1214 1215 activation = pending_activation->activation; 1216 1217 transaction = bus_transaction_new (activation->context); 1218 if (transaction == NULL) 1219 return FALSE; 1220 1221 link = _dbus_list_get_first_link (&pending_activation->entries); 1222 while (link != NULL) 1223 { 1224 BusPendingActivationEntry *entry = link->data; 1225 DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link); 1226 1227 if (dbus_connection_get_is_connected (entry->connection)) 1228 { 1229 if (!bus_transaction_send_error_reply (transaction, 1230 entry->connection, 1231 how, 1232 entry->activation_message)) 1233 goto error; 1234 } 1235 1236 link = next; 1237 } 1238 1239 bus_transaction_execute_and_free (transaction); 1240 1241 return TRUE; 1242 1243 error: 1244 if (transaction) 1245 bus_transaction_cancel_and_free (transaction); 1246 return FALSE; 1247} 1248 1249/** 1250 * Free the pending activation and send an error message to all the 1251 * connections that were waiting for it. 1252 */ 1253static void 1254pending_activation_failed (BusPendingActivation *pending_activation, 1255 const DBusError *how) 1256{ 1257 /* FIXME use preallocated OOM messages instead of bus_wait_for_memory() */ 1258 while (!try_send_activation_failure (pending_activation, how)) 1259 _dbus_wait_for_memory (); 1260 1261 /* Destroy this pending activation */ 1262 _dbus_hash_table_remove_string (pending_activation->activation->pending_activations, 1263 pending_activation->service_name); 1264} 1265 1266/** 1267 * Depending on the exit code of the helper, set the error accordingly 1268 */ 1269static void 1270handle_servicehelper_exit_error (int exit_code, 1271 DBusError *error) 1272{ 1273 switch (exit_code) 1274 { 1275 case BUS_SPAWN_EXIT_CODE_NO_MEMORY: 1276 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, 1277 "Launcher could not run (out of memory)"); 1278 break; 1279 case BUS_SPAWN_EXIT_CODE_SETUP_FAILED: 1280 dbus_set_error (error, DBUS_ERROR_SPAWN_SETUP_FAILED, 1281 "Failed to setup environment correctly"); 1282 break; 1283 case BUS_SPAWN_EXIT_CODE_NAME_INVALID: 1284 dbus_set_error (error, DBUS_ERROR_SPAWN_SERVICE_INVALID, 1285 "Bus name is not valid or missing"); 1286 break; 1287 case BUS_SPAWN_EXIT_CODE_SERVICE_NOT_FOUND: 1288 dbus_set_error (error, DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND, 1289 "Bus name not found in system service directory"); 1290 break; 1291 case BUS_SPAWN_EXIT_CODE_PERMISSIONS_INVALID: 1292 dbus_set_error (error, DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, 1293 "The permission of the setuid helper is not correct"); 1294 break; 1295 case BUS_SPAWN_EXIT_CODE_FILE_INVALID: 1296 dbus_set_error (error, DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, 1297 "The service file is incorrect or does not have all required attributes"); 1298 break; 1299 case BUS_SPAWN_EXIT_CODE_EXEC_FAILED: 1300 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED, 1301 "Cannot launch daemon, file not found or permissions invalid"); 1302 break; 1303 case BUS_SPAWN_EXIT_CODE_INVALID_ARGS: 1304 dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, 1305 "Invalid arguments to command line"); 1306 break; 1307 case BUS_SPAWN_EXIT_CODE_CHILD_SIGNALED: 1308 dbus_set_error (error, DBUS_ERROR_SPAWN_CHILD_SIGNALED, 1309 "Launched child was signaled, it probably crashed"); 1310 break; 1311 default: 1312 dbus_set_error (error, DBUS_ERROR_SPAWN_CHILD_EXITED, 1313 "Launch helper exited with unknown return code %i", exit_code); 1314 break; 1315 } 1316} 1317 1318static dbus_bool_t 1319babysitter_watch_callback (DBusWatch *watch, 1320 unsigned int condition, 1321 void *data) 1322{ 1323 BusPendingActivation *pending_activation = data; 1324 dbus_bool_t retval; 1325 DBusBabysitter *babysitter; 1326 dbus_bool_t uses_servicehelper; 1327 1328 babysitter = pending_activation->babysitter; 1329 1330 _dbus_babysitter_ref (babysitter); 1331 1332 retval = dbus_watch_handle (watch, condition); 1333 1334 /* There are two major cases here; are we the system bus or the session? Here this 1335 * is distinguished by whether or not we use a setuid helper launcher. With the launch helper, 1336 * some process exit codes are meaningful, processed by handle_servicehelper_exit_error. 1337 * 1338 * In both cases though, just ignore when a process exits with status 0; it's possible for 1339 * a program to (misguidedly) "daemonize", and that appears to us as an exit. This closes a race 1340 * condition between this code and the child process claiming the bus name. 1341 */ 1342 uses_servicehelper = bus_context_get_servicehelper (pending_activation->activation->context) != NULL; 1343 1344 /* FIXME this is broken in the same way that 1345 * connection watches used to be; there should be 1346 * a separate callback for status change, instead 1347 * of doing "if we handled a watch status might 1348 * have changed" 1349 * 1350 * Fixing this lets us move dbus_watch_handle 1351 * calls into dbus-mainloop.c 1352 */ 1353 if (_dbus_babysitter_get_child_exited (babysitter)) 1354 { 1355 DBusError error; 1356 DBusHashIter iter; 1357 dbus_bool_t activation_failed; 1358 int exit_code = 0; 1359 1360 dbus_error_init (&error); 1361 1362 _dbus_babysitter_set_child_exit_error (babysitter, &error); 1363 1364 /* Explicitly check for SPAWN_CHILD_EXITED to avoid overwriting an 1365 * exec error */ 1366 if (dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_EXITED) 1367 && _dbus_babysitter_get_child_exit_status (babysitter, &exit_code)) 1368 { 1369 activation_failed = exit_code != 0; 1370 1371 dbus_error_free(&error); 1372 1373 if (activation_failed) 1374 { 1375 if (uses_servicehelper) 1376 handle_servicehelper_exit_error (exit_code, &error); 1377 else 1378 _dbus_babysitter_set_child_exit_error (babysitter, &error); 1379 } 1380 } 1381 else 1382 { 1383 activation_failed = TRUE; 1384 } 1385 1386 if (activation_failed) 1387 { 1388 /* Destroy all pending activations with the same exec */ 1389 _dbus_hash_iter_init (pending_activation->activation->pending_activations, 1390 &iter); 1391 while (_dbus_hash_iter_next (&iter)) 1392 { 1393 BusPendingActivation *p = _dbus_hash_iter_get_value (&iter); 1394 1395 if (p != pending_activation && strcmp (p->exec, pending_activation->exec) == 0) 1396 pending_activation_failed (p, &error); 1397 } 1398 1399 /* Destroys the pending activation */ 1400 pending_activation_failed (pending_activation, &error); 1401 1402 dbus_error_free (&error); 1403 } 1404 } 1405 1406 _dbus_babysitter_unref (babysitter); 1407 1408 return retval; 1409} 1410 1411static dbus_bool_t 1412add_babysitter_watch (DBusWatch *watch, 1413 void *data) 1414{ 1415 BusPendingActivation *pending_activation = data; 1416 1417 return _dbus_loop_add_watch (bus_context_get_loop (pending_activation->activation->context), 1418 watch, babysitter_watch_callback, pending_activation, 1419 NULL); 1420} 1421 1422static void 1423remove_babysitter_watch (DBusWatch *watch, 1424 void *data) 1425{ 1426 BusPendingActivation *pending_activation = data; 1427 1428 _dbus_loop_remove_watch (bus_context_get_loop (pending_activation->activation->context), 1429 watch, babysitter_watch_callback, pending_activation); 1430} 1431 1432static dbus_bool_t 1433pending_activation_timed_out (void *data) 1434{ 1435 BusPendingActivation *pending_activation = data; 1436 DBusError error; 1437 1438 /* Kill the spawned process, since it sucks 1439 * (not sure this is what we want to do, but 1440 * may as well try it for now) 1441 */ 1442 if (pending_activation->babysitter) 1443 _dbus_babysitter_kill_child (pending_activation->babysitter); 1444 1445 dbus_error_init (&error); 1446 1447 dbus_set_error (&error, DBUS_ERROR_TIMED_OUT, 1448 "Activation of %s timed out", 1449 pending_activation->service_name); 1450 1451 pending_activation_failed (pending_activation, &error); 1452 1453 dbus_error_free (&error); 1454 1455 return TRUE; 1456} 1457 1458static void 1459cancel_pending (void *data) 1460{ 1461 BusPendingActivation *pending_activation = data; 1462 1463 _dbus_verbose ("Canceling pending activation of %s\n", 1464 pending_activation->service_name); 1465 1466 if (pending_activation->babysitter) 1467 _dbus_babysitter_kill_child (pending_activation->babysitter); 1468 1469 _dbus_hash_table_remove_string (pending_activation->activation->pending_activations, 1470 pending_activation->service_name); 1471} 1472 1473static void 1474free_pending_cancel_data (void *data) 1475{ 1476 BusPendingActivation *pending_activation = data; 1477 1478 bus_pending_activation_unref (pending_activation); 1479} 1480 1481static dbus_bool_t 1482add_cancel_pending_to_transaction (BusTransaction *transaction, 1483 BusPendingActivation *pending_activation) 1484{ 1485 if (!bus_transaction_add_cancel_hook (transaction, cancel_pending, 1486 pending_activation, 1487 free_pending_cancel_data)) 1488 return FALSE; 1489 1490 bus_pending_activation_ref (pending_activation); 1491 1492 _dbus_verbose ("Saved pending activation to be canceled if the transaction fails\n"); 1493 1494 return TRUE; 1495} 1496 1497static dbus_bool_t 1498update_service_cache (BusActivation *activation, DBusError *error) 1499{ 1500 DBusHashIter iter; 1501 1502 _dbus_hash_iter_init (activation->directories, &iter); 1503 while (_dbus_hash_iter_next (&iter)) 1504 { 1505 DBusError tmp_error; 1506 BusServiceDirectory *s_dir; 1507 1508 s_dir = _dbus_hash_iter_get_value (&iter); 1509 1510 dbus_error_init (&tmp_error); 1511 if (!update_directory (activation, s_dir, &tmp_error)) 1512 { 1513 if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) 1514 { 1515 dbus_move_error (&tmp_error, error); 1516 return FALSE; 1517 } 1518 1519 dbus_error_free (&tmp_error); 1520 continue; 1521 } 1522 } 1523 1524 return TRUE; 1525} 1526 1527static BusActivationEntry * 1528activation_find_entry (BusActivation *activation, 1529 const char *service_name, 1530 DBusError *error) 1531{ 1532 BusActivationEntry *entry; 1533 1534 entry = _dbus_hash_table_lookup_string (activation->entries, service_name); 1535 if (!entry) 1536 { 1537 if (!update_service_cache (activation, error)) 1538 return NULL; 1539 1540 entry = _dbus_hash_table_lookup_string (activation->entries, 1541 service_name); 1542 } 1543 else 1544 { 1545 BusActivationEntry *updated_entry; 1546 1547 if (!check_service_file (activation, entry, &updated_entry, error)) 1548 return NULL; 1549 1550 entry = updated_entry; 1551 } 1552 1553 if (!entry) 1554 { 1555 dbus_set_error (error, DBUS_ERROR_SERVICE_UNKNOWN, 1556 "The name %s was not provided by any .service files", 1557 service_name); 1558 return NULL; 1559 } 1560 1561 return entry; 1562} 1563 1564static char ** 1565bus_activation_get_environment (BusActivation *activation) 1566{ 1567 char **environment; 1568 int i, length; 1569 DBusString entry; 1570 DBusHashIter iter; 1571 1572 length = _dbus_hash_table_get_n_entries (activation->environment); 1573 1574 environment = dbus_new0 (char *, length + 1); 1575 1576 if (environment == NULL) 1577 return NULL; 1578 1579 i = 0; 1580 _dbus_hash_iter_init (activation->environment, &iter); 1581 1582 if (!_dbus_string_init (&entry)) 1583 { 1584 dbus_free_string_array (environment); 1585 return NULL; 1586 } 1587 1588 while (_dbus_hash_iter_next (&iter)) 1589 { 1590 const char *key, *value; 1591 1592 key = (const char *) _dbus_hash_iter_get_string_key (&iter); 1593 value = (const char *) _dbus_hash_iter_get_value (&iter); 1594 1595 if (!_dbus_string_append_printf (&entry, "%s=%s", key, value)) 1596 break; 1597 1598 if (!_dbus_string_steal_data (&entry, environment + i)) 1599 break; 1600 i++; 1601 } 1602 1603 _dbus_string_free (&entry); 1604 1605 if (i != length) 1606 { 1607 dbus_free_string_array (environment); 1608 environment = NULL; 1609 } 1610 1611 return environment; 1612} 1613 1614dbus_bool_t 1615bus_activation_set_environment_variable (BusActivation *activation, 1616 const char *key, 1617 const char *value, 1618 DBusError *error) 1619{ 1620 char *hash_key; 1621 char *hash_value; 1622 dbus_bool_t retval; 1623 1624 retval = FALSE; 1625 hash_key = NULL; 1626 hash_value = NULL; 1627 hash_key = _dbus_strdup (key); 1628 1629 if (hash_key == NULL) 1630 goto out; 1631 1632 hash_value = _dbus_strdup (value); 1633 1634 if (hash_value == NULL) 1635 goto out; 1636 1637 if (!_dbus_hash_table_insert_string (activation->environment, 1638 hash_key, hash_value)) 1639 goto out; 1640 1641 retval = TRUE; 1642out: 1643 if (retval == FALSE) 1644 { 1645 dbus_free (hash_key); 1646 dbus_free (hash_value); 1647 BUS_SET_OOM (error); 1648 } 1649 1650 return retval; 1651} 1652 1653dbus_bool_t 1654bus_activation_activate_service (BusActivation *activation, 1655 DBusConnection *connection, 1656 BusTransaction *transaction, 1657 dbus_bool_t auto_activation, 1658 DBusMessage *activation_message, 1659 const char *service_name, 1660 DBusError *error) 1661{ 1662 BusActivationEntry *entry; 1663 BusPendingActivation *pending_activation; 1664 BusPendingActivationEntry *pending_activation_entry; 1665 DBusMessage *message; 1666 DBusString service_str; 1667 const char *servicehelper; 1668 char **argv; 1669 char **envp = NULL; 1670 int argc; 1671 dbus_bool_t retval; 1672 DBusHashIter iter; 1673 dbus_bool_t activated; 1674 DBusString command; 1675 1676 activated = TRUE; 1677 1678 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1679 1680 if (activation->n_pending_activations >= 1681 bus_context_get_max_pending_activations (activation->context)) 1682 { 1683 dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED, 1684 "The maximum number of pending activations has been reached, activation of %s failed", 1685 service_name); 1686 return FALSE; 1687 } 1688 1689 entry = activation_find_entry (activation, service_name, error); 1690 if (!entry) 1691 return FALSE; 1692 1693 /* Bypass the registry lookup if we're auto-activating, bus_dispatch would not 1694 * call us if the service is already active. 1695 */ 1696 if (!auto_activation) 1697 { 1698 /* Check if the service is active */ 1699 _dbus_string_init_const (&service_str, service_name); 1700 if (bus_registry_lookup (bus_context_get_registry (activation->context), &service_str) != NULL) 1701 { 1702 dbus_uint32_t result; 1703 1704 _dbus_verbose ("Service \"%s\" is already active\n", service_name); 1705 1706 message = dbus_message_new_method_return (activation_message); 1707 1708 if (!message) 1709 { 1710 _dbus_verbose ("No memory to create reply to activate message\n"); 1711 BUS_SET_OOM (error); 1712 return FALSE; 1713 } 1714 1715 result = DBUS_START_REPLY_ALREADY_RUNNING; 1716 1717 if (!dbus_message_append_args (message, 1718 DBUS_TYPE_UINT32, &result, 1719 DBUS_TYPE_INVALID)) 1720 { 1721 _dbus_verbose ("No memory to set args of reply to activate message\n"); 1722 BUS_SET_OOM (error); 1723 dbus_message_unref (message); 1724 return FALSE; 1725 } 1726 1727 retval = bus_transaction_send_from_driver (transaction, connection, message); 1728 dbus_message_unref (message); 1729 if (!retval) 1730 { 1731 _dbus_verbose ("Failed to send reply\n"); 1732 BUS_SET_OOM (error); 1733 } 1734 1735 return retval; 1736 } 1737 } 1738 1739 pending_activation_entry = dbus_new0 (BusPendingActivationEntry, 1); 1740 if (!pending_activation_entry) 1741 { 1742 _dbus_verbose ("Failed to create pending activation entry\n"); 1743 BUS_SET_OOM (error); 1744 return FALSE; 1745 } 1746 1747 pending_activation_entry->auto_activation = auto_activation; 1748 1749 pending_activation_entry->activation_message = activation_message; 1750 dbus_message_ref (activation_message); 1751 pending_activation_entry->connection = connection; 1752 dbus_connection_ref (connection); 1753 1754 /* Check if the service is being activated */ 1755 pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, service_name); 1756 if (pending_activation) 1757 { 1758 if (!_dbus_list_append (&pending_activation->entries, pending_activation_entry)) 1759 { 1760 _dbus_verbose ("Failed to append a new entry to pending activation\n"); 1761 1762 BUS_SET_OOM (error); 1763 bus_pending_activation_entry_free (pending_activation_entry); 1764 return FALSE; 1765 } 1766 1767 pending_activation->n_entries += 1; 1768 pending_activation->activation->n_pending_activations += 1; 1769 } 1770 else 1771 { 1772 pending_activation = dbus_new0 (BusPendingActivation, 1); 1773 if (!pending_activation) 1774 { 1775 _dbus_verbose ("Failed to create pending activation\n"); 1776 1777 BUS_SET_OOM (error); 1778 bus_pending_activation_entry_free (pending_activation_entry); 1779 return FALSE; 1780 } 1781 1782 pending_activation->activation = activation; 1783 pending_activation->refcount = 1; 1784 1785 pending_activation->service_name = _dbus_strdup (service_name); 1786 if (!pending_activation->service_name) 1787 { 1788 _dbus_verbose ("Failed to copy service name for pending activation\n"); 1789 1790 BUS_SET_OOM (error); 1791 bus_pending_activation_unref (pending_activation); 1792 bus_pending_activation_entry_free (pending_activation_entry); 1793 return FALSE; 1794 } 1795 1796 pending_activation->exec = _dbus_strdup (entry->exec); 1797 if (!pending_activation->exec) 1798 { 1799 _dbus_verbose ("Failed to copy service exec for pending activation\n"); 1800 BUS_SET_OOM (error); 1801 bus_pending_activation_unref (pending_activation); 1802 bus_pending_activation_entry_free (pending_activation_entry); 1803 return FALSE; 1804 } 1805 1806 if (entry->systemd_service) 1807 { 1808 pending_activation->systemd_service = _dbus_strdup (entry->systemd_service); 1809 if (!pending_activation->systemd_service) 1810 { 1811 _dbus_verbose ("Failed to copy systemd service for pending activation\n"); 1812 BUS_SET_OOM (error); 1813 bus_pending_activation_unref (pending_activation); 1814 bus_pending_activation_entry_free (pending_activation_entry); 1815 return FALSE; 1816 } 1817 } 1818 1819 pending_activation->timeout = 1820 _dbus_timeout_new (bus_context_get_activation_timeout (activation->context), 1821 pending_activation_timed_out, 1822 pending_activation, 1823 NULL); 1824 if (!pending_activation->timeout) 1825 { 1826 _dbus_verbose ("Failed to create timeout for pending activation\n"); 1827 1828 BUS_SET_OOM (error); 1829 bus_pending_activation_unref (pending_activation); 1830 bus_pending_activation_entry_free (pending_activation_entry); 1831 return FALSE; 1832 } 1833 1834 if (!_dbus_loop_add_timeout (bus_context_get_loop (activation->context), 1835 pending_activation->timeout, 1836 handle_timeout_callback, 1837 pending_activation, 1838 NULL)) 1839 { 1840 _dbus_verbose ("Failed to add timeout for pending activation\n"); 1841 1842 BUS_SET_OOM (error); 1843 bus_pending_activation_unref (pending_activation); 1844 bus_pending_activation_entry_free (pending_activation_entry); 1845 return FALSE; 1846 } 1847 1848 pending_activation->timeout_added = TRUE; 1849 1850 if (!_dbus_list_append (&pending_activation->entries, pending_activation_entry)) 1851 { 1852 _dbus_verbose ("Failed to add entry to just-created pending activation\n"); 1853 1854 BUS_SET_OOM (error); 1855 bus_pending_activation_unref (pending_activation); 1856 bus_pending_activation_entry_free (pending_activation_entry); 1857 return FALSE; 1858 } 1859 1860 pending_activation->n_entries += 1; 1861 pending_activation->activation->n_pending_activations += 1; 1862 1863 activated = FALSE; 1864 _dbus_hash_iter_init (activation->pending_activations, &iter); 1865 while (_dbus_hash_iter_next (&iter)) 1866 { 1867 BusPendingActivation *p = _dbus_hash_iter_get_value (&iter); 1868 1869 if (strcmp (p->exec, entry->exec) == 0) 1870 { 1871 activated = TRUE; 1872 break; 1873 } 1874 } 1875 1876 if (!_dbus_hash_table_insert_string (activation->pending_activations, 1877 pending_activation->service_name, 1878 pending_activation)) 1879 { 1880 _dbus_verbose ("Failed to put pending activation in hash table\n"); 1881 1882 BUS_SET_OOM (error); 1883 bus_pending_activation_unref (pending_activation); 1884 return FALSE; 1885 } 1886 } 1887 1888 if (!add_cancel_pending_to_transaction (transaction, pending_activation)) 1889 { 1890 _dbus_verbose ("Failed to add pending activation cancel hook to transaction\n"); 1891 BUS_SET_OOM (error); 1892 _dbus_hash_table_remove_string (activation->pending_activations, 1893 pending_activation->service_name); 1894 1895 return FALSE; 1896 } 1897 1898 if (activated) 1899 return TRUE; 1900 1901 if (bus_context_get_systemd_activation (activation->context)) 1902 { 1903 if (strcmp (service_name, "org.freedesktop.systemd1") == 0) 1904 /* systemd itself is missing apparently. That can happen 1905 only during early startup. Let's just wait until systemd 1906 connects to us and do nothing. */ 1907 return TRUE; 1908 1909 if (entry->systemd_service) 1910 { 1911 BusTransaction *activation_transaction; 1912 DBusString service_string; 1913 BusService *service; 1914 BusRegistry *registry; 1915 1916 /* OK, we have a systemd service configured for this entry, 1917 hence let's enqueue an activation request message. This 1918 is implemented as a directed signal, not a method call, 1919 for three reasons: 1) we don't expect a response on 1920 success, where we just expect a name appearing on the 1921 bus; 2) at this time the systemd service might not yet 1922 have connected, so we wouldn't know the message serial at 1923 this point to set up a pending call; 3) it is ugly if the 1924 bus suddenly becomes the caller of a remote method. */ 1925 1926 message = dbus_message_new_signal (DBUS_PATH_DBUS, 1927 "org.freedesktop.systemd1.Activator", 1928 "ActivationRequest"); 1929 if (!message) 1930 { 1931 _dbus_verbose ("No memory to create activation message\n"); 1932 BUS_SET_OOM (error); 1933 return FALSE; 1934 } 1935 1936 if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS) || 1937 !dbus_message_set_destination (message, "org.freedesktop.systemd1") || 1938 !dbus_message_append_args (message, 1939 DBUS_TYPE_STRING, &entry->systemd_service, 1940 DBUS_TYPE_INVALID)) 1941 { 1942 _dbus_verbose ("No memory to set args of activation message\n"); 1943 dbus_message_unref (message); 1944 BUS_SET_OOM (error); 1945 return FALSE; 1946 } 1947 1948 /* Create our transaction */ 1949 activation_transaction = bus_transaction_new (activation->context); 1950 if (activation_transaction == NULL) 1951 { 1952 _dbus_verbose ("No memory to create activation transaction\n"); 1953 dbus_message_unref (message); 1954 BUS_SET_OOM (error); 1955 return FALSE; 1956 } 1957 1958 /* Check whether systemd is already connected */ 1959 registry = bus_connection_get_registry (connection); 1960 _dbus_string_init_const (&service_string, "org.freedesktop.systemd1"); 1961 service = bus_registry_lookup (registry, &service_string); 1962 1963 if (service != NULL) 1964 /* Wonderful, systemd is connected, let's just send the msg */ 1965 retval = bus_dispatch_matches (activation_transaction, NULL, bus_service_get_primary_owners_connection (service), 1966 message, error); 1967 else 1968 /* systemd is not around, let's "activate" it. */ 1969 retval = bus_activation_activate_service (activation, connection, activation_transaction, TRUE, 1970 message, "org.freedesktop.systemd1", error); 1971 1972 dbus_message_unref (message); 1973 1974 if (!retval) 1975 { 1976 _DBUS_ASSERT_ERROR_IS_SET (error); 1977 _dbus_verbose ("failed to send activation message: %s\n", error->name); 1978 bus_transaction_cancel_and_free (activation_transaction); 1979 return FALSE; 1980 } 1981 1982 bus_transaction_execute_and_free (activation_transaction); 1983 return TRUE; 1984 } 1985 1986 /* OK, we have no configured systemd service, hence let's 1987 proceed with traditional activation. */ 1988 } 1989 1990 /* use command as system and session different */ 1991 if (!_dbus_string_init (&command)) 1992 { 1993 BUS_SET_OOM (error); 1994 return FALSE; 1995 } 1996 1997 /* does the bus use a helper? */ 1998 servicehelper = bus_context_get_servicehelper (activation->context); 1999 if (servicehelper != NULL) 2000 { 2001 if (entry->user == NULL) 2002 { 2003 _dbus_string_free (&command); 2004 dbus_set_error (error, DBUS_ERROR_SPAWN_FILE_INVALID, 2005 "Cannot do system-bus activation with no user\n"); 2006 return FALSE; 2007 } 2008 2009 /* join the helper path and the service name */ 2010 if (!_dbus_string_append (&command, servicehelper)) 2011 { 2012 _dbus_string_free (&command); 2013 BUS_SET_OOM (error); 2014 return FALSE; 2015 } 2016 if (!_dbus_string_append (&command, " ")) 2017 { 2018 _dbus_string_free (&command); 2019 BUS_SET_OOM (error); 2020 return FALSE; 2021 } 2022 if (!_dbus_string_append (&command, service_name)) 2023 { 2024 _dbus_string_free (&command); 2025 BUS_SET_OOM (error); 2026 return FALSE; 2027 } 2028 } 2029 else 2030 { 2031 /* the bus does not use a helper, so we can append arguments with the exec line */ 2032 if (!_dbus_string_append (&command, entry->exec)) 2033 { 2034 _dbus_string_free (&command); 2035 BUS_SET_OOM (error); 2036 return FALSE; 2037 } 2038 } 2039 2040 /* convert command into arguments */ 2041 if (!_dbus_shell_parse_argv (_dbus_string_get_const_data (&command), &argc, &argv, error)) 2042 { 2043 _dbus_verbose ("Failed to parse command line: %s\n", entry->exec); 2044 _DBUS_ASSERT_ERROR_IS_SET (error); 2045 2046 _dbus_hash_table_remove_string (activation->pending_activations, 2047 pending_activation->service_name); 2048 2049 _dbus_string_free (&command); 2050 return FALSE; 2051 } 2052 _dbus_string_free (&command); 2053 2054 if (!add_bus_environment (activation, error)) 2055 { 2056 _DBUS_ASSERT_ERROR_IS_SET (error); 2057 dbus_free_string_array (argv); 2058 return FALSE; 2059 } 2060 2061 envp = bus_activation_get_environment (activation); 2062 2063 if (envp == NULL) 2064 { 2065 BUS_SET_OOM (error); 2066 dbus_free_string_array (argv); 2067 return FALSE; 2068 } 2069 2070 _dbus_verbose ("Spawning %s ...\n", argv[0]); 2071 if (!_dbus_spawn_async_with_babysitter (&pending_activation->babysitter, argv, 2072 envp, 2073 NULL, activation, 2074 error)) 2075 { 2076 _dbus_verbose ("Failed to spawn child\n"); 2077 _DBUS_ASSERT_ERROR_IS_SET (error); 2078 dbus_free_string_array (argv); 2079 dbus_free_string_array (envp); 2080 2081 return FALSE; 2082 } 2083 2084 dbus_free_string_array (argv); 2085 envp = NULL; 2086 2087 _dbus_assert (pending_activation->babysitter != NULL); 2088 2089 if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter, 2090 add_babysitter_watch, 2091 remove_babysitter_watch, 2092 NULL, 2093 pending_activation, 2094 NULL)) 2095 { 2096 BUS_SET_OOM (error); 2097 _dbus_verbose ("Failed to set babysitter watch functions\n"); 2098 return FALSE; 2099 } 2100 2101 return TRUE; 2102} 2103 2104dbus_bool_t 2105bus_activation_list_services (BusActivation *activation, 2106 char ***listp, 2107 int *array_len) 2108{ 2109 int i, j, len; 2110 char **retval; 2111 DBusHashIter iter; 2112 2113 len = _dbus_hash_table_get_n_entries (activation->entries); 2114 retval = dbus_new (char *, len + 1); 2115 2116 if (retval == NULL) 2117 return FALSE; 2118 2119 _dbus_hash_iter_init (activation->entries, &iter); 2120 i = 0; 2121 while (_dbus_hash_iter_next (&iter)) 2122 { 2123 BusActivationEntry *entry = _dbus_hash_iter_get_value (&iter); 2124 2125 retval[i] = _dbus_strdup (entry->name); 2126 if (retval[i] == NULL) 2127 goto error; 2128 2129 i++; 2130 } 2131 2132 retval[i] = NULL; 2133 2134 if (array_len) 2135 *array_len = len; 2136 2137 *listp = retval; 2138 return TRUE; 2139 2140 error: 2141 for (j = 0; j < i; j++) 2142 dbus_free (retval[i]); 2143 dbus_free (retval); 2144 2145 return FALSE; 2146} 2147 2148dbus_bool_t 2149dbus_activation_systemd_failure (BusActivation *activation, 2150 DBusMessage *message) 2151{ 2152 DBusError error; 2153 const char *code, *str, *unit = NULL; 2154 2155 dbus_error_init(&error); 2156 2157 /* This is called whenever the systemd activator sent us a 2158 response. We'll invalidate all pending activations that match the 2159 unit name. */ 2160 2161 if (dbus_message_get_args (message, &error, 2162 DBUS_TYPE_STRING, &unit, 2163 DBUS_TYPE_STRING, &code, 2164 DBUS_TYPE_STRING, &str, 2165 DBUS_TYPE_INVALID)) 2166 dbus_set_error(&error, code, str); 2167 2168 if (unit) 2169 { 2170 DBusHashIter iter; 2171 2172 _dbus_hash_iter_init (activation->pending_activations, 2173 &iter); 2174 2175 while (_dbus_hash_iter_next (&iter)) 2176 { 2177 BusPendingActivation *p = _dbus_hash_iter_get_value (&iter); 2178 2179 if (p->systemd_service && strcmp (p->systemd_service, unit) == 0) 2180 pending_activation_failed(p, &error); 2181 } 2182 } 2183 2184 dbus_error_free(&error); 2185 2186 return TRUE; 2187} 2188 2189#ifdef DBUS_BUILD_TESTS 2190 2191#include <stdio.h> 2192 2193#define SERVICE_NAME_1 "MyService1" 2194#define SERVICE_NAME_2 "MyService2" 2195#define SERVICE_NAME_3 "MyService3" 2196 2197#define SERVICE_FILE_1 "service-1.service" 2198#define SERVICE_FILE_2 "service-2.service" 2199#define SERVICE_FILE_3 "service-3.service" 2200 2201static dbus_bool_t 2202test_create_service_file (DBusString *dir, 2203 const char *filename, 2204 const char *name, 2205 const char *exec) 2206{ 2207 DBusString file_name, full_path; 2208 FILE *file; 2209 dbus_bool_t ret_val; 2210 2211 ret_val = TRUE; 2212 _dbus_string_init_const (&file_name, filename); 2213 2214 if (!_dbus_string_init (&full_path)) 2215 return FALSE; 2216 2217 if (!_dbus_string_append (&full_path, _dbus_string_get_const_data (dir)) || 2218 !_dbus_concat_dir_and_file (&full_path, &file_name)) 2219 { 2220 ret_val = FALSE; 2221 goto out; 2222 } 2223 2224 file = fopen (_dbus_string_get_const_data (&full_path), "w"); 2225 if (!file) 2226 { 2227 ret_val = FALSE; 2228 goto out; 2229 } 2230 2231 fprintf (file, "[D-BUS Service]\nName=%s\nExec=%s\n", name, exec); 2232 fclose (file); 2233 2234out: 2235 _dbus_string_free (&full_path); 2236 return ret_val; 2237} 2238 2239static dbus_bool_t 2240test_remove_service_file (DBusString *dir, const char *filename) 2241{ 2242 DBusString file_name, full_path; 2243 dbus_bool_t ret_val; 2244 2245 ret_val = TRUE; 2246 2247 _dbus_string_init_const (&file_name, filename); 2248 2249 if (!_dbus_string_init (&full_path)) 2250 return FALSE; 2251 2252 if (!_dbus_string_append (&full_path, _dbus_string_get_const_data (dir)) || 2253 !_dbus_concat_dir_and_file (&full_path, &file_name)) 2254 { 2255 ret_val = FALSE; 2256 goto out; 2257 } 2258 2259 if (!_dbus_delete_file (&full_path, NULL)) 2260 { 2261 ret_val = FALSE; 2262 goto out; 2263 } 2264 2265out: 2266 _dbus_string_free (&full_path); 2267 return ret_val; 2268} 2269 2270static dbus_bool_t 2271test_remove_directory (DBusString *dir) 2272{ 2273 DBusDirIter *iter; 2274 DBusString filename, full_path; 2275 dbus_bool_t ret_val; 2276 2277 ret_val = TRUE; 2278 2279 if (!_dbus_string_init (&filename)) 2280 return FALSE; 2281 2282 if (!_dbus_string_init (&full_path)) 2283 { 2284 _dbus_string_free (&filename); 2285 return FALSE; 2286 } 2287 2288 iter = _dbus_directory_open (dir, NULL); 2289 if (iter == NULL) 2290 { 2291 ret_val = FALSE; 2292 goto out; 2293 } 2294 2295 while (_dbus_directory_get_next_file (iter, &filename, NULL)) 2296 { 2297 if (!test_remove_service_file (dir, _dbus_string_get_const_data (&filename))) 2298 { 2299 ret_val = FALSE; 2300 goto out; 2301 } 2302 } 2303 _dbus_directory_close (iter); 2304 2305 if (!_dbus_delete_directory (dir, NULL)) 2306 { 2307 ret_val = FALSE; 2308 goto out; 2309 } 2310 2311out: 2312 _dbus_string_free (&filename); 2313 _dbus_string_free (&full_path); 2314 2315 return ret_val; 2316} 2317 2318static dbus_bool_t 2319init_service_reload_test (DBusString *dir) 2320{ 2321 DBusStat stat_buf; 2322 2323 if (!_dbus_stat (dir, &stat_buf, NULL)) 2324 { 2325 if (!_dbus_create_directory (dir, NULL)) 2326 return FALSE; 2327 } 2328 else 2329 { 2330 if (!test_remove_directory (dir)) 2331 return FALSE; 2332 2333 if (!_dbus_create_directory (dir, NULL)) 2334 return FALSE; 2335 } 2336 2337 /* Create one initial file */ 2338 if (!test_create_service_file (dir, SERVICE_FILE_1, SERVICE_NAME_1, "exec-1")) 2339 return FALSE; 2340 2341 return TRUE; 2342} 2343 2344static dbus_bool_t 2345cleanup_service_reload_test (DBusString *dir) 2346{ 2347 if (!test_remove_directory (dir)) 2348 return FALSE; 2349 2350 return TRUE; 2351} 2352 2353typedef struct 2354{ 2355 BusActivation *activation; 2356 const char *service_name; 2357 dbus_bool_t expecting_find; 2358} CheckData; 2359 2360static dbus_bool_t 2361check_func (void *data) 2362{ 2363 CheckData *d; 2364 BusActivationEntry *entry; 2365 DBusError error; 2366 dbus_bool_t ret_val; 2367 2368 ret_val = TRUE; 2369 d = data; 2370 2371 dbus_error_init (&error); 2372 2373 entry = activation_find_entry (d->activation, d->service_name, &error); 2374 if (entry == NULL) 2375 { 2376 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 2377 { 2378 ret_val = TRUE; 2379 } 2380 else 2381 { 2382 if (d->expecting_find) 2383 ret_val = FALSE; 2384 } 2385 2386 dbus_error_free (&error); 2387 } 2388 else 2389 { 2390 if (!d->expecting_find) 2391 ret_val = FALSE; 2392 } 2393 2394 return ret_val; 2395} 2396 2397static dbus_bool_t 2398do_test (const char *description, dbus_bool_t oom_test, CheckData *data) 2399{ 2400 dbus_bool_t err; 2401 2402 if (oom_test) 2403 err = !_dbus_test_oom_handling (description, check_func, data); 2404 else 2405 err = !check_func (data); 2406 2407 if (err) 2408 _dbus_assert_not_reached ("Test failed"); 2409 2410 return TRUE; 2411} 2412 2413static dbus_bool_t 2414do_service_reload_test (DBusString *dir, dbus_bool_t oom_test) 2415{ 2416 BusActivation *activation; 2417 DBusString address; 2418 DBusList *directories; 2419 CheckData d; 2420 2421 directories = NULL; 2422 _dbus_string_init_const (&address, ""); 2423 2424 if (!_dbus_list_append (&directories, _dbus_string_get_data (dir))) 2425 return FALSE; 2426 2427 activation = bus_activation_new (NULL, &address, &directories, NULL); 2428 if (!activation) 2429 return FALSE; 2430 2431 d.activation = activation; 2432 2433 /* Check for existing service file */ 2434 d.expecting_find = TRUE; 2435 d.service_name = SERVICE_NAME_1; 2436 2437 if (!do_test ("Existing service file", oom_test, &d)) 2438 return FALSE; 2439 2440 /* Check for non-existing service file */ 2441 d.expecting_find = FALSE; 2442 d.service_name = SERVICE_NAME_3; 2443 2444 if (!do_test ("Nonexisting service file", oom_test, &d)) 2445 return FALSE; 2446 2447 /* Check for added service file */ 2448 if (!test_create_service_file (dir, SERVICE_FILE_2, SERVICE_NAME_2, "exec-2")) 2449 return FALSE; 2450 2451 d.expecting_find = TRUE; 2452 d.service_name = SERVICE_NAME_2; 2453 2454 if (!do_test ("Added service file", oom_test, &d)) 2455 return FALSE; 2456 2457 /* Check for removed service file */ 2458 if (!test_remove_service_file (dir, SERVICE_FILE_2)) 2459 return FALSE; 2460 2461 d.expecting_find = FALSE; 2462 d.service_name = SERVICE_FILE_2; 2463 2464 if (!do_test ("Removed service file", oom_test, &d)) 2465 return FALSE; 2466 2467 /* Check for updated service file */ 2468 2469 _dbus_sleep_milliseconds (1000); /* Sleep a second to make sure the mtime is updated */ 2470 2471 if (!test_create_service_file (dir, SERVICE_FILE_1, SERVICE_NAME_3, "exec-3")) 2472 return FALSE; 2473 2474 d.expecting_find = TRUE; 2475 d.service_name = SERVICE_NAME_3; 2476 2477 if (!do_test ("Updated service file, part 1", oom_test, &d)) 2478 return FALSE; 2479 2480 d.expecting_find = FALSE; 2481 d.service_name = SERVICE_NAME_1; 2482 2483 if (!do_test ("Updated service file, part 2", oom_test, &d)) 2484 return FALSE; 2485 2486 bus_activation_unref (activation); 2487 _dbus_list_clear (&directories); 2488 2489 return TRUE; 2490} 2491 2492dbus_bool_t 2493bus_activation_service_reload_test (const DBusString *test_data_dir) 2494{ 2495 DBusString directory; 2496 2497 if (!_dbus_string_init (&directory)) 2498 return FALSE; 2499 2500 if (!_dbus_string_append (&directory, _dbus_get_tmpdir())) 2501 return FALSE; 2502 2503 if (!_dbus_string_append (&directory, "/dbus-reload-test-") || 2504 !_dbus_generate_random_ascii (&directory, 6)) 2505 { 2506 return FALSE; 2507 } 2508 2509 /* Do normal tests */ 2510 if (!init_service_reload_test (&directory)) 2511 _dbus_assert_not_reached ("could not initiate service reload test"); 2512 2513 if (!do_service_reload_test (&directory, FALSE)) 2514 ; /* Do nothing? */ 2515 2516 /* Do OOM tests */ 2517 if (!init_service_reload_test (&directory)) 2518 _dbus_assert_not_reached ("could not initiate service reload test"); 2519 2520 if (!do_service_reload_test (&directory, TRUE)) 2521 ; /* Do nothing? */ 2522 2523 /* Cleanup test directory */ 2524 if (!cleanup_service_reload_test (&directory)) 2525 return FALSE; 2526 2527 _dbus_string_free (&directory); 2528 2529 return TRUE; 2530} 2531 2532#endif /* DBUS_BUILD_TESTS */ 2533