1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2 /* dispatch.c Message dispatcher 3 * 4 * Copyright (C) 2003 CodeFactory AB 5 * Copyright (C) 2003, 2004, 2005 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 "dispatch.h" 28 #include "connection.h" 29 #include "driver.h" 30 #include "services.h" 31 #include "activation.h" 32 #include "utils.h" 33 #include "bus.h" 34 #include "signals.h" 35 #include "test.h" 36 #include <dbus/dbus-internals.h> 37 #include <string.h> 38 39 #ifdef HAVE_UNIX_FD_PASSING 40 #include <dbus/dbus-sysdeps-unix.h> 41 #include <unistd.h> 42 #endif 43 44 #ifndef TEST_CONNECTION 45 /* 46 TODO autotools: 47 move to build system as already done for cmake 48 */ 49 #ifdef DBUS_UNIX 50 #define TEST_CONNECTION "debug-pipe:name=test-server" 51 #else 52 #define TEST_CONNECTION "tcp:host=localhost,port=1234" 53 #endif 54 #endif 55 56 static dbus_bool_t 57 send_one_message (DBusConnection *connection, 58 BusContext *context, 59 DBusConnection *sender, 60 DBusConnection *addressed_recipient, 61 DBusMessage *message, 62 BusTransaction *transaction, 63 DBusError *error) 64 { 65 if (!bus_context_check_security_policy (context, transaction, 66 sender, 67 addressed_recipient, 68 connection, 69 message, 70 NULL)) 71 return TRUE; /* silently don't send it */ 72 73 if (dbus_message_contains_unix_fds(message) && 74 !dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD)) 75 return TRUE; /* silently don't send it */ 76 77 if (!bus_transaction_send (transaction, 78 connection, 79 message)) 80 { 81 BUS_SET_OOM (error); 82 return FALSE; 83 } 84 85 return TRUE; 86 } 87 88 dbus_bool_t 89 bus_dispatch_matches (BusTransaction *transaction, 90 DBusConnection *sender, 91 DBusConnection *addressed_recipient, 92 DBusMessage *message, 93 DBusError *error) 94 { 95 DBusError tmp_error; 96 BusConnections *connections; 97 DBusList *recipients; 98 BusMatchmaker *matchmaker; 99 DBusList *link; 100 BusContext *context; 101 102 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 103 104 /* sender and recipient can both be NULL for the bus driver, 105 * or for signals with no particular recipient 106 */ 107 108 _dbus_assert (sender == NULL || bus_connection_is_active (sender)); 109 _dbus_assert (dbus_message_get_sender (message) != NULL); 110 111 context = bus_transaction_get_context (transaction); 112 113 /* First, send the message to the addressed_recipient, if there is one. */ 114 if (addressed_recipient != NULL) 115 { 116 if (!bus_context_check_security_policy (context, transaction, 117 sender, addressed_recipient, 118 addressed_recipient, 119 message, error)) 120 return FALSE; 121 122 if (dbus_message_contains_unix_fds (message) && 123 !dbus_connection_can_send_type (addressed_recipient, 124 DBUS_TYPE_UNIX_FD)) 125 { 126 dbus_set_error (error, 127 DBUS_ERROR_NOT_SUPPORTED, 128 "Tried to send message with Unix file descriptors" 129 "to a client that doesn't support that."); 130 return FALSE; 131 } 132 133 /* Dispatch the message */ 134 if (!bus_transaction_send (transaction, addressed_recipient, message)) 135 { 136 BUS_SET_OOM (error); 137 return FALSE; 138 } 139 } 140 141 /* Now dispatch to others who look interested in this message */ 142 connections = bus_transaction_get_connections (transaction); 143 dbus_error_init (&tmp_error); 144 matchmaker = bus_context_get_matchmaker (context); 145 146 recipients = NULL; 147 if (!bus_matchmaker_get_recipients (matchmaker, connections, 148 sender, addressed_recipient, message, 149 &recipients)) 150 { 151 BUS_SET_OOM (error); 152 return FALSE; 153 } 154 155 link = _dbus_list_get_first_link (&recipients); 156 while (link != NULL) 157 { 158 DBusConnection *dest; 159 160 dest = link->data; 161 162 if (!send_one_message (dest, context, sender, addressed_recipient, 163 message, transaction, &tmp_error)) 164 break; 165 166 link = _dbus_list_get_next_link (&recipients, link); 167 } 168 169 _dbus_list_clear (&recipients); 170 171 if (dbus_error_is_set (&tmp_error)) 172 { 173 dbus_move_error (&tmp_error, error); 174 return FALSE; 175 } 176 else 177 return TRUE; 178 } 179 180 static DBusHandlerResult 181 bus_dispatch (DBusConnection *connection, 182 DBusMessage *message) 183 { 184 const char *sender, *service_name; 185 DBusError error; 186 BusTransaction *transaction; 187 BusContext *context; 188 DBusHandlerResult result; 189 DBusConnection *addressed_recipient; 190 191 result = DBUS_HANDLER_RESULT_HANDLED; 192 193 transaction = NULL; 194 addressed_recipient = NULL; 195 dbus_error_init (&error); 196 197 context = bus_connection_get_context (connection); 198 _dbus_assert (context != NULL); 199 200 /* If we can't even allocate an OOM error, we just go to sleep 201 * until we can. 202 */ 203 while (!bus_connection_preallocate_oom_error (connection)) 204 _dbus_wait_for_memory (); 205 206 /* Ref connection in case we disconnect it at some point in here */ 207 dbus_connection_ref (connection); 208 209 service_name = dbus_message_get_destination (message); 210 211 #ifdef DBUS_ENABLE_VERBOSE_MODE 212 { 213 const char *interface_name, *member_name, *error_name; 214 215 interface_name = dbus_message_get_interface (message); 216 member_name = dbus_message_get_member (message); 217 error_name = dbus_message_get_error_name (message); 218 219 _dbus_verbose ("DISPATCH: %s %s %s to %s\n", 220 interface_name ? interface_name : "(no interface)", 221 member_name ? member_name : "(no member)", 222 error_name ? error_name : "(no error name)", 223 service_name ? service_name : "peer"); 224 } 225 #endif /* DBUS_ENABLE_VERBOSE_MODE */ 226 227 /* If service_name is NULL, if it's a signal we send it to all 228 * connections with a match rule. If it's not a signal, there 229 * are some special cases here but mostly we just bail out. 230 */ 231 if (service_name == NULL) 232 { 233 if (dbus_message_is_signal (message, 234 DBUS_INTERFACE_LOCAL, 235 "Disconnected")) 236 { 237 bus_connection_disconnected (connection); 238 goto out; 239 } 240 241 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL) 242 { 243 /* DBusConnection also handles some of these automatically, we leave 244 * it to do so. 245 */ 246 result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 247 goto out; 248 } 249 } 250 251 /* Create our transaction */ 252 transaction = bus_transaction_new (context); 253 if (transaction == NULL) 254 { 255 BUS_SET_OOM (&error); 256 goto out; 257 } 258 259 /* Assign a sender to the message */ 260 if (bus_connection_is_active (connection)) 261 { 262 sender = bus_connection_get_name (connection); 263 _dbus_assert (sender != NULL); 264 265 if (!dbus_message_set_sender (message, sender)) 266 { 267 BUS_SET_OOM (&error); 268 goto out; 269 } 270 271 /* We need to refetch the service name here, because 272 * dbus_message_set_sender can cause the header to be 273 * reallocated, and thus the service_name pointer will become 274 * invalid. 275 */ 276 service_name = dbus_message_get_destination (message); 277 } 278 279 if (service_name && 280 strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */ 281 { 282 if (!bus_context_check_security_policy (context, transaction, 283 connection, NULL, NULL, message, &error)) 284 { 285 _dbus_verbose ("Security policy rejected message\n"); 286 goto out; 287 } 288 289 _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_DBUS); 290 if (!bus_driver_handle_message (connection, transaction, message, &error)) 291 goto out; 292 } 293 else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */ 294 { 295 _dbus_verbose ("Received message from non-registered client. Disconnecting.\n"); 296 dbus_connection_close (connection); 297 goto out; 298 } 299 else if (service_name != NULL) /* route to named service */ 300 { 301 DBusString service_string; 302 BusService *service; 303 BusRegistry *registry; 304 305 _dbus_assert (service_name != NULL); 306 307 registry = bus_connection_get_registry (connection); 308 309 _dbus_string_init_const (&service_string, service_name); 310 service = bus_registry_lookup (registry, &service_string); 311 312 if (service == NULL && dbus_message_get_auto_start (message)) 313 { 314 BusActivation *activation; 315 /* We can't do the security policy check here, since the addressed 316 * recipient service doesn't exist yet. We do it before sending the 317 * message after the service has been created. 318 */ 319 activation = bus_connection_get_activation (connection); 320 321 if (!bus_activation_activate_service (activation, connection, transaction, TRUE, 322 message, service_name, &error)) 323 { 324 _DBUS_ASSERT_ERROR_CONTENT_IS_SET (&error); 325 _dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name); 326 goto out; 327 } 328 329 goto out; 330 } 331 else if (service == NULL) 332 { 333 dbus_set_error (&error, 334 DBUS_ERROR_NAME_HAS_NO_OWNER, 335 "Name \"%s\" does not exist", 336 service_name); 337 goto out; 338 } 339 else 340 { 341 addressed_recipient = bus_service_get_primary_owners_connection (service); 342 _dbus_assert (addressed_recipient != NULL); 343 } 344 } 345 346 /* Now send the message to its destination (or not, if 347 * addressed_recipient == NULL), and match it against other connections' 348 * match rules. 349 */ 350 if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error)) 351 goto out; 352 353 out: 354 if (dbus_error_is_set (&error)) 355 { 356 if (!dbus_connection_get_is_connected (connection)) 357 { 358 /* If we disconnected it, we won't bother to send it any error 359 * messages. 360 */ 361 _dbus_verbose ("Not sending error to connection we disconnected\n"); 362 } 363 else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 364 { 365 bus_connection_send_oom_error (connection, message); 366 367 /* cancel transaction due to OOM */ 368 if (transaction != NULL) 369 { 370 bus_transaction_cancel_and_free (transaction); 371 transaction = NULL; 372 } 373 } 374 else 375 { 376 /* Try to send the real error, if no mem to do that, send 377 * the OOM error 378 */ 379 _dbus_assert (transaction != NULL); 380 if (!bus_transaction_send_error_reply (transaction, connection, 381 &error, message)) 382 { 383 bus_connection_send_oom_error (connection, message); 384 385 /* cancel transaction due to OOM */ 386 if (transaction != NULL) 387 { 388 bus_transaction_cancel_and_free (transaction); 389 transaction = NULL; 390 } 391 } 392 } 393 394 395 dbus_error_free (&error); 396 } 397 398 if (transaction != NULL) 399 { 400 bus_transaction_execute_and_free (transaction); 401 } 402 403 dbus_connection_unref (connection); 404 405 return result; 406 } 407 408 static DBusHandlerResult 409 bus_dispatch_message_filter (DBusConnection *connection, 410 DBusMessage *message, 411 void *user_data) 412 { 413 return bus_dispatch (connection, message); 414 } 415 416 dbus_bool_t 417 bus_dispatch_add_connection (DBusConnection *connection) 418 { 419 if (!dbus_connection_add_filter (connection, 420 bus_dispatch_message_filter, 421 NULL, NULL)) 422 return FALSE; 423 424 return TRUE; 425 } 426 427 void 428 bus_dispatch_remove_connection (DBusConnection *connection) 429 { 430 /* Here we tell the bus driver that we want to get off. */ 431 bus_driver_remove_connection (connection); 432 433 dbus_connection_remove_filter (connection, 434 bus_dispatch_message_filter, 435 NULL); 436 } 437 438 #ifdef DBUS_BUILD_TESTS 439 440 #include <stdio.h> 441 442 /* This is used to know whether we need to block in order to finish 443 * sending a message, or whether the initial dbus_connection_send() 444 * already flushed the queue. 445 */ 446 #define SEND_PENDING(connection) (dbus_connection_has_messages_to_send (connection)) 447 448 typedef dbus_bool_t (* Check1Func) (BusContext *context); 449 typedef dbus_bool_t (* Check2Func) (BusContext *context, 450 DBusConnection *connection); 451 452 static dbus_bool_t check_no_leftovers (BusContext *context); 453 454 static void 455 block_connection_until_message_from_bus (BusContext *context, 456 DBusConnection *connection, 457 const char *what_is_expected) 458 { 459 _dbus_verbose ("expecting: %s\n", what_is_expected); 460 461 while (dbus_connection_get_dispatch_status (connection) == 462 DBUS_DISPATCH_COMPLETE && 463 dbus_connection_get_is_connected (connection)) 464 { 465 bus_test_run_bus_loop (context, TRUE); 466 bus_test_run_clients_loop (FALSE); 467 } 468 } 469 470 static void 471 spin_connection_until_authenticated (BusContext *context, 472 DBusConnection *connection) 473 { 474 _dbus_verbose ("Spinning to auth connection %p\n", connection); 475 while (!dbus_connection_get_is_authenticated (connection) && 476 dbus_connection_get_is_connected (connection)) 477 { 478 bus_test_run_bus_loop (context, FALSE); 479 bus_test_run_clients_loop (FALSE); 480 } 481 _dbus_verbose (" ... done spinning to auth connection %p\n", connection); 482 } 483 484 /* compensate for fact that pop_message() can return #NULL due to OOM */ 485 static DBusMessage* 486 pop_message_waiting_for_memory (DBusConnection *connection) 487 { 488 while (dbus_connection_get_dispatch_status (connection) == 489 DBUS_DISPATCH_NEED_MEMORY) 490 _dbus_wait_for_memory (); 491 492 return dbus_connection_pop_message (connection); 493 } 494 495 static DBusMessage* 496 borrow_message_waiting_for_memory (DBusConnection *connection) 497 { 498 while (dbus_connection_get_dispatch_status (connection) == 499 DBUS_DISPATCH_NEED_MEMORY) 500 _dbus_wait_for_memory (); 501 502 return dbus_connection_borrow_message (connection); 503 } 504 505 static void 506 warn_unexpected_real (DBusConnection *connection, 507 DBusMessage *message, 508 const char *expected, 509 const char *function, 510 int line) 511 { 512 if (message) 513 _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n", 514 function, line, 515 dbus_message_get_interface (message) ? 516 dbus_message_get_interface (message) : "(unset)", 517 dbus_message_get_member (message) ? 518 dbus_message_get_member (message) : "(unset)", 519 dbus_message_get_error_name (message) ? 520 dbus_message_get_error_name (message) : "(unset)", 521 connection, 522 expected); 523 else 524 _dbus_warn ("%s:%d received no message on %p, expecting %s\n", 525 function, line, connection, expected); 526 } 527 528 #define warn_unexpected(connection, message, expected) \ 529 warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__) 530 531 static void 532 verbose_message_received (DBusConnection *connection, 533 DBusMessage *message) 534 { 535 _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n", 536 dbus_message_get_interface (message) ? 537 dbus_message_get_interface (message) : "(unset)", 538 dbus_message_get_member (message) ? 539 dbus_message_get_member (message) : "(unset)", 540 dbus_message_get_error_name (message) ? 541 dbus_message_get_error_name (message) : "(unset)", 542 connection); 543 } 544 545 typedef enum 546 { 547 SERVICE_CREATED, 548 OWNER_CHANGED, 549 SERVICE_DELETED 550 } ServiceInfoKind; 551 552 typedef struct 553 { 554 ServiceInfoKind expected_kind; 555 const char *expected_service_name; 556 dbus_bool_t failed; 557 DBusConnection *skip_connection; 558 } CheckServiceOwnerChangedData; 559 560 static dbus_bool_t 561 check_service_owner_changed_foreach (DBusConnection *connection, 562 void *data) 563 { 564 CheckServiceOwnerChangedData *d = data; 565 DBusMessage *message; 566 DBusError error; 567 const char *service_name, *old_owner, *new_owner; 568 569 if (d->expected_kind == SERVICE_CREATED 570 && connection == d->skip_connection) 571 return TRUE; 572 573 dbus_error_init (&error); 574 d->failed = TRUE; 575 576 message = pop_message_waiting_for_memory (connection); 577 if (message == NULL) 578 { 579 _dbus_warn ("Did not receive a message on %p, expecting %s\n", 580 connection, "NameOwnerChanged"); 581 goto out; 582 } 583 else if (!dbus_message_is_signal (message, 584 DBUS_INTERFACE_DBUS, 585 "NameOwnerChanged")) 586 { 587 warn_unexpected (connection, message, "NameOwnerChanged"); 588 589 goto out; 590 } 591 else 592 { 593 reget_service_info_data: 594 service_name = NULL; 595 old_owner = NULL; 596 new_owner = NULL; 597 598 dbus_message_get_args (message, &error, 599 DBUS_TYPE_STRING, &service_name, 600 DBUS_TYPE_STRING, &old_owner, 601 DBUS_TYPE_STRING, &new_owner, 602 DBUS_TYPE_INVALID); 603 604 if (dbus_error_is_set (&error)) 605 { 606 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 607 { 608 dbus_error_free (&error); 609 _dbus_wait_for_memory (); 610 goto reget_service_info_data; 611 } 612 else 613 { 614 _dbus_warn ("Did not get the expected arguments\n"); 615 goto out; 616 } 617 } 618 619 if ((d->expected_kind == SERVICE_CREATED && ( old_owner[0] || !new_owner[0])) 620 || (d->expected_kind == OWNER_CHANGED && (!old_owner[0] || !new_owner[0])) 621 || (d->expected_kind == SERVICE_DELETED && (!old_owner[0] || new_owner[0]))) 622 { 623 _dbus_warn ("inconsistent NameOwnerChanged arguments\n"); 624 goto out; 625 } 626 627 if (strcmp (service_name, d->expected_service_name) != 0) 628 { 629 _dbus_warn ("expected info on service %s, got info on %s\n", 630 d->expected_service_name, 631 service_name); 632 goto out; 633 } 634 635 if (*service_name == ':' && new_owner[0] 636 && strcmp (service_name, new_owner) != 0) 637 { 638 _dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n", 639 service_name, old_owner, new_owner); 640 goto out; 641 } 642 } 643 644 d->failed = FALSE; 645 646 out: 647 dbus_error_free (&error); 648 649 if (message) 650 dbus_message_unref (message); 651 652 return !d->failed; 653 } 654 655 656 static void 657 kill_client_connection (BusContext *context, 658 DBusConnection *connection) 659 { 660 char *base_service; 661 const char *s; 662 CheckServiceOwnerChangedData socd; 663 664 _dbus_verbose ("killing connection %p\n", connection); 665 666 s = dbus_bus_get_unique_name (connection); 667 _dbus_assert (s != NULL); 668 669 while ((base_service = _dbus_strdup (s)) == NULL) 670 _dbus_wait_for_memory (); 671 672 dbus_connection_ref (connection); 673 674 /* kick in the disconnect handler that unrefs the connection */ 675 dbus_connection_close (connection); 676 677 bus_test_run_everything (context); 678 679 _dbus_assert (bus_test_client_listed (connection)); 680 681 /* Run disconnect handler in test.c */ 682 if (bus_connection_dispatch_one_message (connection)) 683 _dbus_assert_not_reached ("something received on connection being killed other than the disconnect"); 684 685 _dbus_assert (!dbus_connection_get_is_connected (connection)); 686 dbus_connection_unref (connection); 687 connection = NULL; 688 _dbus_assert (!bus_test_client_listed (connection)); 689 690 socd.expected_kind = SERVICE_DELETED; 691 socd.expected_service_name = base_service; 692 socd.failed = FALSE; 693 socd.skip_connection = NULL; 694 695 bus_test_clients_foreach (check_service_owner_changed_foreach, 696 &socd); 697 698 dbus_free (base_service); 699 700 if (socd.failed) 701 _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages"); 702 703 if (!check_no_leftovers (context)) 704 _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client"); 705 } 706 707 static void 708 kill_client_connection_unchecked (DBusConnection *connection) 709 { 710 /* This kills the connection without expecting it to affect 711 * the rest of the bus. 712 */ 713 _dbus_verbose ("Unchecked kill of connection %p\n", connection); 714 715 dbus_connection_ref (connection); 716 dbus_connection_close (connection); 717 /* dispatching disconnect handler will unref once */ 718 if (bus_connection_dispatch_one_message (connection)) 719 _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register"); 720 721 _dbus_assert (!bus_test_client_listed (connection)); 722 dbus_connection_unref (connection); 723 } 724 725 typedef struct 726 { 727 dbus_bool_t failed; 728 } CheckNoMessagesData; 729 730 static dbus_bool_t 731 check_no_messages_foreach (DBusConnection *connection, 732 void *data) 733 { 734 CheckNoMessagesData *d = data; 735 DBusMessage *message; 736 737 message = pop_message_waiting_for_memory (connection); 738 if (message != NULL) 739 { 740 warn_unexpected (connection, message, "no messages"); 741 742 d->failed = TRUE; 743 } 744 745 if (message) 746 dbus_message_unref (message); 747 return !d->failed; 748 } 749 750 static dbus_bool_t 751 check_no_leftovers (BusContext *context) 752 { 753 CheckNoMessagesData nmd; 754 755 nmd.failed = FALSE; 756 bus_test_clients_foreach (check_no_messages_foreach, 757 &nmd); 758 759 if (nmd.failed) 760 { 761 _dbus_verbose ("leftover message found\n"); 762 return FALSE; 763 } 764 else 765 return TRUE; 766 } 767 768 /* returns TRUE if the correct thing happens, 769 * but the correct thing may include OOM errors. 770 */ 771 static dbus_bool_t 772 check_hello_message (BusContext *context, 773 DBusConnection *connection) 774 { 775 DBusMessage *message; 776 DBusMessage *name_message; 777 dbus_uint32_t serial; 778 dbus_bool_t retval; 779 DBusError error; 780 const char *name; 781 const char *acquired; 782 783 retval = FALSE; 784 dbus_error_init (&error); 785 name = NULL; 786 acquired = NULL; 787 message = NULL; 788 name_message = NULL; 789 790 _dbus_verbose ("check_hello_message for %p\n", connection); 791 792 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 793 DBUS_PATH_DBUS, 794 DBUS_INTERFACE_DBUS, 795 "Hello"); 796 797 if (message == NULL) 798 return TRUE; 799 800 dbus_connection_ref (connection); /* because we may get disconnected */ 801 802 if (!dbus_connection_send (connection, message, &serial)) 803 { 804 dbus_message_unref (message); 805 dbus_connection_unref (connection); 806 return TRUE; 807 } 808 809 _dbus_assert (dbus_message_has_signature (message, "")); 810 811 dbus_message_unref (message); 812 message = NULL; 813 814 if (!dbus_connection_get_is_connected (connection)) 815 { 816 _dbus_verbose ("connection was disconnected (presumably auth failed)\n"); 817 818 dbus_connection_unref (connection); 819 820 return TRUE; 821 } 822 823 /* send our message */ 824 bus_test_run_clients_loop (SEND_PENDING (connection)); 825 826 if (!dbus_connection_get_is_connected (connection)) 827 { 828 _dbus_verbose ("connection was disconnected (presumably auth failed)\n"); 829 830 dbus_connection_unref (connection); 831 832 return TRUE; 833 } 834 835 block_connection_until_message_from_bus (context, connection, "reply to Hello"); 836 837 if (!dbus_connection_get_is_connected (connection)) 838 { 839 _dbus_verbose ("connection was disconnected (presumably auth failed)\n"); 840 841 dbus_connection_unref (connection); 842 843 return TRUE; 844 } 845 846 dbus_connection_unref (connection); 847 848 message = pop_message_waiting_for_memory (connection); 849 if (message == NULL) 850 { 851 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 852 "Hello", serial, connection); 853 goto out; 854 } 855 856 verbose_message_received (connection, message); 857 858 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 859 { 860 _dbus_warn ("Message has wrong sender %s\n", 861 dbus_message_get_sender (message) ? 862 dbus_message_get_sender (message) : "(none)"); 863 goto out; 864 } 865 866 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 867 { 868 if (dbus_message_is_error (message, 869 DBUS_ERROR_NO_MEMORY)) 870 { 871 ; /* good, this is a valid response */ 872 } 873 else 874 { 875 warn_unexpected (connection, message, "not this error"); 876 877 goto out; 878 } 879 } 880 else 881 { 882 CheckServiceOwnerChangedData socd; 883 884 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN) 885 { 886 ; /* good, expected */ 887 } 888 else 889 { 890 warn_unexpected (connection, message, "method return for Hello"); 891 892 goto out; 893 } 894 895 retry_get_hello_name: 896 if (!dbus_message_get_args (message, &error, 897 DBUS_TYPE_STRING, &name, 898 DBUS_TYPE_INVALID)) 899 { 900 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 901 { 902 _dbus_verbose ("no memory to get service name arg from hello\n"); 903 dbus_error_free (&error); 904 _dbus_wait_for_memory (); 905 goto retry_get_hello_name; 906 } 907 else 908 { 909 _dbus_assert (dbus_error_is_set (&error)); 910 _dbus_warn ("Did not get the expected single string argument to hello\n"); 911 goto out; 912 } 913 } 914 915 _dbus_verbose ("Got hello name: %s\n", name); 916 917 while (!dbus_bus_set_unique_name (connection, name)) 918 _dbus_wait_for_memory (); 919 920 socd.expected_kind = SERVICE_CREATED; 921 socd.expected_service_name = name; 922 socd.failed = FALSE; 923 socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */ 924 bus_test_clients_foreach (check_service_owner_changed_foreach, 925 &socd); 926 927 if (socd.failed) 928 goto out; 929 930 name_message = message; 931 /* Client should also have gotten ServiceAcquired */ 932 933 message = pop_message_waiting_for_memory (connection); 934 if (message == NULL) 935 { 936 _dbus_warn ("Expecting %s, got nothing\n", 937 "NameAcquired"); 938 goto out; 939 } 940 if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, 941 "NameAcquired")) 942 { 943 _dbus_warn ("Expecting %s, got smthg else\n", 944 "NameAcquired"); 945 goto out; 946 } 947 948 retry_get_acquired_name: 949 if (!dbus_message_get_args (message, &error, 950 DBUS_TYPE_STRING, &acquired, 951 DBUS_TYPE_INVALID)) 952 { 953 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 954 { 955 _dbus_verbose ("no memory to get service name arg from acquired\n"); 956 dbus_error_free (&error); 957 _dbus_wait_for_memory (); 958 goto retry_get_acquired_name; 959 } 960 else 961 { 962 _dbus_assert (dbus_error_is_set (&error)); 963 _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n"); 964 goto out; 965 } 966 } 967 968 _dbus_verbose ("Got acquired name: %s\n", acquired); 969 970 if (strcmp (acquired, name) != 0) 971 { 972 _dbus_warn ("Acquired name is %s but expected %s\n", 973 acquired, name); 974 goto out; 975 } 976 acquired = NULL; 977 } 978 979 if (!check_no_leftovers (context)) 980 goto out; 981 982 retval = TRUE; 983 984 out: 985 _dbus_verbose ("ending - retval = %d\n", retval); 986 987 dbus_error_free (&error); 988 989 if (message) 990 dbus_message_unref (message); 991 992 if (name_message) 993 dbus_message_unref (name_message); 994 995 return retval; 996 } 997 998 /* returns TRUE if the correct thing happens, 999 * but the correct thing may include OOM errors. 1000 */ 1001 static dbus_bool_t 1002 check_double_hello_message (BusContext *context, 1003 DBusConnection *connection) 1004 { 1005 DBusMessage *message; 1006 dbus_uint32_t serial; 1007 dbus_bool_t retval; 1008 DBusError error; 1009 1010 retval = FALSE; 1011 dbus_error_init (&error); 1012 message = NULL; 1013 1014 _dbus_verbose ("check_double_hello_message for %p\n", connection); 1015 1016 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 1017 DBUS_PATH_DBUS, 1018 DBUS_INTERFACE_DBUS, 1019 "Hello"); 1020 1021 if (message == NULL) 1022 return TRUE; 1023 1024 if (!dbus_connection_send (connection, message, &serial)) 1025 { 1026 dbus_message_unref (message); 1027 return TRUE; 1028 } 1029 1030 dbus_message_unref (message); 1031 message = NULL; 1032 1033 /* send our message */ 1034 bus_test_run_clients_loop (SEND_PENDING (connection)); 1035 1036 dbus_connection_ref (connection); /* because we may get disconnected */ 1037 block_connection_until_message_from_bus (context, connection, "reply to Hello"); 1038 1039 if (!dbus_connection_get_is_connected (connection)) 1040 { 1041 _dbus_verbose ("connection was disconnected\n"); 1042 1043 dbus_connection_unref (connection); 1044 1045 return TRUE; 1046 } 1047 1048 dbus_connection_unref (connection); 1049 1050 message = pop_message_waiting_for_memory (connection); 1051 if (message == NULL) 1052 { 1053 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1054 "Hello", serial, connection); 1055 goto out; 1056 } 1057 1058 verbose_message_received (connection, message); 1059 1060 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 1061 { 1062 _dbus_warn ("Message has wrong sender %s\n", 1063 dbus_message_get_sender (message) ? 1064 dbus_message_get_sender (message) : "(none)"); 1065 goto out; 1066 } 1067 1068 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR) 1069 { 1070 warn_unexpected (connection, message, "method return for Hello"); 1071 goto out; 1072 } 1073 1074 if (!check_no_leftovers (context)) 1075 goto out; 1076 1077 retval = TRUE; 1078 1079 out: 1080 dbus_error_free (&error); 1081 1082 if (message) 1083 dbus_message_unref (message); 1084 1085 return retval; 1086 } 1087 1088 /* returns TRUE if the correct thing happens, 1089 * but the correct thing may include OOM errors. 1090 */ 1091 static dbus_bool_t 1092 check_get_connection_unix_user (BusContext *context, 1093 DBusConnection *connection) 1094 { 1095 DBusMessage *message; 1096 dbus_uint32_t serial; 1097 dbus_bool_t retval; 1098 DBusError error; 1099 const char *base_service_name; 1100 dbus_uint32_t uid; 1101 1102 retval = FALSE; 1103 dbus_error_init (&error); 1104 message = NULL; 1105 1106 _dbus_verbose ("check_get_connection_unix_user for %p\n", connection); 1107 1108 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 1109 DBUS_PATH_DBUS, 1110 DBUS_INTERFACE_DBUS, 1111 "GetConnectionUnixUser"); 1112 1113 if (message == NULL) 1114 return TRUE; 1115 1116 base_service_name = dbus_bus_get_unique_name (connection); 1117 1118 if (!dbus_message_append_args (message, 1119 DBUS_TYPE_STRING, &base_service_name, 1120 DBUS_TYPE_INVALID)) 1121 { 1122 dbus_message_unref (message); 1123 return TRUE; 1124 } 1125 1126 if (!dbus_connection_send (connection, message, &serial)) 1127 { 1128 dbus_message_unref (message); 1129 return TRUE; 1130 } 1131 1132 /* send our message */ 1133 bus_test_run_clients_loop (SEND_PENDING (connection)); 1134 1135 dbus_message_unref (message); 1136 message = NULL; 1137 1138 dbus_connection_ref (connection); /* because we may get disconnected */ 1139 block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixUser"); 1140 1141 if (!dbus_connection_get_is_connected (connection)) 1142 { 1143 _dbus_verbose ("connection was disconnected\n"); 1144 1145 dbus_connection_unref (connection); 1146 1147 return TRUE; 1148 } 1149 1150 dbus_connection_unref (connection); 1151 1152 message = pop_message_waiting_for_memory (connection); 1153 if (message == NULL) 1154 { 1155 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1156 "GetConnectionUnixUser", serial, connection); 1157 goto out; 1158 } 1159 1160 verbose_message_received (connection, message); 1161 1162 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 1163 { 1164 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY)) 1165 { 1166 ; /* good, this is a valid response */ 1167 } 1168 else 1169 { 1170 warn_unexpected (connection, message, "not this error"); 1171 1172 goto out; 1173 } 1174 } 1175 else 1176 { 1177 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN) 1178 { 1179 ; /* good, expected */ 1180 } 1181 else 1182 { 1183 warn_unexpected (connection, message, 1184 "method_return for GetConnectionUnixUser"); 1185 1186 goto out; 1187 } 1188 1189 retry_get_property: 1190 1191 if (!dbus_message_get_args (message, &error, 1192 DBUS_TYPE_UINT32, &uid, 1193 DBUS_TYPE_INVALID)) 1194 { 1195 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1196 { 1197 _dbus_verbose ("no memory to get uid by GetConnectionUnixUser\n"); 1198 dbus_error_free (&error); 1199 _dbus_wait_for_memory (); 1200 goto retry_get_property; 1201 } 1202 else 1203 { 1204 _dbus_assert (dbus_error_is_set (&error)); 1205 _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixUser\n"); 1206 goto out; 1207 } 1208 } 1209 } 1210 1211 if (!check_no_leftovers (context)) 1212 goto out; 1213 1214 retval = TRUE; 1215 1216 out: 1217 dbus_error_free (&error); 1218 1219 if (message) 1220 dbus_message_unref (message); 1221 1222 return retval; 1223 } 1224 1225 /* returns TRUE if the correct thing happens, 1226 * but the correct thing may include OOM errors. 1227 */ 1228 static dbus_bool_t 1229 check_get_connection_unix_process_id (BusContext *context, 1230 DBusConnection *connection) 1231 { 1232 DBusMessage *message; 1233 dbus_uint32_t serial; 1234 dbus_bool_t retval; 1235 DBusError error; 1236 const char *base_service_name; 1237 dbus_uint32_t pid; 1238 1239 retval = FALSE; 1240 dbus_error_init (&error); 1241 message = NULL; 1242 1243 _dbus_verbose ("check_get_connection_unix_process_id for %p\n", connection); 1244 1245 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 1246 DBUS_PATH_DBUS, 1247 DBUS_INTERFACE_DBUS, 1248 "GetConnectionUnixProcessID"); 1249 1250 if (message == NULL) 1251 return TRUE; 1252 1253 base_service_name = dbus_bus_get_unique_name (connection); 1254 1255 if (!dbus_message_append_args (message, 1256 DBUS_TYPE_STRING, &base_service_name, 1257 DBUS_TYPE_INVALID)) 1258 { 1259 dbus_message_unref (message); 1260 return TRUE; 1261 } 1262 1263 if (!dbus_connection_send (connection, message, &serial)) 1264 { 1265 dbus_message_unref (message); 1266 return TRUE; 1267 } 1268 1269 /* send our message */ 1270 bus_test_run_clients_loop (SEND_PENDING (connection)); 1271 1272 dbus_message_unref (message); 1273 message = NULL; 1274 1275 dbus_connection_ref (connection); /* because we may get disconnected */ 1276 block_connection_until_message_from_bus (context, connection, "reply to GetConnectionUnixProcessID"); 1277 1278 if (!dbus_connection_get_is_connected (connection)) 1279 { 1280 _dbus_verbose ("connection was disconnected\n"); 1281 1282 dbus_connection_unref (connection); 1283 1284 return TRUE; 1285 } 1286 1287 dbus_connection_unref (connection); 1288 1289 message = pop_message_waiting_for_memory (connection); 1290 if (message == NULL) 1291 { 1292 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1293 "GetConnectionUnixProcessID", serial, connection); 1294 goto out; 1295 } 1296 1297 verbose_message_received (connection, message); 1298 1299 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 1300 { 1301 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY)) 1302 { 1303 ; /* good, this is a valid response */ 1304 } 1305 #ifdef DBUS_WIN 1306 else if (dbus_message_is_error (message, DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN)) 1307 { 1308 /* We are expecting this error, since we know in the test suite we aren't 1309 * talking to a client running on UNIX 1310 */ 1311 _dbus_verbose ("Windows correctly does not support GetConnectionUnixProcessID\n"); 1312 } 1313 #endif 1314 else 1315 { 1316 warn_unexpected (connection, message, "not this error"); 1317 1318 goto out; 1319 } 1320 } 1321 else 1322 { 1323 #ifdef DBUS_WIN 1324 warn_unexpected (connection, message, "GetConnectionUnixProcessID to fail on Windows"); 1325 goto out; 1326 #else 1327 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN) 1328 { 1329 ; /* good, expected */ 1330 } 1331 else 1332 { 1333 warn_unexpected (connection, message, 1334 "method_return for GetConnectionUnixProcessID"); 1335 1336 goto out; 1337 } 1338 1339 retry_get_property: 1340 1341 if (!dbus_message_get_args (message, &error, 1342 DBUS_TYPE_UINT32, &pid, 1343 DBUS_TYPE_INVALID)) 1344 { 1345 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1346 { 1347 _dbus_verbose ("no memory to get pid by GetConnectionUnixProcessID\n"); 1348 dbus_error_free (&error); 1349 _dbus_wait_for_memory (); 1350 goto retry_get_property; 1351 } 1352 else 1353 { 1354 _dbus_assert (dbus_error_is_set (&error)); 1355 _dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixProcessID\n"); 1356 goto out; 1357 } 1358 } 1359 else 1360 { 1361 /* test if returned pid is the same as our own pid 1362 * 1363 * @todo It would probably be good to restructure the tests 1364 * in a way so our parent is the bus that we're testing 1365 * cause then we can test that the pid returned matches 1366 * getppid() 1367 */ 1368 if (pid != (dbus_uint32_t) _dbus_getpid ()) 1369 { 1370 _dbus_assert (dbus_error_is_set (&error)); 1371 _dbus_warn ("Result from GetConnectionUnixProcessID is not our own pid\n"); 1372 goto out; 1373 } 1374 } 1375 #endif /* !DBUS_WIN */ 1376 } 1377 1378 if (!check_no_leftovers (context)) 1379 goto out; 1380 1381 retval = TRUE; 1382 1383 out: 1384 dbus_error_free (&error); 1385 1386 if (message) 1387 dbus_message_unref (message); 1388 1389 return retval; 1390 } 1391 1392 /* returns TRUE if the correct thing happens, 1393 * but the correct thing may include OOM errors. 1394 */ 1395 static dbus_bool_t 1396 check_add_match_all (BusContext *context, 1397 DBusConnection *connection) 1398 { 1399 DBusMessage *message; 1400 dbus_bool_t retval; 1401 dbus_uint32_t serial; 1402 DBusError error; 1403 const char *empty = ""; 1404 1405 retval = FALSE; 1406 dbus_error_init (&error); 1407 message = NULL; 1408 1409 _dbus_verbose ("check_add_match_all for %p\n", connection); 1410 1411 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 1412 DBUS_PATH_DBUS, 1413 DBUS_INTERFACE_DBUS, 1414 "AddMatch"); 1415 1416 if (message == NULL) 1417 return TRUE; 1418 1419 /* empty string match rule matches everything */ 1420 if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &empty, 1421 DBUS_TYPE_INVALID)) 1422 { 1423 dbus_message_unref (message); 1424 return TRUE; 1425 } 1426 1427 if (!dbus_connection_send (connection, message, &serial)) 1428 { 1429 dbus_message_unref (message); 1430 return TRUE; 1431 } 1432 1433 dbus_message_unref (message); 1434 message = NULL; 1435 1436 dbus_connection_ref (connection); /* because we may get disconnected */ 1437 1438 /* send our message */ 1439 bus_test_run_clients_loop (SEND_PENDING (connection)); 1440 1441 if (!dbus_connection_get_is_connected (connection)) 1442 { 1443 _dbus_verbose ("connection was disconnected\n"); 1444 1445 dbus_connection_unref (connection); 1446 1447 return TRUE; 1448 } 1449 1450 block_connection_until_message_from_bus (context, connection, "reply to AddMatch"); 1451 1452 if (!dbus_connection_get_is_connected (connection)) 1453 { 1454 _dbus_verbose ("connection was disconnected\n"); 1455 1456 dbus_connection_unref (connection); 1457 1458 return TRUE; 1459 } 1460 1461 dbus_connection_unref (connection); 1462 1463 message = pop_message_waiting_for_memory (connection); 1464 if (message == NULL) 1465 { 1466 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1467 "AddMatch", serial, connection); 1468 goto out; 1469 } 1470 1471 verbose_message_received (connection, message); 1472 1473 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 1474 { 1475 _dbus_warn ("Message has wrong sender %s\n", 1476 dbus_message_get_sender (message) ? 1477 dbus_message_get_sender (message) : "(none)"); 1478 goto out; 1479 } 1480 1481 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 1482 { 1483 if (dbus_message_is_error (message, 1484 DBUS_ERROR_NO_MEMORY)) 1485 { 1486 ; /* good, this is a valid response */ 1487 } 1488 else 1489 { 1490 warn_unexpected (connection, message, "not this error"); 1491 1492 goto out; 1493 } 1494 } 1495 else 1496 { 1497 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN) 1498 { 1499 ; /* good, expected */ 1500 _dbus_assert (dbus_message_get_reply_serial (message) == serial); 1501 } 1502 else 1503 { 1504 warn_unexpected (connection, message, "method return for AddMatch"); 1505 1506 goto out; 1507 } 1508 } 1509 1510 if (!check_no_leftovers (context)) 1511 goto out; 1512 1513 retval = TRUE; 1514 1515 out: 1516 dbus_error_free (&error); 1517 1518 if (message) 1519 dbus_message_unref (message); 1520 1521 return retval; 1522 } 1523 1524 /* returns TRUE if the correct thing happens, 1525 * but the correct thing may include OOM errors. 1526 */ 1527 static dbus_bool_t 1528 check_hello_connection (BusContext *context) 1529 { 1530 DBusConnection *connection; 1531 DBusError error; 1532 1533 dbus_error_init (&error); 1534 1535 connection = dbus_connection_open_private (TEST_CONNECTION, &error); 1536 if (connection == NULL) 1537 { 1538 _DBUS_ASSERT_ERROR_IS_SET (&error); 1539 dbus_error_free (&error); 1540 return TRUE; 1541 } 1542 1543 if (!bus_setup_debug_client (connection)) 1544 { 1545 dbus_connection_close (connection); 1546 dbus_connection_unref (connection); 1547 return TRUE; 1548 } 1549 1550 spin_connection_until_authenticated (context, connection); 1551 1552 if (!check_hello_message (context, connection)) 1553 return FALSE; 1554 1555 if (dbus_bus_get_unique_name (connection) == NULL) 1556 { 1557 /* We didn't successfully register, so we can't 1558 * do the usual kill_client_connection() checks 1559 */ 1560 kill_client_connection_unchecked (connection); 1561 } 1562 else 1563 { 1564 if (!check_add_match_all (context, connection)) 1565 return FALSE; 1566 1567 kill_client_connection (context, connection); 1568 } 1569 1570 return TRUE; 1571 } 1572 1573 #define NONEXISTENT_SERVICE_NAME "test.this.service.does.not.exist.ewuoiurjdfxcvn" 1574 1575 /* returns TRUE if the correct thing happens, 1576 * but the correct thing may include OOM errors. 1577 */ 1578 static dbus_bool_t 1579 check_nonexistent_service_no_auto_start (BusContext *context, 1580 DBusConnection *connection) 1581 { 1582 DBusMessage *message; 1583 dbus_uint32_t serial; 1584 dbus_bool_t retval; 1585 const char *nonexistent = NONEXISTENT_SERVICE_NAME; 1586 dbus_uint32_t flags; 1587 1588 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 1589 DBUS_PATH_DBUS, 1590 DBUS_INTERFACE_DBUS, 1591 "StartServiceByName"); 1592 1593 if (message == NULL) 1594 return TRUE; 1595 1596 dbus_message_set_auto_start (message, FALSE); 1597 1598 flags = 0; 1599 if (!dbus_message_append_args (message, 1600 DBUS_TYPE_STRING, &nonexistent, 1601 DBUS_TYPE_UINT32, &flags, 1602 DBUS_TYPE_INVALID)) 1603 { 1604 dbus_message_unref (message); 1605 return TRUE; 1606 } 1607 1608 if (!dbus_connection_send (connection, message, &serial)) 1609 { 1610 dbus_message_unref (message); 1611 return TRUE; 1612 } 1613 1614 dbus_message_unref (message); 1615 message = NULL; 1616 1617 bus_test_run_everything (context); 1618 block_connection_until_message_from_bus (context, connection, "reply to ActivateService on nonexistent"); 1619 bus_test_run_everything (context); 1620 1621 if (!dbus_connection_get_is_connected (connection)) 1622 { 1623 _dbus_verbose ("connection was disconnected\n"); 1624 return TRUE; 1625 } 1626 1627 retval = FALSE; 1628 1629 message = pop_message_waiting_for_memory (connection); 1630 if (message == NULL) 1631 { 1632 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1633 "StartServiceByName", serial, connection); 1634 goto out; 1635 } 1636 1637 verbose_message_received (connection, message); 1638 1639 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 1640 { 1641 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 1642 { 1643 _dbus_warn ("Message has wrong sender %s\n", 1644 dbus_message_get_sender (message) ? 1645 dbus_message_get_sender (message) : "(none)"); 1646 goto out; 1647 } 1648 1649 if (dbus_message_is_error (message, 1650 DBUS_ERROR_NO_MEMORY)) 1651 { 1652 ; /* good, this is a valid response */ 1653 } 1654 else if (dbus_message_is_error (message, 1655 DBUS_ERROR_SERVICE_UNKNOWN)) 1656 { 1657 ; /* good, this is expected also */ 1658 } 1659 else 1660 { 1661 warn_unexpected (connection, message, "not this error"); 1662 goto out; 1663 } 1664 } 1665 else 1666 { 1667 _dbus_warn ("Did not expect to successfully activate %s\n", 1668 NONEXISTENT_SERVICE_NAME); 1669 goto out; 1670 } 1671 1672 retval = TRUE; 1673 1674 out: 1675 if (message) 1676 dbus_message_unref (message); 1677 1678 return retval; 1679 } 1680 1681 /* returns TRUE if the correct thing happens, 1682 * but the correct thing may include OOM errors. 1683 */ 1684 static dbus_bool_t 1685 check_nonexistent_service_auto_start (BusContext *context, 1686 DBusConnection *connection) 1687 { 1688 DBusMessage *message; 1689 dbus_uint32_t serial; 1690 dbus_bool_t retval; 1691 1692 message = dbus_message_new_method_call (NONEXISTENT_SERVICE_NAME, 1693 "/org/freedesktop/TestSuite", 1694 "org.freedesktop.TestSuite", 1695 "Echo"); 1696 1697 if (message == NULL) 1698 return TRUE; 1699 1700 if (!dbus_connection_send (connection, message, &serial)) 1701 { 1702 dbus_message_unref (message); 1703 return TRUE; 1704 } 1705 1706 dbus_message_unref (message); 1707 message = NULL; 1708 1709 bus_test_run_everything (context); 1710 block_connection_until_message_from_bus (context, connection, "reply to Echo"); 1711 bus_test_run_everything (context); 1712 1713 if (!dbus_connection_get_is_connected (connection)) 1714 { 1715 _dbus_verbose ("connection was disconnected\n"); 1716 return TRUE; 1717 } 1718 1719 retval = FALSE; 1720 1721 message = pop_message_waiting_for_memory (connection); 1722 1723 if (message == NULL) 1724 { 1725 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 1726 "Echo message (auto activation)", serial, connection); 1727 goto out; 1728 } 1729 1730 verbose_message_received (connection, message); 1731 1732 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 1733 { 1734 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 1735 { 1736 _dbus_warn ("Message has wrong sender %s\n", 1737 dbus_message_get_sender (message) ? 1738 dbus_message_get_sender (message) : "(none)"); 1739 goto out; 1740 } 1741 1742 if (dbus_message_is_error (message, 1743 DBUS_ERROR_NO_MEMORY)) 1744 { 1745 ; /* good, this is a valid response */ 1746 } 1747 else if (dbus_message_is_error (message, 1748 DBUS_ERROR_SERVICE_UNKNOWN)) 1749 { 1750 ; /* good, this is expected also */ 1751 } 1752 else 1753 { 1754 warn_unexpected (connection, message, "not this error"); 1755 goto out; 1756 } 1757 } 1758 else 1759 { 1760 _dbus_warn ("Did not expect to successfully activate %s\n", 1761 NONEXISTENT_SERVICE_NAME); 1762 goto out; 1763 } 1764 1765 retval = TRUE; 1766 1767 out: 1768 if (message) 1769 dbus_message_unref (message); 1770 1771 return retval; 1772 } 1773 1774 static dbus_bool_t 1775 check_base_service_activated (BusContext *context, 1776 DBusConnection *connection, 1777 DBusMessage *initial_message, 1778 const char **base_service_p) 1779 { 1780 DBusMessage *message; 1781 dbus_bool_t retval; 1782 DBusError error; 1783 const char *base_service, *base_service_from_bus, *old_owner; 1784 1785 retval = FALSE; 1786 1787 dbus_error_init (&error); 1788 base_service = NULL; 1789 old_owner = NULL; 1790 base_service_from_bus = NULL; 1791 1792 message = initial_message; 1793 dbus_message_ref (message); 1794 1795 if (dbus_message_is_signal (message, 1796 DBUS_INTERFACE_DBUS, 1797 "NameOwnerChanged")) 1798 { 1799 CheckServiceOwnerChangedData socd; 1800 1801 reget_service_name_arg: 1802 base_service = NULL; 1803 old_owner = NULL; 1804 base_service_from_bus = NULL; 1805 1806 if (!dbus_message_get_args (message, &error, 1807 DBUS_TYPE_STRING, &base_service, 1808 DBUS_TYPE_STRING, &old_owner, 1809 DBUS_TYPE_STRING, &base_service_from_bus, 1810 DBUS_TYPE_INVALID)) 1811 { 1812 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1813 { 1814 dbus_error_free (&error); 1815 _dbus_wait_for_memory (); 1816 goto reget_service_name_arg; 1817 } 1818 else 1819 { 1820 _dbus_warn ("Message %s doesn't have a service name: %s\n", 1821 "NameOwnerChanged (creation)", 1822 error.message); 1823 goto out; 1824 } 1825 } 1826 1827 if (*base_service != ':') 1828 { 1829 _dbus_warn ("Expected base service activation, got \"%s\" instead\n", 1830 base_service); 1831 goto out; 1832 } 1833 1834 if (strcmp (base_service, base_service_from_bus) != 0) 1835 { 1836 _dbus_warn ("Expected base service activation, got \"%s\" instead with owner \"%s\"\n", 1837 base_service, base_service_from_bus); 1838 goto out; 1839 } 1840 1841 if (old_owner[0]) 1842 { 1843 _dbus_warn ("Received an old_owner argument during base service activation, \"%s\"\n", 1844 old_owner); 1845 goto out; 1846 } 1847 1848 socd.expected_kind = SERVICE_CREATED; 1849 socd.expected_service_name = base_service; 1850 socd.failed = FALSE; 1851 socd.skip_connection = connection; 1852 bus_test_clients_foreach (check_service_owner_changed_foreach, 1853 &socd); 1854 1855 if (socd.failed) 1856 goto out; 1857 } 1858 else 1859 { 1860 warn_unexpected (connection, message, "NameOwnerChanged (creation) for base service"); 1861 1862 goto out; 1863 } 1864 1865 if (base_service_p) 1866 *base_service_p = base_service; 1867 1868 retval = TRUE; 1869 1870 out: 1871 if (message) 1872 dbus_message_unref (message); 1873 dbus_error_free (&error); 1874 1875 return retval; 1876 } 1877 1878 static dbus_bool_t 1879 check_service_activated (BusContext *context, 1880 DBusConnection *connection, 1881 const char *activated_name, 1882 const char *base_service_name, 1883 DBusMessage *initial_message) 1884 { 1885 DBusMessage *message; 1886 dbus_bool_t retval; 1887 DBusError error; 1888 dbus_uint32_t activation_result; 1889 1890 retval = FALSE; 1891 1892 dbus_error_init (&error); 1893 1894 message = initial_message; 1895 dbus_message_ref (message); 1896 1897 if (dbus_message_is_signal (message, 1898 DBUS_INTERFACE_DBUS, 1899 "NameOwnerChanged")) 1900 { 1901 CheckServiceOwnerChangedData socd; 1902 const char *service_name, *base_service_from_bus, *old_owner; 1903 1904 reget_service_name_arg: 1905 service_name = NULL; 1906 old_owner = NULL; 1907 base_service_from_bus = NULL; 1908 1909 if (!dbus_message_get_args (message, &error, 1910 DBUS_TYPE_STRING, &service_name, 1911 DBUS_TYPE_STRING, &old_owner, 1912 DBUS_TYPE_STRING, &base_service_from_bus, 1913 DBUS_TYPE_INVALID)) 1914 { 1915 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1916 { 1917 dbus_error_free (&error); 1918 _dbus_wait_for_memory (); 1919 goto reget_service_name_arg; 1920 } 1921 else 1922 { 1923 _dbus_warn ("Message %s doesn't have a service name: %s\n", 1924 "NameOwnerChanged (creation)", 1925 error.message); 1926 goto out; 1927 } 1928 } 1929 1930 if (strcmp (service_name, activated_name) != 0) 1931 { 1932 _dbus_warn ("Expected to see service %s created, saw %s instead\n", 1933 activated_name, service_name); 1934 goto out; 1935 } 1936 1937 if (strcmp (base_service_name, base_service_from_bus) != 0) 1938 { 1939 _dbus_warn ("NameOwnerChanged reports wrong base service: %s owner, expected %s instead\n", 1940 base_service_from_bus, base_service_name); 1941 goto out; 1942 } 1943 1944 if (old_owner[0]) 1945 { 1946 _dbus_warn ("expected a %s, got a %s\n", 1947 "NameOwnerChanged (creation)", 1948 "NameOwnerChanged (change)"); 1949 goto out; 1950 } 1951 1952 socd.expected_kind = SERVICE_CREATED; 1953 socd.skip_connection = connection; 1954 socd.failed = FALSE; 1955 socd.expected_service_name = service_name; 1956 bus_test_clients_foreach (check_service_owner_changed_foreach, 1957 &socd); 1958 1959 if (socd.failed) 1960 goto out; 1961 1962 dbus_message_unref (message); 1963 service_name = NULL; 1964 old_owner = NULL; 1965 base_service_from_bus = NULL; 1966 1967 message = pop_message_waiting_for_memory (connection); 1968 if (message == NULL) 1969 { 1970 _dbus_warn ("Expected a reply to %s, got nothing\n", 1971 "StartServiceByName"); 1972 goto out; 1973 } 1974 } 1975 else 1976 { 1977 warn_unexpected (connection, message, "NameOwnerChanged for the activated name"); 1978 1979 goto out; 1980 } 1981 1982 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN) 1983 { 1984 warn_unexpected (connection, message, "reply to StartServiceByName"); 1985 1986 goto out; 1987 } 1988 1989 activation_result = 0; 1990 if (!dbus_message_get_args (message, &error, 1991 DBUS_TYPE_UINT32, &activation_result, 1992 DBUS_TYPE_INVALID)) 1993 { 1994 if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1995 { 1996 _dbus_warn ("Did not have activation result first argument to %s: %s\n", 1997 "StartServiceByName", error.message); 1998 goto out; 1999 } 2000 2001 dbus_error_free (&error); 2002 } 2003 else 2004 { 2005 if (activation_result == DBUS_START_REPLY_SUCCESS) 2006 ; /* Good */ 2007 else if (activation_result == DBUS_START_REPLY_ALREADY_RUNNING) 2008 ; /* Good also */ 2009 else 2010 { 2011 _dbus_warn ("Activation result was %u, no good.\n", 2012 activation_result); 2013 goto out; 2014 } 2015 } 2016 2017 dbus_message_unref (message); 2018 message = NULL; 2019 2020 if (!check_no_leftovers (context)) 2021 { 2022 _dbus_warn ("Messages were left over after verifying existent activation results\n"); 2023 goto out; 2024 } 2025 2026 retval = TRUE; 2027 2028 out: 2029 if (message) 2030 dbus_message_unref (message); 2031 dbus_error_free (&error); 2032 2033 return retval; 2034 } 2035 2036 static dbus_bool_t 2037 check_service_auto_activated (BusContext *context, 2038 DBusConnection *connection, 2039 const char *activated_name, 2040 const char *base_service_name, 2041 DBusMessage *initial_message) 2042 { 2043 DBusMessage *message; 2044 dbus_bool_t retval; 2045 DBusError error; 2046 2047 retval = FALSE; 2048 2049 dbus_error_init (&error); 2050 2051 message = initial_message; 2052 dbus_message_ref (message); 2053 2054 if (dbus_message_is_signal (message, 2055 DBUS_INTERFACE_DBUS, 2056 "NameOwnerChanged")) 2057 { 2058 const char *service_name; 2059 CheckServiceOwnerChangedData socd; 2060 2061 reget_service_name_arg: 2062 if (!dbus_message_get_args (message, &error, 2063 DBUS_TYPE_STRING, &service_name, 2064 DBUS_TYPE_INVALID)) 2065 { 2066 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 2067 { 2068 dbus_error_free (&error); 2069 _dbus_wait_for_memory (); 2070 goto reget_service_name_arg; 2071 } 2072 else 2073 { 2074 _dbus_warn ("Message %s doesn't have a service name: %s\n", 2075 "NameOwnerChanged", 2076 error.message); 2077 dbus_error_free (&error); 2078 goto out; 2079 } 2080 } 2081 2082 if (strcmp (service_name, activated_name) != 0) 2083 { 2084 _dbus_warn ("Expected to see service %s created, saw %s instead\n", 2085 activated_name, service_name); 2086 goto out; 2087 } 2088 2089 socd.expected_kind = SERVICE_CREATED; 2090 socd.expected_service_name = service_name; 2091 socd.failed = FALSE; 2092 socd.skip_connection = connection; 2093 bus_test_clients_foreach (check_service_owner_changed_foreach, 2094 &socd); 2095 2096 if (socd.failed) 2097 goto out; 2098 2099 /* Note that this differs from regular activation in that we don't get a 2100 * reply to ActivateService here. 2101 */ 2102 2103 dbus_message_unref (message); 2104 message = NULL; 2105 service_name = NULL; 2106 } 2107 else 2108 { 2109 warn_unexpected (connection, message, "NameOwnerChanged for the activated name"); 2110 2111 goto out; 2112 } 2113 2114 retval = TRUE; 2115 2116 out: 2117 if (message) 2118 dbus_message_unref (message); 2119 2120 return retval; 2121 } 2122 2123 static dbus_bool_t 2124 check_service_deactivated (BusContext *context, 2125 DBusConnection *connection, 2126 const char *activated_name, 2127 const char *base_service) 2128 { 2129 dbus_bool_t retval; 2130 CheckServiceOwnerChangedData socd; 2131 2132 retval = FALSE; 2133 2134 /* Now we are expecting ServiceOwnerChanged (deletion) messages for the base 2135 * service and the activated_name. The base service 2136 * notification is required to come last. 2137 */ 2138 socd.expected_kind = SERVICE_DELETED; 2139 socd.expected_service_name = activated_name; 2140 socd.failed = FALSE; 2141 socd.skip_connection = NULL; 2142 bus_test_clients_foreach (check_service_owner_changed_foreach, 2143 &socd); 2144 2145 if (socd.failed) 2146 goto out; 2147 2148 socd.expected_kind = SERVICE_DELETED; 2149 socd.expected_service_name = base_service; 2150 socd.failed = FALSE; 2151 socd.skip_connection = NULL; 2152 bus_test_clients_foreach (check_service_owner_changed_foreach, 2153 &socd); 2154 2155 if (socd.failed) 2156 goto out; 2157 2158 retval = TRUE; 2159 2160 out: 2161 return retval; 2162 } 2163 2164 static dbus_bool_t 2165 check_send_exit_to_service (BusContext *context, 2166 DBusConnection *connection, 2167 const char *service_name, 2168 const char *base_service) 2169 { 2170 dbus_bool_t got_error; 2171 DBusMessage *message; 2172 dbus_uint32_t serial; 2173 dbus_bool_t retval; 2174 2175 _dbus_verbose ("Sending exit message to the test service\n"); 2176 2177 retval = FALSE; 2178 2179 /* Kill off the test service by sending it a quit message */ 2180 message = dbus_message_new_method_call (service_name, 2181 "/org/freedesktop/TestSuite", 2182 "org.freedesktop.TestSuite", 2183 "Exit"); 2184 2185 if (message == NULL) 2186 { 2187 /* Do this again; we still need the service to exit... */ 2188 if (!check_send_exit_to_service (context, connection, 2189 service_name, base_service)) 2190 goto out; 2191 2192 return TRUE; 2193 } 2194 2195 if (!dbus_connection_send (connection, message, &serial)) 2196 { 2197 dbus_message_unref (message); 2198 2199 /* Do this again; we still need the service to exit... */ 2200 if (!check_send_exit_to_service (context, connection, 2201 service_name, base_service)) 2202 goto out; 2203 2204 return TRUE; 2205 } 2206 2207 dbus_message_unref (message); 2208 message = NULL; 2209 2210 /* send message */ 2211 bus_test_run_clients_loop (SEND_PENDING (connection)); 2212 2213 /* read it in and write it out to test service */ 2214 bus_test_run_bus_loop (context, FALSE); 2215 2216 /* see if we got an error during message bus dispatching */ 2217 bus_test_run_clients_loop (FALSE); 2218 message = borrow_message_waiting_for_memory (connection); 2219 got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR; 2220 if (message) 2221 { 2222 dbus_connection_return_message (connection, message); 2223 message = NULL; 2224 } 2225 2226 if (!got_error) 2227 { 2228 /* If no error, wait for the test service to exit */ 2229 block_connection_until_message_from_bus (context, connection, "test service to exit"); 2230 2231 bus_test_run_everything (context); 2232 } 2233 2234 if (got_error) 2235 { 2236 message = pop_message_waiting_for_memory (connection); 2237 _dbus_assert (message != NULL); 2238 2239 if (dbus_message_get_reply_serial (message) != serial) 2240 { 2241 warn_unexpected (connection, message, 2242 "error with the correct reply serial"); 2243 goto out; 2244 } 2245 2246 if (!dbus_message_is_error (message, 2247 DBUS_ERROR_NO_MEMORY)) 2248 { 2249 warn_unexpected (connection, message, 2250 "a no memory error from asking test service to exit"); 2251 goto out; 2252 } 2253 2254 _dbus_verbose ("Got error %s when asking test service to exit\n", 2255 dbus_message_get_error_name (message)); 2256 2257 /* Do this again; we still need the service to exit... */ 2258 if (!check_send_exit_to_service (context, connection, 2259 service_name, base_service)) 2260 goto out; 2261 } 2262 else 2263 { 2264 if (!check_service_deactivated (context, connection, 2265 service_name, base_service)) 2266 goto out; 2267 2268 /* Should now have a NoReply error from the Exit() method 2269 * call; it should have come after all the deactivation 2270 * stuff. 2271 */ 2272 message = pop_message_waiting_for_memory (connection); 2273 2274 if (message == NULL) 2275 { 2276 warn_unexpected (connection, NULL, 2277 "reply to Exit() method call"); 2278 goto out; 2279 } 2280 if (!dbus_message_is_error (message, 2281 DBUS_ERROR_NO_REPLY)) 2282 { 2283 warn_unexpected (connection, message, 2284 "NoReply error from Exit() method call"); 2285 goto out; 2286 } 2287 2288 if (dbus_message_get_reply_serial (message) != serial) 2289 { 2290 warn_unexpected (connection, message, 2291 "error with the correct reply serial"); 2292 goto out; 2293 } 2294 2295 _dbus_verbose ("Got error %s after test service exited\n", 2296 dbus_message_get_error_name (message)); 2297 2298 if (!check_no_leftovers (context)) 2299 { 2300 _dbus_warn ("Messages were left over after %s\n", 2301 _DBUS_FUNCTION_NAME); 2302 goto out; 2303 } 2304 } 2305 2306 retval = TRUE; 2307 2308 out: 2309 if (message) 2310 dbus_message_unref (message); 2311 2312 return retval; 2313 } 2314 2315 static dbus_bool_t 2316 check_got_error (BusContext *context, 2317 DBusConnection *connection, 2318 const char *first_error_name, 2319 ...) 2320 { 2321 DBusMessage *message; 2322 dbus_bool_t retval; 2323 va_list ap; 2324 dbus_bool_t error_found; 2325 const char *error_name; 2326 2327 retval = FALSE; 2328 2329 message = pop_message_waiting_for_memory (connection); 2330 if (message == NULL) 2331 { 2332 _dbus_warn ("Did not get an expected error\n"); 2333 goto out; 2334 } 2335 2336 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR) 2337 { 2338 warn_unexpected (connection, message, "an error"); 2339 2340 goto out; 2341 } 2342 2343 error_found = FALSE; 2344 2345 va_start (ap, first_error_name); 2346 error_name = first_error_name; 2347 while (error_name != NULL) 2348 { 2349 if (dbus_message_is_error (message, error_name)) 2350 { 2351 error_found = TRUE; 2352 break; 2353 } 2354 error_name = va_arg (ap, char*); 2355 } 2356 va_end (ap); 2357 2358 if (!error_found) 2359 { 2360 _dbus_warn ("Expected error %s or other, got %s instead\n", 2361 first_error_name, 2362 dbus_message_get_error_name (message)); 2363 goto out; 2364 } 2365 2366 retval = TRUE; 2367 2368 out: 2369 if (message) 2370 dbus_message_unref (message); 2371 2372 return retval; 2373 } 2374 2375 typedef enum 2376 { 2377 GOT_SERVICE_CREATED, 2378 GOT_SERVICE_DELETED, 2379 GOT_ERROR, 2380 GOT_SOMETHING_ELSE 2381 } GotServiceInfo; 2382 2383 static GotServiceInfo 2384 check_got_service_info (DBusMessage *message) 2385 { 2386 GotServiceInfo message_kind; 2387 2388 if (dbus_message_is_signal (message, 2389 DBUS_INTERFACE_DBUS, 2390 "NameOwnerChanged")) 2391 { 2392 DBusError error; 2393 const char *service_name, *old_owner, *new_owner; 2394 dbus_error_init (&error); 2395 2396 reget_service_info_data: 2397 service_name = NULL; 2398 old_owner = NULL; 2399 new_owner = NULL; 2400 2401 dbus_message_get_args (message, &error, 2402 DBUS_TYPE_STRING, &service_name, 2403 DBUS_TYPE_STRING, &old_owner, 2404 DBUS_TYPE_STRING, &new_owner, 2405 DBUS_TYPE_INVALID); 2406 if (dbus_error_is_set (&error)) 2407 { 2408 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 2409 { 2410 dbus_error_free (&error); 2411 goto reget_service_info_data; 2412 } 2413 else 2414 { 2415 _dbus_warn ("unexpected arguments for NameOwnerChanged message\n"); 2416 message_kind = GOT_SOMETHING_ELSE; 2417 } 2418 } 2419 else if (!old_owner[0]) 2420 message_kind = GOT_SERVICE_CREATED; 2421 else if (!new_owner[0]) 2422 message_kind = GOT_SERVICE_DELETED; 2423 else 2424 message_kind = GOT_SOMETHING_ELSE; 2425 2426 dbus_error_free (&error); 2427 } 2428 else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 2429 message_kind = GOT_ERROR; 2430 else 2431 message_kind = GOT_SOMETHING_ELSE; 2432 2433 return message_kind; 2434 } 2435 2436 #define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService" 2437 2438 /* returns TRUE if the correct thing happens, 2439 * but the correct thing may include OOM errors. 2440 */ 2441 static dbus_bool_t 2442 check_existent_service_no_auto_start (BusContext *context, 2443 DBusConnection *connection) 2444 { 2445 DBusMessage *message; 2446 DBusMessage *base_service_message; 2447 const char *base_service; 2448 dbus_uint32_t serial; 2449 dbus_bool_t retval; 2450 const char *existent = EXISTENT_SERVICE_NAME; 2451 dbus_uint32_t flags; 2452 2453 base_service_message = NULL; 2454 2455 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 2456 DBUS_PATH_DBUS, 2457 DBUS_INTERFACE_DBUS, 2458 "StartServiceByName"); 2459 2460 if (message == NULL) 2461 return TRUE; 2462 2463 dbus_message_set_auto_start (message, FALSE); 2464 2465 flags = 0; 2466 if (!dbus_message_append_args (message, 2467 DBUS_TYPE_STRING, &existent, 2468 DBUS_TYPE_UINT32, &flags, 2469 DBUS_TYPE_INVALID)) 2470 { 2471 dbus_message_unref (message); 2472 return TRUE; 2473 } 2474 2475 if (!dbus_connection_send (connection, message, &serial)) 2476 { 2477 dbus_message_unref (message); 2478 return TRUE; 2479 } 2480 2481 dbus_message_unref (message); 2482 message = NULL; 2483 2484 bus_test_run_everything (context); 2485 2486 /* now wait for the message bus to hear back from the activated 2487 * service. 2488 */ 2489 block_connection_until_message_from_bus (context, connection, "activated service to connect"); 2490 2491 bus_test_run_everything (context); 2492 2493 if (!dbus_connection_get_is_connected (connection)) 2494 { 2495 _dbus_verbose ("connection was disconnected\n"); 2496 return TRUE; 2497 } 2498 2499 retval = FALSE; 2500 2501 message = pop_message_waiting_for_memory (connection); 2502 if (message == NULL) 2503 { 2504 _dbus_warn ("Did not receive any messages after %s %d on %p\n", 2505 "StartServiceByName", serial, connection); 2506 goto out; 2507 } 2508 2509 verbose_message_received (connection, message); 2510 _dbus_verbose (" (after sending %s)\n", "StartServiceByName"); 2511 2512 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 2513 { 2514 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 2515 { 2516 _dbus_warn ("Message has wrong sender %s\n", 2517 dbus_message_get_sender (message) ? 2518 dbus_message_get_sender (message) : "(none)"); 2519 goto out; 2520 } 2521 2522 if (dbus_message_is_error (message, 2523 DBUS_ERROR_NO_MEMORY)) 2524 { 2525 ; /* good, this is a valid response */ 2526 } 2527 else if (dbus_message_is_error (message, 2528 DBUS_ERROR_SPAWN_CHILD_EXITED) || 2529 dbus_message_is_error (message, 2530 DBUS_ERROR_SPAWN_CHILD_SIGNALED) || 2531 dbus_message_is_error (message, 2532 DBUS_ERROR_SPAWN_EXEC_FAILED)) 2533 { 2534 ; /* good, this is expected also */ 2535 } 2536 else 2537 { 2538 _dbus_warn ("Did not expect error %s\n", 2539 dbus_message_get_error_name (message)); 2540 goto out; 2541 } 2542 } 2543 else 2544 { 2545 GotServiceInfo message_kind; 2546 2547 if (!check_base_service_activated (context, connection, 2548 message, &base_service)) 2549 goto out; 2550 2551 base_service_message = message; 2552 message = NULL; 2553 2554 /* We may need to block here for the test service to exit or finish up */ 2555 block_connection_until_message_from_bus (context, connection, "test service to exit or finish up"); 2556 2557 message = dbus_connection_borrow_message (connection); 2558 if (message == NULL) 2559 { 2560 _dbus_warn ("Did not receive any messages after base service creation notification\n"); 2561 goto out; 2562 } 2563 2564 message_kind = check_got_service_info (message); 2565 2566 dbus_connection_return_message (connection, message); 2567 message = NULL; 2568 2569 switch (message_kind) 2570 { 2571 case GOT_SOMETHING_ELSE: 2572 _dbus_warn ("Unexpected message after ActivateService " 2573 "(should be an error or a service announcement"); 2574 goto out; 2575 2576 case GOT_ERROR: 2577 if (!check_got_error (context, connection, 2578 DBUS_ERROR_SPAWN_CHILD_EXITED, 2579 DBUS_ERROR_NO_MEMORY, 2580 NULL)) 2581 goto out; 2582 /* A service deleted should be coming along now after this error. 2583 * We can also get the error *after* the service deleted. 2584 */ 2585 2586 /* fall through */ 2587 2588 case GOT_SERVICE_DELETED: 2589 { 2590 /* The service started up and got a base address, but then 2591 * failed to register under EXISTENT_SERVICE_NAME 2592 */ 2593 CheckServiceOwnerChangedData socd; 2594 2595 socd.expected_kind = SERVICE_DELETED; 2596 socd.expected_service_name = base_service; 2597 socd.failed = FALSE; 2598 socd.skip_connection = NULL; 2599 2600 bus_test_clients_foreach (check_service_owner_changed_foreach, 2601 &socd); 2602 2603 if (socd.failed) 2604 goto out; 2605 2606 /* Now we should get an error about the service exiting 2607 * if we didn't get it before. 2608 */ 2609 if (message_kind != GOT_ERROR) 2610 { 2611 block_connection_until_message_from_bus (context, connection, "error about service exiting"); 2612 2613 /* and process everything again */ 2614 bus_test_run_everything (context); 2615 2616 if (!check_got_error (context, connection, 2617 DBUS_ERROR_SPAWN_CHILD_EXITED, 2618 DBUS_ERROR_NO_MEMORY, 2619 NULL)) 2620 goto out; 2621 } 2622 break; 2623 } 2624 2625 case GOT_SERVICE_CREATED: 2626 message = pop_message_waiting_for_memory (connection); 2627 if (message == NULL) 2628 { 2629 _dbus_warn ("Failed to pop message we just put back! " 2630 "should have been a NameOwnerChanged (creation)\n"); 2631 goto out; 2632 } 2633 2634 if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME, 2635 base_service, message)) 2636 goto out; 2637 2638 dbus_message_unref (message); 2639 message = NULL; 2640 2641 if (!check_no_leftovers (context)) 2642 { 2643 _dbus_warn ("Messages were left over after successful activation\n"); 2644 goto out; 2645 } 2646 2647 if (!check_send_exit_to_service (context, connection, 2648 EXISTENT_SERVICE_NAME, base_service)) 2649 goto out; 2650 2651 break; 2652 } 2653 } 2654 2655 retval = TRUE; 2656 2657 out: 2658 if (message) 2659 dbus_message_unref (message); 2660 2661 if (base_service_message) 2662 dbus_message_unref (base_service_message); 2663 2664 return retval; 2665 } 2666 2667 #ifndef DBUS_WIN_FIXME 2668 /* returns TRUE if the correct thing happens, 2669 * but the correct thing may include OOM errors. 2670 */ 2671 static dbus_bool_t 2672 check_segfault_service_no_auto_start (BusContext *context, 2673 DBusConnection *connection) 2674 { 2675 DBusMessage *message; 2676 dbus_uint32_t serial; 2677 dbus_bool_t retval; 2678 const char *segv_service; 2679 dbus_uint32_t flags; 2680 2681 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 2682 DBUS_PATH_DBUS, 2683 DBUS_INTERFACE_DBUS, 2684 "StartServiceByName"); 2685 2686 if (message == NULL) 2687 return TRUE; 2688 2689 dbus_message_set_auto_start (message, FALSE); 2690 2691 segv_service = "org.freedesktop.DBus.TestSuiteSegfaultService"; 2692 flags = 0; 2693 if (!dbus_message_append_args (message, 2694 DBUS_TYPE_STRING, &segv_service, 2695 DBUS_TYPE_UINT32, &flags, 2696 DBUS_TYPE_INVALID)) 2697 { 2698 dbus_message_unref (message); 2699 return TRUE; 2700 } 2701 2702 if (!dbus_connection_send (connection, message, &serial)) 2703 { 2704 dbus_message_unref (message); 2705 return TRUE; 2706 } 2707 2708 dbus_message_unref (message); 2709 message = NULL; 2710 2711 bus_test_run_everything (context); 2712 block_connection_until_message_from_bus (context, connection, "reply to activating segfault service"); 2713 bus_test_run_everything (context); 2714 2715 if (!dbus_connection_get_is_connected (connection)) 2716 { 2717 _dbus_verbose ("connection was disconnected\n"); 2718 return TRUE; 2719 } 2720 2721 retval = FALSE; 2722 2723 message = pop_message_waiting_for_memory (connection); 2724 if (message == NULL) 2725 { 2726 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 2727 "StartServiceByName", serial, connection); 2728 goto out; 2729 } 2730 2731 verbose_message_received (connection, message); 2732 2733 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 2734 { 2735 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 2736 { 2737 _dbus_warn ("Message has wrong sender %s\n", 2738 dbus_message_get_sender (message) ? 2739 dbus_message_get_sender (message) : "(none)"); 2740 goto out; 2741 } 2742 2743 if (dbus_message_is_error (message, 2744 DBUS_ERROR_NO_MEMORY)) 2745 { 2746 ; /* good, this is a valid response */ 2747 } 2748 else if (dbus_message_is_error (message, 2749 DBUS_ERROR_FAILED)) 2750 { 2751 const char *servicehelper; 2752 servicehelper = bus_context_get_servicehelper (context); 2753 /* make sure this only happens with the launch helper */ 2754 _dbus_assert (servicehelper != NULL); 2755 } 2756 else if (dbus_message_is_error (message, 2757 DBUS_ERROR_SPAWN_CHILD_SIGNALED)) 2758 { 2759 ; /* good, this is expected also */ 2760 } 2761 else 2762 { 2763 warn_unexpected (connection, message, "not this error"); 2764 2765 goto out; 2766 } 2767 } 2768 else 2769 { 2770 _dbus_warn ("Did not expect to successfully activate segfault service\n"); 2771 goto out; 2772 } 2773 2774 retval = TRUE; 2775 2776 out: 2777 if (message) 2778 dbus_message_unref (message); 2779 2780 return retval; 2781 } 2782 2783 2784 /* returns TRUE if the correct thing happens, 2785 * but the correct thing may include OOM errors. 2786 */ 2787 static dbus_bool_t 2788 check_segfault_service_auto_start (BusContext *context, 2789 DBusConnection *connection) 2790 { 2791 DBusMessage *message; 2792 dbus_uint32_t serial; 2793 dbus_bool_t retval; 2794 2795 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteSegfaultService", 2796 "/org/freedesktop/TestSuite", 2797 "org.freedesktop.TestSuite", 2798 "Echo"); 2799 2800 if (message == NULL) 2801 return TRUE; 2802 2803 if (!dbus_connection_send (connection, message, &serial)) 2804 { 2805 dbus_message_unref (message); 2806 return TRUE; 2807 } 2808 2809 dbus_message_unref (message); 2810 message = NULL; 2811 2812 bus_test_run_everything (context); 2813 block_connection_until_message_from_bus (context, connection, "reply to Echo on segfault service"); 2814 bus_test_run_everything (context); 2815 2816 if (!dbus_connection_get_is_connected (connection)) 2817 { 2818 _dbus_verbose ("connection was disconnected\n"); 2819 return TRUE; 2820 } 2821 2822 retval = FALSE; 2823 2824 message = pop_message_waiting_for_memory (connection); 2825 if (message == NULL) 2826 { 2827 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 2828 "Echo message (auto activation)", serial, connection); 2829 goto out; 2830 } 2831 2832 verbose_message_received (connection, message); 2833 2834 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 2835 { 2836 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 2837 { 2838 _dbus_warn ("Message has wrong sender %s\n", 2839 dbus_message_get_sender (message) ? 2840 dbus_message_get_sender (message) : "(none)"); 2841 goto out; 2842 } 2843 2844 if (dbus_message_is_error (message, 2845 DBUS_ERROR_NO_MEMORY)) 2846 { 2847 ; /* good, this is a valid response */ 2848 } 2849 else if (dbus_message_is_error (message, 2850 DBUS_ERROR_SPAWN_CHILD_SIGNALED)) 2851 { 2852 ; /* good, this is expected also */ 2853 } 2854 else 2855 { 2856 warn_unexpected (connection, message, "not this error"); 2857 2858 goto out; 2859 } 2860 } 2861 else 2862 { 2863 _dbus_warn ("Did not expect to successfully activate segfault service\n"); 2864 goto out; 2865 } 2866 2867 retval = TRUE; 2868 2869 out: 2870 if (message) 2871 dbus_message_unref (message); 2872 2873 return retval; 2874 } 2875 #endif 2876 2877 #define TEST_ECHO_MESSAGE "Test echo message" 2878 #define TEST_RUN_HELLO_FROM_SELF_MESSAGE "Test sending message to self" 2879 2880 /* returns TRUE if the correct thing happens, 2881 * but the correct thing may include OOM errors. 2882 */ 2883 static dbus_bool_t 2884 check_existent_hello_from_self (BusContext *context, 2885 DBusConnection *connection) 2886 { 2887 DBusMessage *message; 2888 dbus_uint32_t serial; 2889 const char *text; 2890 2891 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME, 2892 "/org/freedesktop/TestSuite", 2893 "org.freedesktop.TestSuite", 2894 "RunHelloFromSelf"); 2895 2896 if (message == NULL) 2897 return TRUE; 2898 2899 text = TEST_RUN_HELLO_FROM_SELF_MESSAGE; 2900 if (!dbus_message_append_args (message, 2901 DBUS_TYPE_STRING, &text, 2902 DBUS_TYPE_INVALID)) 2903 { 2904 dbus_message_unref (message); 2905 return TRUE; 2906 } 2907 2908 if (!dbus_connection_send (connection, message, &serial)) 2909 { 2910 dbus_message_unref (message); 2911 return TRUE; 2912 } 2913 2914 dbus_message_unref (message); 2915 message = NULL; 2916 2917 bus_test_run_everything (context); 2918 2919 /* Note: if this test is run in OOM mode, it will block when the bus 2920 * doesn't send a reply due to OOM. 2921 */ 2922 block_connection_until_message_from_bus (context, connection, "reply from running hello from self"); 2923 2924 message = pop_message_waiting_for_memory (connection); 2925 if (message == NULL) 2926 { 2927 _dbus_warn ("Failed to pop message! Should have been reply from RunHelloFromSelf message\n"); 2928 return FALSE; 2929 } 2930 2931 if (dbus_message_get_reply_serial (message) != serial) 2932 { 2933 _dbus_warn ("Wrong reply serial\n"); 2934 dbus_message_unref (message); 2935 return FALSE; 2936 } 2937 2938 dbus_message_unref (message); 2939 message = NULL; 2940 2941 return TRUE; 2942 } 2943 2944 /* returns TRUE if the correct thing happens, 2945 * but the correct thing may include OOM errors. 2946 */ 2947 static dbus_bool_t 2948 check_existent_ping (BusContext *context, 2949 DBusConnection *connection) 2950 { 2951 DBusMessage *message; 2952 dbus_uint32_t serial; 2953 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME, 2954 "/org/freedesktop/TestSuite", 2955 "org.freedesktop.DBus.Peer", 2956 "Ping"); 2957 2958 if (message == NULL) 2959 return TRUE; 2960 2961 if (!dbus_connection_send (connection, message, &serial)) 2962 { 2963 dbus_message_unref (message); 2964 return TRUE; 2965 } 2966 2967 dbus_message_unref (message); 2968 message = NULL; 2969 2970 bus_test_run_everything (context); 2971 2972 /* Note: if this test is run in OOM mode, it will block when the bus 2973 * doesn't send a reply due to OOM. 2974 */ 2975 block_connection_until_message_from_bus (context, connection, "reply from running Ping"); 2976 2977 message = pop_message_waiting_for_memory (connection); 2978 if (message == NULL) 2979 { 2980 _dbus_warn ("Failed to pop message! Should have been reply from Ping message\n"); 2981 return FALSE; 2982 } 2983 2984 if (dbus_message_get_reply_serial (message) != serial) 2985 { 2986 _dbus_warn ("Wrong reply serial\n"); 2987 dbus_message_unref (message); 2988 return FALSE; 2989 } 2990 2991 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN) 2992 { 2993 _dbus_warn ("Unexpected message return during Ping\n"); 2994 dbus_message_unref (message); 2995 return FALSE; 2996 } 2997 2998 dbus_message_unref (message); 2999 message = NULL; 3000 3001 return TRUE; 3002 } 3003 3004 /* returns TRUE if the correct thing happens, 3005 * but the correct thing may include OOM errors. 3006 */ 3007 static dbus_bool_t 3008 check_existent_get_machine_id (BusContext *context, 3009 DBusConnection *connection) 3010 { 3011 DBusMessage *message; 3012 dbus_uint32_t serial; 3013 const char *machine_id; 3014 3015 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME, 3016 "/org/freedesktop/TestSuite", 3017 "org.freedesktop.DBus.Peer", 3018 "GetMachineId"); 3019 3020 if (message == NULL) 3021 return TRUE; 3022 3023 if (!dbus_connection_send (connection, message, &serial)) 3024 { 3025 dbus_message_unref (message); 3026 return TRUE; 3027 } 3028 3029 dbus_message_unref (message); 3030 message = NULL; 3031 3032 bus_test_run_everything (context); 3033 3034 /* Note: if this test is run in OOM mode, it will block when the bus 3035 * doesn't send a reply due to OOM. 3036 */ 3037 block_connection_until_message_from_bus (context, connection, "reply from running GetMachineId"); 3038 3039 message = pop_message_waiting_for_memory (connection); 3040 if (message == NULL) 3041 { 3042 _dbus_warn ("Failed to pop message! Should have been reply from GetMachineId message\n"); 3043 return FALSE; 3044 } 3045 3046 if (dbus_message_get_reply_serial (message) != serial) 3047 { 3048 _dbus_warn ("Wrong reply serial\n"); 3049 dbus_message_unref (message); 3050 return FALSE; 3051 } 3052 3053 if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN) 3054 { 3055 _dbus_warn ("Unexpected message return during GetMachineId\n"); 3056 dbus_message_unref (message); 3057 return FALSE; 3058 } 3059 3060 machine_id = NULL; 3061 if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &machine_id, DBUS_TYPE_INVALID)) 3062 { 3063 _dbus_warn ("Did not get a machine ID in reply to GetMachineId\n"); 3064 dbus_message_unref (message); 3065 return FALSE; 3066 } 3067 3068 if (machine_id == NULL || strlen (machine_id) != 32) 3069 { 3070 _dbus_warn ("Machine id looks bogus: '%s'\n", machine_id ? machine_id : "null"); 3071 dbus_message_unref (message); 3072 return FALSE; 3073 } 3074 3075 /* We can't check that the machine id is correct because during make check it is 3076 * just made up for each process separately 3077 */ 3078 3079 dbus_message_unref (message); 3080 message = NULL; 3081 3082 return TRUE; 3083 } 3084 3085 /* returns TRUE if the correct thing happens, 3086 * but the correct thing may include OOM errors. 3087 */ 3088 static dbus_bool_t 3089 check_existent_service_auto_start (BusContext *context, 3090 DBusConnection *connection) 3091 { 3092 DBusMessage *message; 3093 DBusMessage *base_service_message; 3094 dbus_uint32_t serial; 3095 dbus_bool_t retval; 3096 const char *base_service; 3097 const char *text; 3098 3099 base_service_message = NULL; 3100 3101 message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME, 3102 "/org/freedesktop/TestSuite", 3103 "org.freedesktop.TestSuite", 3104 "Echo"); 3105 3106 if (message == NULL) 3107 return TRUE; 3108 3109 text = TEST_ECHO_MESSAGE; 3110 if (!dbus_message_append_args (message, 3111 DBUS_TYPE_STRING, &text, 3112 DBUS_TYPE_INVALID)) 3113 { 3114 dbus_message_unref (message); 3115 return TRUE; 3116 } 3117 3118 if (!dbus_connection_send (connection, message, &serial)) 3119 { 3120 dbus_message_unref (message); 3121 return TRUE; 3122 } 3123 3124 dbus_message_unref (message); 3125 message = NULL; 3126 3127 bus_test_run_everything (context); 3128 3129 /* now wait for the message bus to hear back from the activated 3130 * service. 3131 */ 3132 block_connection_until_message_from_bus (context, connection, "reply to Echo on existent service"); 3133 bus_test_run_everything (context); 3134 3135 if (!dbus_connection_get_is_connected (connection)) 3136 { 3137 _dbus_verbose ("connection was disconnected\n"); 3138 return TRUE; 3139 } 3140 3141 retval = FALSE; 3142 3143 message = pop_message_waiting_for_memory (connection); 3144 if (message == NULL) 3145 { 3146 _dbus_warn ("Did not receive any messages after auto start %d on %p\n", 3147 serial, connection); 3148 goto out; 3149 } 3150 3151 verbose_message_received (connection, message); 3152 _dbus_verbose (" (after sending %s)\n", "auto start"); 3153 3154 /* we should get zero or two ServiceOwnerChanged signals */ 3155 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL) 3156 { 3157 GotServiceInfo message_kind; 3158 3159 if (!check_base_service_activated (context, connection, 3160 message, &base_service)) 3161 goto out; 3162 3163 base_service_message = message; 3164 message = NULL; 3165 3166 /* We may need to block here for the test service to exit or finish up */ 3167 block_connection_until_message_from_bus (context, connection, "service to exit"); 3168 3169 /* Should get a service creation notification for the activated 3170 * service name, or a service deletion on the base service name 3171 */ 3172 message = dbus_connection_borrow_message (connection); 3173 if (message == NULL) 3174 { 3175 _dbus_warn ("No message after auto activation " 3176 "(should be a service announcement)\n"); 3177 dbus_connection_return_message (connection, message); 3178 message = NULL; 3179 goto out; 3180 } 3181 3182 message_kind = check_got_service_info (message); 3183 3184 dbus_connection_return_message (connection, message); 3185 message = NULL; 3186 3187 switch (message_kind) 3188 { 3189 case GOT_SERVICE_CREATED: 3190 message = pop_message_waiting_for_memory (connection); 3191 if (message == NULL) 3192 { 3193 _dbus_warn ("Failed to pop message we just put back! " 3194 "should have been a NameOwnerChanged (creation)\n"); 3195 goto out; 3196 } 3197 3198 /* Check that ServiceOwnerChanged (creation) was correctly received */ 3199 if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME, 3200 base_service, message)) 3201 goto out; 3202 3203 dbus_message_unref (message); 3204 message = NULL; 3205 3206 break; 3207 3208 case GOT_SERVICE_DELETED: 3209 { 3210 /* The service started up and got a base address, but then 3211 * failed to register under EXISTENT_SERVICE_NAME 3212 */ 3213 CheckServiceOwnerChangedData socd; 3214 3215 socd.expected_kind = SERVICE_DELETED; 3216 socd.expected_service_name = base_service; 3217 socd.failed = FALSE; 3218 socd.skip_connection = NULL; 3219 bus_test_clients_foreach (check_service_owner_changed_foreach, 3220 &socd); 3221 3222 if (socd.failed) 3223 goto out; 3224 3225 break; 3226 } 3227 3228 case GOT_ERROR: 3229 case GOT_SOMETHING_ELSE: 3230 _dbus_warn ("Unexpected message after auto activation\n"); 3231 goto out; 3232 } 3233 } 3234 3235 /* OK, now we've dealt with ServiceOwnerChanged signals, now should 3236 * come the method reply (or error) from the initial method call 3237 */ 3238 3239 /* Note: if this test is run in OOM mode, it will block when the bus 3240 * doesn't send a reply due to OOM. 3241 */ 3242 block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation"); 3243 3244 message = pop_message_waiting_for_memory (connection); 3245 if (message == NULL) 3246 { 3247 _dbus_warn ("Failed to pop message! Should have been reply from echo message\n"); 3248 goto out; 3249 } 3250 3251 if (dbus_message_get_reply_serial (message) != serial) 3252 { 3253 _dbus_warn ("Wrong reply serial\n"); 3254 goto out; 3255 } 3256 3257 dbus_message_unref (message); 3258 message = NULL; 3259 3260 if (!check_existent_ping (context, connection)) 3261 goto out; 3262 3263 if (!check_existent_get_machine_id (context, connection)) 3264 goto out; 3265 3266 if (!check_existent_hello_from_self (context, connection)) 3267 goto out; 3268 3269 if (!check_send_exit_to_service (context, connection, 3270 EXISTENT_SERVICE_NAME, 3271 base_service)) 3272 goto out; 3273 3274 retval = TRUE; 3275 3276 out: 3277 if (message) 3278 dbus_message_unref (message); 3279 3280 if (base_service_message) 3281 dbus_message_unref (base_service_message); 3282 3283 return retval; 3284 } 3285 3286 #define SERVICE_FILE_MISSING_NAME "org.freedesktop.DBus.TestSuiteEchoServiceDotServiceFileDoesNotExist" 3287 3288 /* returns TRUE if the correct thing happens, 3289 * but the correct thing may include OOM errors. 3290 */ 3291 static dbus_bool_t 3292 check_launch_service_file_missing (BusContext *context, 3293 DBusConnection *connection) 3294 { 3295 DBusMessage *message; 3296 dbus_uint32_t serial; 3297 dbus_bool_t retval; 3298 3299 message = dbus_message_new_method_call (SERVICE_FILE_MISSING_NAME, 3300 "/org/freedesktop/TestSuite", 3301 "org.freedesktop.TestSuite", 3302 "Echo"); 3303 3304 if (message == NULL) 3305 return TRUE; 3306 3307 if (!dbus_connection_send (connection, message, &serial)) 3308 { 3309 dbus_message_unref (message); 3310 return TRUE; 3311 } 3312 3313 dbus_message_unref (message); 3314 message = NULL; 3315 3316 bus_test_run_everything (context); 3317 block_connection_until_message_from_bus (context, connection, "reply to service file missing should fail to auto-start"); 3318 bus_test_run_everything (context); 3319 3320 if (!dbus_connection_get_is_connected (connection)) 3321 { 3322 _dbus_verbose ("connection was disconnected\n"); 3323 return TRUE; 3324 } 3325 3326 retval = FALSE; 3327 3328 message = pop_message_waiting_for_memory (connection); 3329 if (message == NULL) 3330 { 3331 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 3332 "Echo message (auto activation)", serial, connection); 3333 goto out; 3334 } 3335 3336 verbose_message_received (connection, message); 3337 3338 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 3339 { 3340 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 3341 { 3342 _dbus_warn ("Message has wrong sender %s\n", 3343 dbus_message_get_sender (message) ? 3344 dbus_message_get_sender (message) : "(none)"); 3345 goto out; 3346 } 3347 3348 if (dbus_message_is_error (message, 3349 DBUS_ERROR_NO_MEMORY)) 3350 { 3351 ; /* good, this is a valid response */ 3352 } 3353 else if (dbus_message_is_error (message, 3354 DBUS_ERROR_SERVICE_UNKNOWN)) 3355 { 3356 _dbus_verbose("got service unknown\n"); 3357 ; /* good, this is expected (only valid when using launch helper) */ 3358 } 3359 else 3360 { 3361 warn_unexpected (connection, message, "not this error"); 3362 3363 goto out; 3364 } 3365 } 3366 else 3367 { 3368 _dbus_warn ("Did not expect to successfully auto-start missing service\n"); 3369 goto out; 3370 } 3371 3372 retval = TRUE; 3373 3374 out: 3375 if (message) 3376 dbus_message_unref (message); 3377 3378 return retval; 3379 } 3380 3381 #define SERVICE_USER_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoUser" 3382 3383 /* returns TRUE if the correct thing happens, 3384 * but the correct thing may include OOM errors. 3385 */ 3386 static dbus_bool_t 3387 check_launch_service_user_missing (BusContext *context, 3388 DBusConnection *connection) 3389 { 3390 DBusMessage *message; 3391 dbus_uint32_t serial; 3392 dbus_bool_t retval; 3393 3394 message = dbus_message_new_method_call (SERVICE_USER_MISSING_NAME, 3395 "/org/freedesktop/TestSuite", 3396 "org.freedesktop.TestSuite", 3397 "Echo"); 3398 3399 if (message == NULL) 3400 return TRUE; 3401 3402 if (!dbus_connection_send (connection, message, &serial)) 3403 { 3404 dbus_message_unref (message); 3405 return TRUE; 3406 } 3407 3408 dbus_message_unref (message); 3409 message = NULL; 3410 3411 bus_test_run_everything (context); 3412 block_connection_until_message_from_bus (context, connection, 3413 "reply to service which should fail to auto-start (missing User)"); 3414 bus_test_run_everything (context); 3415 3416 if (!dbus_connection_get_is_connected (connection)) 3417 { 3418 _dbus_warn ("connection was disconnected\n"); 3419 return TRUE; 3420 } 3421 3422 retval = FALSE; 3423 3424 message = pop_message_waiting_for_memory (connection); 3425 if (message == NULL) 3426 { 3427 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 3428 "Echo message (auto activation)", serial, connection); 3429 goto out; 3430 } 3431 3432 verbose_message_received (connection, message); 3433 3434 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 3435 { 3436 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 3437 { 3438 _dbus_warn ("Message has wrong sender %s\n", 3439 dbus_message_get_sender (message) ? 3440 dbus_message_get_sender (message) : "(none)"); 3441 goto out; 3442 } 3443 3444 if (dbus_message_is_error (message, 3445 DBUS_ERROR_NO_MEMORY)) 3446 { 3447 ; /* good, this is a valid response */ 3448 } 3449 else if (dbus_message_is_error (message, 3450 DBUS_ERROR_SPAWN_FILE_INVALID)) 3451 { 3452 _dbus_verbose("got service file invalid\n"); 3453 ; /* good, this is expected (only valid when using launch helper) */ 3454 } 3455 else 3456 { 3457 warn_unexpected (connection, message, "not this error"); 3458 3459 goto out; 3460 } 3461 } 3462 else 3463 { 3464 _dbus_warn ("Did not expect to successfully auto-start missing service\n"); 3465 goto out; 3466 } 3467 3468 retval = TRUE; 3469 3470 out: 3471 if (message) 3472 dbus_message_unref (message); 3473 3474 return retval; 3475 } 3476 3477 #define SERVICE_EXEC_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoExec" 3478 3479 /* returns TRUE if the correct thing happens, 3480 * but the correct thing may include OOM errors. 3481 */ 3482 static dbus_bool_t 3483 check_launch_service_exec_missing (BusContext *context, 3484 DBusConnection *connection) 3485 { 3486 DBusMessage *message; 3487 dbus_uint32_t serial; 3488 dbus_bool_t retval; 3489 3490 message = dbus_message_new_method_call (SERVICE_EXEC_MISSING_NAME, 3491 "/org/freedesktop/TestSuite", 3492 "org.freedesktop.TestSuite", 3493 "Echo"); 3494 3495 if (message == NULL) 3496 return TRUE; 3497 3498 if (!dbus_connection_send (connection, message, &serial)) 3499 { 3500 dbus_message_unref (message); 3501 return TRUE; 3502 } 3503 3504 dbus_message_unref (message); 3505 message = NULL; 3506 3507 bus_test_run_everything (context); 3508 block_connection_until_message_from_bus (context, connection, 3509 "reply to service which should fail to auto-start (missing Exec)"); 3510 bus_test_run_everything (context); 3511 3512 if (!dbus_connection_get_is_connected (connection)) 3513 { 3514 _dbus_warn ("connection was disconnected\n"); 3515 return TRUE; 3516 } 3517 3518 retval = FALSE; 3519 3520 message = pop_message_waiting_for_memory (connection); 3521 if (message == NULL) 3522 { 3523 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 3524 "Echo message (auto activation)", serial, connection); 3525 goto out; 3526 } 3527 3528 verbose_message_received (connection, message); 3529 3530 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 3531 { 3532 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 3533 { 3534 _dbus_warn ("Message has wrong sender %s\n", 3535 dbus_message_get_sender (message) ? 3536 dbus_message_get_sender (message) : "(none)"); 3537 goto out; 3538 } 3539 3540 if (dbus_message_is_error (message, 3541 DBUS_ERROR_NO_MEMORY)) 3542 { 3543 ; /* good, this is a valid response */ 3544 } 3545 else if (dbus_message_is_error (message, 3546 DBUS_ERROR_SERVICE_UNKNOWN)) 3547 { 3548 _dbus_verbose("could not activate as invalid service file was not added\n"); 3549 ; /* good, this is expected as we shouldn't have been added to 3550 * the activation list with a missing Exec key */ 3551 } 3552 else if (dbus_message_is_error (message, 3553 DBUS_ERROR_SPAWN_FILE_INVALID)) 3554 { 3555 _dbus_verbose("got service file invalid\n"); 3556 ; /* good, this is allowed, and is the message passed back from the 3557 * launch helper */ 3558 } 3559 else 3560 { 3561 warn_unexpected (connection, message, "not this error"); 3562 3563 goto out; 3564 } 3565 } 3566 else 3567 { 3568 _dbus_warn ("Did not expect to successfully auto-start missing service\n"); 3569 goto out; 3570 } 3571 3572 retval = TRUE; 3573 3574 out: 3575 if (message) 3576 dbus_message_unref (message); 3577 3578 return retval; 3579 } 3580 3581 #define SERVICE_SERVICE_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoService" 3582 3583 /* returns TRUE if the correct thing happens, 3584 * but the correct thing may include OOM errors. 3585 */ 3586 static dbus_bool_t 3587 check_launch_service_service_missing (BusContext *context, 3588 DBusConnection *connection) 3589 { 3590 DBusMessage *message; 3591 dbus_uint32_t serial; 3592 dbus_bool_t retval; 3593 3594 message = dbus_message_new_method_call (SERVICE_SERVICE_MISSING_NAME, 3595 "/org/freedesktop/TestSuite", 3596 "org.freedesktop.TestSuite", 3597 "Echo"); 3598 3599 if (message == NULL) 3600 return TRUE; 3601 3602 if (!dbus_connection_send (connection, message, &serial)) 3603 { 3604 dbus_message_unref (message); 3605 return TRUE; 3606 } 3607 3608 dbus_message_unref (message); 3609 message = NULL; 3610 3611 bus_test_run_everything (context); 3612 block_connection_until_message_from_bus (context, connection, 3613 "reply to service which should fail to auto-start (missing Service)"); 3614 bus_test_run_everything (context); 3615 3616 if (!dbus_connection_get_is_connected (connection)) 3617 { 3618 _dbus_warn ("connection was disconnected\n"); 3619 return TRUE; 3620 } 3621 3622 retval = FALSE; 3623 3624 message = pop_message_waiting_for_memory (connection); 3625 if (message == NULL) 3626 { 3627 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 3628 "Echo message (auto activation)", serial, connection); 3629 goto out; 3630 } 3631 3632 verbose_message_received (connection, message); 3633 3634 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 3635 { 3636 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 3637 { 3638 _dbus_warn ("Message has wrong sender %s\n", 3639 dbus_message_get_sender (message) ? 3640 dbus_message_get_sender (message) : "(none)"); 3641 goto out; 3642 } 3643 3644 if (dbus_message_is_error (message, 3645 DBUS_ERROR_NO_MEMORY)) 3646 { 3647 ; /* good, this is a valid response */ 3648 } 3649 else if (dbus_message_is_error (message, 3650 DBUS_ERROR_SERVICE_UNKNOWN)) 3651 { 3652 _dbus_verbose("could not activate as invalid service file was not added\n"); 3653 ; /* good, this is expected as we shouldn't have been added to 3654 * the activation list with a missing Exec key */ 3655 } 3656 else if (dbus_message_is_error (message, 3657 DBUS_ERROR_SPAWN_FILE_INVALID)) 3658 { 3659 _dbus_verbose("got service file invalid\n"); 3660 ; /* good, this is allowed, and is the message passed back from the 3661 * launch helper */ 3662 } 3663 else 3664 { 3665 warn_unexpected (connection, message, "not this error"); 3666 3667 goto out; 3668 } 3669 } 3670 else 3671 { 3672 _dbus_warn ("Did not expect to successfully auto-start missing service\n"); 3673 goto out; 3674 } 3675 3676 retval = TRUE; 3677 3678 out: 3679 if (message) 3680 dbus_message_unref (message); 3681 3682 return retval; 3683 } 3684 3685 #define SHELL_FAIL_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceFail" 3686 3687 /* returns TRUE if the correct thing happens, 3688 * but the correct thing may include OOM errors. 3689 */ 3690 static dbus_bool_t 3691 check_shell_fail_service_auto_start (BusContext *context, 3692 DBusConnection *connection) 3693 { 3694 DBusMessage *message; 3695 dbus_uint32_t serial; 3696 dbus_bool_t retval; 3697 3698 message = dbus_message_new_method_call (SHELL_FAIL_SERVICE_NAME, 3699 "/org/freedesktop/TestSuite", 3700 "org.freedesktop.TestSuite", 3701 "Echo"); 3702 3703 if (message == NULL) 3704 return TRUE; 3705 3706 if (!dbus_connection_send (connection, message, &serial)) 3707 { 3708 dbus_message_unref (message); 3709 return TRUE; 3710 } 3711 3712 dbus_message_unref (message); 3713 message = NULL; 3714 3715 bus_test_run_everything (context); 3716 block_connection_until_message_from_bus (context, connection, "reply to shell Echo on service which should fail to auto-start"); 3717 bus_test_run_everything (context); 3718 3719 if (!dbus_connection_get_is_connected (connection)) 3720 { 3721 _dbus_verbose ("connection was disconnected\n"); 3722 return TRUE; 3723 } 3724 3725 retval = FALSE; 3726 3727 message = pop_message_waiting_for_memory (connection); 3728 if (message == NULL) 3729 { 3730 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 3731 "Echo message (auto activation)", serial, connection); 3732 goto out; 3733 } 3734 3735 verbose_message_received (connection, message); 3736 3737 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 3738 { 3739 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 3740 { 3741 _dbus_warn ("Message has wrong sender %s\n", 3742 dbus_message_get_sender (message) ? 3743 dbus_message_get_sender (message) : "(none)"); 3744 goto out; 3745 } 3746 3747 if (dbus_message_is_error (message, 3748 DBUS_ERROR_NO_MEMORY)) 3749 { 3750 ; /* good, this is a valid response */ 3751 } 3752 else if (dbus_message_is_error (message, 3753 DBUS_ERROR_INVALID_ARGS)) 3754 { 3755 _dbus_verbose("got invalid args\n"); 3756 ; /* good, this is expected also */ 3757 } 3758 else 3759 { 3760 warn_unexpected (connection, message, "not this error"); 3761 3762 goto out; 3763 } 3764 } 3765 else 3766 { 3767 _dbus_warn ("Did not expect to successfully auto-start shell fail service\n"); 3768 goto out; 3769 } 3770 3771 retval = TRUE; 3772 3773 out: 3774 if (message) 3775 dbus_message_unref (message); 3776 3777 return retval; 3778 } 3779 3780 #define SHELL_SUCCESS_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceSuccess" 3781 3782 /* returns TRUE if the correct thing happens, 3783 * but the correct thing may include OOM errors. 3784 */ 3785 static dbus_bool_t 3786 check_shell_service_success_auto_start (BusContext *context, 3787 DBusConnection *connection) 3788 { 3789 DBusMessage *message; 3790 DBusMessage *base_service_message; 3791 dbus_uint32_t serial; 3792 dbus_bool_t retval; 3793 const char *base_service; 3794 const char *argv[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL}; 3795 3796 base_service_message = NULL; 3797 3798 message = dbus_message_new_method_call (SHELL_SUCCESS_SERVICE_NAME, 3799 "/org/freedesktop/TestSuite", 3800 "org.freedesktop.TestSuite", 3801 "Echo"); 3802 3803 if (message == NULL) 3804 return TRUE; 3805 3806 if (!dbus_connection_send (connection, message, &serial)) 3807 { 3808 dbus_message_unref (message); 3809 return TRUE; 3810 } 3811 3812 dbus_message_unref (message); 3813 message = NULL; 3814 3815 bus_test_run_everything (context); 3816 3817 /* now wait for the message bus to hear back from the activated 3818 * service. 3819 */ 3820 block_connection_until_message_from_bus (context, connection, "reply to Echo on shell success service"); 3821 bus_test_run_everything (context); 3822 3823 if (!dbus_connection_get_is_connected (connection)) 3824 { 3825 _dbus_verbose ("connection was disconnected\n"); 3826 return TRUE; 3827 } 3828 3829 retval = FALSE; 3830 3831 message = pop_message_waiting_for_memory (connection); 3832 if (message == NULL) 3833 { 3834 _dbus_warn ("Did not receive any messages after auto start %d on %p\n", 3835 serial, connection); 3836 goto out; 3837 } 3838 3839 verbose_message_received (connection, message); 3840 _dbus_verbose (" (after sending %s)\n", "auto start"); 3841 3842 /* we should get zero or two ServiceOwnerChanged signals */ 3843 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL) 3844 { 3845 GotServiceInfo message_kind; 3846 3847 if (!check_base_service_activated (context, connection, 3848 message, &base_service)) 3849 goto out; 3850 3851 base_service_message = message; 3852 message = NULL; 3853 3854 /* We may need to block here for the test service to exit or finish up */ 3855 block_connection_until_message_from_bus (context, connection, "service to exit"); 3856 3857 /* Should get a service creation notification for the activated 3858 * service name, or a service deletion on the base service name 3859 */ 3860 message = dbus_connection_borrow_message (connection); 3861 if (message == NULL) 3862 { 3863 _dbus_warn ("No message after auto activation " 3864 "(should be a service announcement)\n"); 3865 dbus_connection_return_message (connection, message); 3866 message = NULL; 3867 goto out; 3868 } 3869 3870 message_kind = check_got_service_info (message); 3871 3872 dbus_connection_return_message (connection, message); 3873 message = NULL; 3874 3875 switch (message_kind) 3876 { 3877 case GOT_SERVICE_CREATED: 3878 message = pop_message_waiting_for_memory (connection); 3879 if (message == NULL) 3880 { 3881 _dbus_warn ("Failed to pop message we just put back! " 3882 "should have been a NameOwnerChanged (creation)\n"); 3883 goto out; 3884 } 3885 3886 /* Check that ServiceOwnerChanged (creation) was correctly received */ 3887 if (!check_service_auto_activated (context, connection, SHELL_SUCCESS_SERVICE_NAME, 3888 base_service, message)) 3889 goto out; 3890 3891 dbus_message_unref (message); 3892 message = NULL; 3893 3894 break; 3895 3896 case GOT_SERVICE_DELETED: 3897 { 3898 /* The service started up and got a base address, but then 3899 * failed to register under SHELL_SUCCESS_SERVICE_NAME 3900 */ 3901 CheckServiceOwnerChangedData socd; 3902 3903 socd.expected_kind = SERVICE_DELETED; 3904 socd.expected_service_name = base_service; 3905 socd.failed = FALSE; 3906 socd.skip_connection = NULL; 3907 bus_test_clients_foreach (check_service_owner_changed_foreach, 3908 &socd); 3909 3910 if (socd.failed) 3911 goto out; 3912 3913 break; 3914 } 3915 3916 case GOT_ERROR: 3917 case GOT_SOMETHING_ELSE: 3918 _dbus_warn ("Unexpected message after auto activation\n"); 3919 goto out; 3920 } 3921 } 3922 3923 /* OK, now we've dealt with ServiceOwnerChanged signals, now should 3924 * come the method reply (or error) from the initial method call 3925 */ 3926 3927 /* Note: if this test is run in OOM mode, it will block when the bus 3928 * doesn't send a reply due to OOM. 3929 */ 3930 block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation"); 3931 3932 message = pop_message_waiting_for_memory (connection); 3933 if (message == NULL) 3934 { 3935 _dbus_warn ("Failed to pop message! Should have been reply from echo message\n"); 3936 goto out; 3937 } 3938 3939 if (dbus_message_get_reply_serial (message) != serial) 3940 { 3941 _dbus_warn ("Wrong reply serial\n"); 3942 goto out; 3943 } 3944 3945 if (!dbus_message_get_args (message, NULL, 3946 DBUS_TYPE_STRING, &argv[0], 3947 DBUS_TYPE_STRING, &argv[1], 3948 DBUS_TYPE_STRING, &argv[2], 3949 DBUS_TYPE_STRING, &argv[3], 3950 DBUS_TYPE_STRING, &argv[4], 3951 DBUS_TYPE_STRING, &argv[5], 3952 DBUS_TYPE_STRING, &argv[6], 3953 DBUS_TYPE_INVALID)) 3954 { 3955 _dbus_warn ("Error getting arguments from return\n"); 3956 goto out; 3957 } 3958 3959 /* don't worry about arg[0] as it may be different 3960 depending on the path to the tests 3961 */ 3962 if (strcmp("-test", argv[1]) != 0) 3963 { 3964 _dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n", 3965 "-test", argv[1]); 3966 goto out; 3967 } 3968 3969 if (strcmp("that", argv[2]) != 0) 3970 { 3971 _dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n", 3972 "that", argv[2]); 3973 goto out; 3974 } 3975 3976 if (strcmp("we get", argv[3]) != 0) 3977 { 3978 _dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n", 3979 "we get", argv[3]); 3980 goto out; 3981 } 3982 3983 if (strcmp("back", argv[4]) != 0) 3984 { 3985 _dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n", 3986 "back", argv[4]); 3987 goto out; 3988 } 3989 3990 if (strcmp("--what", argv[5]) != 0) 3991 { 3992 _dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n", 3993 "--what", argv[5]); 3994 goto out; 3995 } 3996 3997 if (strcmp("we put in", argv[6]) != 0) 3998 { 3999 _dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n", 4000 "we put in", argv[6]); 4001 goto out; 4002 } 4003 4004 dbus_message_unref (message); 4005 message = NULL; 4006 4007 if (!check_send_exit_to_service (context, connection, 4008 SHELL_SUCCESS_SERVICE_NAME, 4009 base_service)) 4010 goto out; 4011 4012 retval = TRUE; 4013 4014 out: 4015 if (message) 4016 dbus_message_unref (message); 4017 4018 if (base_service_message) 4019 dbus_message_unref (base_service_message); 4020 4021 return retval; 4022 } 4023 4024 typedef struct 4025 { 4026 Check1Func func; 4027 BusContext *context; 4028 } Check1Data; 4029 4030 static dbus_bool_t 4031 check_oom_check1_func (void *data) 4032 { 4033 Check1Data *d = data; 4034 4035 if (! (* d->func) (d->context)) 4036 return FALSE; 4037 4038 if (!check_no_leftovers (d->context)) 4039 { 4040 _dbus_warn ("Messages were left over, should be covered by test suite\n"); 4041 return FALSE; 4042 } 4043 4044 return TRUE; 4045 } 4046 4047 static void 4048 check1_try_iterations (BusContext *context, 4049 const char *description, 4050 Check1Func func) 4051 { 4052 Check1Data d; 4053 4054 d.func = func; 4055 d.context = context; 4056 4057 if (!_dbus_test_oom_handling (description, check_oom_check1_func, 4058 &d)) 4059 _dbus_assert_not_reached ("test failed"); 4060 } 4061 4062 static dbus_bool_t 4063 check_get_services (BusContext *context, 4064 DBusConnection *connection, 4065 const char *method, 4066 char ***services, 4067 int *len) 4068 { 4069 DBusMessage *message; 4070 dbus_uint32_t serial; 4071 dbus_bool_t retval; 4072 DBusError error; 4073 char **srvs; 4074 int l; 4075 4076 retval = FALSE; 4077 dbus_error_init (&error); 4078 message = NULL; 4079 4080 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 4081 DBUS_PATH_DBUS, 4082 DBUS_INTERFACE_DBUS, 4083 method); 4084 4085 if (message == NULL) 4086 return TRUE; 4087 4088 if (!dbus_connection_send (connection, message, &serial)) 4089 { 4090 dbus_message_unref (message); 4091 return TRUE; 4092 } 4093 4094 /* send our message */ 4095 bus_test_run_clients_loop (SEND_PENDING (connection)); 4096 4097 dbus_message_unref (message); 4098 message = NULL; 4099 4100 dbus_connection_ref (connection); /* because we may get disconnected */ 4101 block_connection_until_message_from_bus (context, connection, "reply to ListActivatableNames/ListNames"); 4102 4103 if (!dbus_connection_get_is_connected (connection)) 4104 { 4105 _dbus_verbose ("connection was disconnected\n"); 4106 4107 dbus_connection_unref (connection); 4108 4109 return TRUE; 4110 } 4111 4112 dbus_connection_unref (connection); 4113 4114 message = pop_message_waiting_for_memory (connection); 4115 if (message == NULL) 4116 { 4117 _dbus_warn ("Did not receive a reply to %s %d on %p\n", 4118 method, serial, connection); 4119 goto out; 4120 } 4121 4122 verbose_message_received (connection, message); 4123 4124 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 4125 { 4126 if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY)) 4127 { 4128 ; /* good, this is a valid response */ 4129 } 4130 else 4131 { 4132 warn_unexpected (connection, message, "not this error"); 4133 4134 goto out; 4135 } 4136 } 4137 else 4138 { 4139 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN) 4140 { 4141 ; /* good, expected */ 4142 } 4143 else 4144 { 4145 warn_unexpected (connection, message, 4146 "method_return for ListActivatableNames/ListNames"); 4147 4148 goto out; 4149 } 4150 4151 retry_get_property: 4152 4153 if (!dbus_message_get_args (message, &error, 4154 DBUS_TYPE_ARRAY, 4155 DBUS_TYPE_STRING, 4156 &srvs, &l, 4157 DBUS_TYPE_INVALID)) 4158 { 4159 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 4160 { 4161 _dbus_verbose ("no memory to list services by %s\n", method); 4162 dbus_error_free (&error); 4163 _dbus_wait_for_memory (); 4164 goto retry_get_property; 4165 } 4166 else 4167 { 4168 _dbus_assert (dbus_error_is_set (&error)); 4169 _dbus_warn ("Did not get the expected DBUS_TYPE_ARRAY from %s\n", method); 4170 goto out; 4171 } 4172 } else { 4173 *services = srvs; 4174 *len = l; 4175 } 4176 } 4177 4178 if (!check_no_leftovers (context)) 4179 goto out; 4180 4181 retval = TRUE; 4182 4183 out: 4184 dbus_error_free (&error); 4185 4186 if (message) 4187 dbus_message_unref (message); 4188 4189 return retval; 4190 } 4191 4192 /* returns TRUE if the correct thing happens, 4193 * but the correct thing may include OOM errors. 4194 */ 4195 static dbus_bool_t 4196 check_list_services (BusContext *context, 4197 DBusConnection *connection) 4198 { 4199 DBusMessage *message; 4200 DBusMessage *base_service_message; 4201 const char *base_service; 4202 dbus_uint32_t serial; 4203 dbus_bool_t retval; 4204 const char *existent = EXISTENT_SERVICE_NAME; 4205 dbus_uint32_t flags; 4206 char **services; 4207 int len; 4208 4209 _dbus_verbose ("check_list_services for %p\n", connection); 4210 4211 if (!check_get_services (context, connection, "ListActivatableNames", &services, &len)) 4212 { 4213 return TRUE; 4214 } 4215 4216 if (!_dbus_string_array_contains ((const char **)services, existent)) 4217 { 4218 _dbus_warn ("Did not get the expected %s from ListActivatableNames\n", existent); 4219 dbus_free_string_array (services); 4220 return FALSE; 4221 } 4222 4223 dbus_free_string_array (services); 4224 4225 base_service_message = NULL; 4226 4227 message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, 4228 DBUS_PATH_DBUS, 4229 DBUS_INTERFACE_DBUS, 4230 "StartServiceByName"); 4231 4232 if (message == NULL) 4233 return TRUE; 4234 4235 dbus_message_set_auto_start (message, FALSE); 4236 4237 flags = 0; 4238 if (!dbus_message_append_args (message, 4239 DBUS_TYPE_STRING, &existent, 4240 DBUS_TYPE_UINT32, &flags, 4241 DBUS_TYPE_INVALID)) 4242 { 4243 dbus_message_unref (message); 4244 return TRUE; 4245 } 4246 4247 if (!dbus_connection_send (connection, message, &serial)) 4248 { 4249 dbus_message_unref (message); 4250 return TRUE; 4251 } 4252 4253 dbus_message_unref (message); 4254 message = NULL; 4255 4256 bus_test_run_everything (context); 4257 4258 /* now wait for the message bus to hear back from the activated 4259 * service. 4260 */ 4261 block_connection_until_message_from_bus (context, connection, "activated service to connect"); 4262 4263 bus_test_run_everything (context); 4264 4265 if (!dbus_connection_get_is_connected (connection)) 4266 { 4267 _dbus_verbose ("connection was disconnected\n"); 4268 return TRUE; 4269 } 4270 4271 retval = FALSE; 4272 4273 message = pop_message_waiting_for_memory (connection); 4274 if (message == NULL) 4275 { 4276 _dbus_warn ("Did not receive any messages after %s %d on %p\n", 4277 "StartServiceByName", serial, connection); 4278 goto out; 4279 } 4280 4281 verbose_message_received (connection, message); 4282 _dbus_verbose (" (after sending %s)\n", "StartServiceByName"); 4283 4284 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR) 4285 { 4286 if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS)) 4287 { 4288 _dbus_warn ("Message has wrong sender %s\n", 4289 dbus_message_get_sender (message) ? 4290 dbus_message_get_sender (message) : "(none)"); 4291 goto out; 4292 } 4293 4294 if (dbus_message_is_error (message, 4295 DBUS_ERROR_NO_MEMORY)) 4296 { 4297 ; /* good, this is a valid response */ 4298 } 4299 else if (dbus_message_is_error (message, 4300 DBUS_ERROR_SPAWN_CHILD_EXITED) || 4301 dbus_message_is_error (message, 4302 DBUS_ERROR_SPAWN_CHILD_SIGNALED) || 4303 dbus_message_is_error (message, 4304 DBUS_ERROR_SPAWN_EXEC_FAILED)) 4305 { 4306 ; /* good, this is expected also */ 4307 } 4308 else 4309 { 4310 _dbus_warn ("Did not expect error %s\n", 4311 dbus_message_get_error_name (message)); 4312 goto out; 4313 } 4314 } 4315 else 4316 { 4317 GotServiceInfo message_kind; 4318 4319 if (!check_base_service_activated (context, connection, 4320 message, &base_service)) 4321 goto out; 4322 4323 base_service_message = message; 4324 message = NULL; 4325 4326 /* We may need to block here for the test service to exit or finish up */ 4327 block_connection_until_message_from_bus (context, connection, "test service to exit or finish up"); 4328 4329 message = dbus_connection_borrow_message (connection); 4330 if (message == NULL) 4331 { 4332 _dbus_warn ("Did not receive any messages after base service creation notification\n"); 4333 goto out; 4334 } 4335 4336 message_kind = check_got_service_info (message); 4337 4338 dbus_connection_return_message (connection, message); 4339 message = NULL; 4340 4341 switch (message_kind) 4342 { 4343 case GOT_SOMETHING_ELSE: 4344 case GOT_ERROR: 4345 case GOT_SERVICE_DELETED: 4346 _dbus_warn ("Unexpected message after ActivateService " 4347 "(should be an error or a service announcement)\n"); 4348 goto out; 4349 4350 case GOT_SERVICE_CREATED: 4351 message = pop_message_waiting_for_memory (connection); 4352 if (message == NULL) 4353 { 4354 _dbus_warn ("Failed to pop message we just put back! " 4355 "should have been a NameOwnerChanged (creation)\n"); 4356 goto out; 4357 } 4358 4359 if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME, 4360 base_service, message)) 4361 goto out; 4362 4363 dbus_message_unref (message); 4364 message = NULL; 4365 4366 if (!check_no_leftovers (context)) 4367 { 4368 _dbus_warn ("Messages were left over after successful activation\n"); 4369 goto out; 4370 } 4371 4372 break; 4373 } 4374 } 4375 4376 if (!check_get_services (context, connection, "ListNames", &services, &len)) 4377 { 4378 return TRUE; 4379 } 4380 4381 if (!_dbus_string_array_contains ((const char **)services, existent)) 4382 { 4383 _dbus_warn ("Did not get the expected %s from ListNames\n", existent); 4384 goto out; 4385 } 4386 4387 dbus_free_string_array (services); 4388 4389 if (!check_send_exit_to_service (context, connection, 4390 EXISTENT_SERVICE_NAME, base_service)) 4391 goto out; 4392 4393 retval = TRUE; 4394 4395 out: 4396 if (message) 4397 dbus_message_unref (message); 4398 4399 if (base_service_message) 4400 dbus_message_unref (base_service_message); 4401 4402 return retval; 4403 } 4404 4405 typedef struct 4406 { 4407 Check2Func func; 4408 BusContext *context; 4409 DBusConnection *connection; 4410 } Check2Data; 4411 4412 static dbus_bool_t 4413 check_oom_check2_func (void *data) 4414 { 4415 Check2Data *d = data; 4416 4417 if (! (* d->func) (d->context, d->connection)) 4418 return FALSE; 4419 4420 if (!check_no_leftovers (d->context)) 4421 { 4422 _dbus_warn ("Messages were left over, should be covered by test suite\n"); 4423 return FALSE; 4424 } 4425 4426 return TRUE; 4427 } 4428 4429 static void 4430 check2_try_iterations (BusContext *context, 4431 DBusConnection *connection, 4432 const char *description, 4433 Check2Func func) 4434 { 4435 Check2Data d; 4436 4437 d.func = func; 4438 d.context = context; 4439 d.connection = connection; 4440 4441 if (!_dbus_test_oom_handling (description, check_oom_check2_func, 4442 &d)) 4443 { 4444 _dbus_warn ("%s failed during oom\n", description); 4445 _dbus_assert_not_reached ("test failed"); 4446 } 4447 } 4448 4449 static dbus_bool_t 4450 setenv_TEST_LAUNCH_HELPER_CONFIG(const DBusString *test_data_dir, 4451 const char *filename) 4452 { 4453 DBusString full; 4454 DBusString file; 4455 4456 if (!_dbus_string_init (&full)) 4457 return FALSE; 4458 4459 if (!_dbus_string_copy (test_data_dir, 0, &full, 0)) 4460 { 4461 _dbus_string_free (&full); 4462 return FALSE; 4463 } 4464 4465 _dbus_string_init_const (&file, filename); 4466 4467 if (!_dbus_concat_dir_and_file (&full, &file)) 4468 { 4469 _dbus_string_free (&full); 4470 return FALSE; 4471 } 4472 4473 _dbus_verbose ("Setting TEST_LAUNCH_HELPER_CONFIG to '%s'\n", 4474 _dbus_string_get_const_data (&full)); 4475 4476 _dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG", _dbus_string_get_const_data (&full)); 4477 4478 _dbus_string_free (&full); 4479 4480 return TRUE; 4481 } 4482 4483 static dbus_bool_t 4484 bus_dispatch_test_conf (const DBusString *test_data_dir, 4485 const char *filename, 4486 dbus_bool_t use_launcher) 4487 { 4488 BusContext *context; 4489 DBusConnection *foo; 4490 DBusConnection *bar; 4491 DBusConnection *baz; 4492 DBusError error; 4493 4494 /* save the config name for the activation helper */ 4495 if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename)) 4496 _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG"); 4497 4498 dbus_error_init (&error); 4499 4500 context = bus_context_new_test (test_data_dir, filename); 4501 if (context == NULL) 4502 return FALSE; 4503 4504 foo = dbus_connection_open_private (TEST_CONNECTION, &error); 4505 if (foo == NULL) 4506 _dbus_assert_not_reached ("could not alloc connection"); 4507 4508 if (!bus_setup_debug_client (foo)) 4509 _dbus_assert_not_reached ("could not set up connection"); 4510 4511 spin_connection_until_authenticated (context, foo); 4512 4513 if (!check_hello_message (context, foo)) 4514 _dbus_assert_not_reached ("hello message failed"); 4515 4516 if (!check_double_hello_message (context, foo)) 4517 _dbus_assert_not_reached ("double hello message failed"); 4518 4519 if (!check_add_match_all (context, foo)) 4520 _dbus_assert_not_reached ("AddMatch message failed"); 4521 4522 bar = dbus_connection_open_private (TEST_CONNECTION, &error); 4523 if (bar == NULL) 4524 _dbus_assert_not_reached ("could not alloc connection"); 4525 4526 if (!bus_setup_debug_client (bar)) 4527 _dbus_assert_not_reached ("could not set up connection"); 4528 4529 spin_connection_until_authenticated (context, bar); 4530 4531 if (!check_hello_message (context, bar)) 4532 _dbus_assert_not_reached ("hello message failed"); 4533 4534 if (!check_add_match_all (context, bar)) 4535 _dbus_assert_not_reached ("AddMatch message failed"); 4536 4537 baz = dbus_connection_open_private (TEST_CONNECTION, &error); 4538 if (baz == NULL) 4539 _dbus_assert_not_reached ("could not alloc connection"); 4540 4541 if (!bus_setup_debug_client (baz)) 4542 _dbus_assert_not_reached ("could not set up connection"); 4543 4544 spin_connection_until_authenticated (context, baz); 4545 4546 if (!check_hello_message (context, baz)) 4547 _dbus_assert_not_reached ("hello message failed"); 4548 4549 if (!check_add_match_all (context, baz)) 4550 _dbus_assert_not_reached ("AddMatch message failed"); 4551 4552 #ifdef DBUS_WIN_FIXME 4553 _dbus_warn("TODO: testing of GetConnectionUnixUser message skipped for now\n"); 4554 _dbus_warn("TODO: testing of GetConnectionUnixProcessID message skipped for now\n"); 4555 #else 4556 if (!check_get_connection_unix_user (context, baz)) 4557 _dbus_assert_not_reached ("GetConnectionUnixUser message failed"); 4558 4559 if (!check_get_connection_unix_process_id (context, baz)) 4560 _dbus_assert_not_reached ("GetConnectionUnixProcessID message failed"); 4561 #endif 4562 4563 if (!check_list_services (context, baz)) 4564 _dbus_assert_not_reached ("ListActivatableNames message failed"); 4565 4566 if (!check_no_leftovers (context)) 4567 { 4568 _dbus_warn ("Messages were left over after setting up initial connections\n"); 4569 _dbus_assert_not_reached ("initial connection setup failed"); 4570 } 4571 4572 check1_try_iterations (context, "create_and_hello", 4573 check_hello_connection); 4574 4575 check2_try_iterations (context, foo, "nonexistent_service_no_auto_start", 4576 check_nonexistent_service_no_auto_start); 4577 4578 #ifdef DBUS_WIN_FIXME 4579 _dbus_warn("TODO: dispatch.c segfault_service_no_auto_start test\n"); 4580 #else 4581 check2_try_iterations (context, foo, "segfault_service_no_auto_start", 4582 check_segfault_service_no_auto_start); 4583 #endif 4584 4585 check2_try_iterations (context, foo, "existent_service_no_auto_start", 4586 check_existent_service_no_auto_start); 4587 4588 check2_try_iterations (context, foo, "nonexistent_service_auto_start", 4589 check_nonexistent_service_auto_start); 4590 4591 4592 #ifdef DBUS_WIN_FIXME 4593 _dbus_warn("TODO: dispatch.c segfault_service_auto_start test\n"); 4594 #else 4595 /* only do the segfault test if we are not using the launcher */ 4596 check2_try_iterations (context, foo, "segfault_service_auto_start", 4597 check_segfault_service_auto_start); 4598 #endif 4599 4600 /* only do the shell fail test if we are not using the launcher */ 4601 check2_try_iterations (context, foo, "shell_fail_service_auto_start", 4602 check_shell_fail_service_auto_start); 4603 4604 /* specific to launcher */ 4605 if (use_launcher) 4606 if (!check_launch_service_file_missing (context, foo)) 4607 _dbus_assert_not_reached ("did not get service file not found error"); 4608 4609 #if 0 4610 /* Note: need to resolve some issues with the testing code in order to run 4611 * this in oom (handle that we sometimes don't get replies back from the bus 4612 * when oom happens, without blocking the test). 4613 */ 4614 check2_try_iterations (context, foo, "existent_service_auto_auto_start", 4615 check_existent_service_auto_start); 4616 #endif 4617 4618 if (!check_existent_service_auto_start (context, foo)) 4619 _dbus_assert_not_reached ("existent service auto start failed"); 4620 4621 if (!check_shell_service_success_auto_start (context, foo)) 4622 _dbus_assert_not_reached ("shell success service auto start failed"); 4623 4624 _dbus_verbose ("Disconnecting foo, bar, and baz\n"); 4625 4626 kill_client_connection_unchecked (foo); 4627 kill_client_connection_unchecked (bar); 4628 kill_client_connection_unchecked (baz); 4629 4630 bus_context_unref (context); 4631 4632 return TRUE; 4633 } 4634 4635 static dbus_bool_t 4636 bus_dispatch_test_conf_fail (const DBusString *test_data_dir, 4637 const char *filename) 4638 { 4639 BusContext *context; 4640 DBusConnection *foo; 4641 DBusError error; 4642 4643 /* save the config name for the activation helper */ 4644 if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename)) 4645 _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG"); 4646 4647 dbus_error_init (&error); 4648 4649 context = bus_context_new_test (test_data_dir, filename); 4650 if (context == NULL) 4651 return FALSE; 4652 4653 foo = dbus_connection_open_private (TEST_CONNECTION, &error); 4654 if (foo == NULL) 4655 _dbus_assert_not_reached ("could not alloc connection"); 4656 4657 if (!bus_setup_debug_client (foo)) 4658 _dbus_assert_not_reached ("could not set up connection"); 4659 4660 spin_connection_until_authenticated (context, foo); 4661 4662 if (!check_hello_message (context, foo)) 4663 _dbus_assert_not_reached ("hello message failed"); 4664 4665 if (!check_double_hello_message (context, foo)) 4666 _dbus_assert_not_reached ("double hello message failed"); 4667 4668 if (!check_add_match_all (context, foo)) 4669 _dbus_assert_not_reached ("AddMatch message failed"); 4670 4671 /* this only tests the activation.c user check */ 4672 if (!check_launch_service_user_missing (context, foo)) 4673 _dbus_assert_not_reached ("user missing did not trigger error"); 4674 4675 /* this only tests the desktop.c exec check */ 4676 if (!check_launch_service_exec_missing (context, foo)) 4677 _dbus_assert_not_reached ("exec missing did not trigger error"); 4678 4679 /* this only tests the desktop.c service check */ 4680 if (!check_launch_service_service_missing (context, foo)) 4681 _dbus_assert_not_reached ("service missing did not trigger error"); 4682 4683 _dbus_verbose ("Disconnecting foo\n"); 4684 4685 kill_client_connection_unchecked (foo); 4686 4687 bus_context_unref (context); 4688 4689 return TRUE; 4690 } 4691 4692 dbus_bool_t 4693 bus_dispatch_test (const DBusString *test_data_dir) 4694 { 4695 /* run normal activation tests */ 4696 _dbus_verbose ("Normal activation tests\n"); 4697 if (!bus_dispatch_test_conf (test_data_dir, 4698 "valid-config-files/debug-allow-all.conf", FALSE)) 4699 return FALSE; 4700 4701 #ifdef DBUS_WIN 4702 _dbus_warn("Info: Launch helper activation tests skipped because launch-helper is not supported yet\n"); 4703 #else 4704 /* run launch-helper activation tests */ 4705 _dbus_verbose ("Launch helper activation tests\n"); 4706 if (!bus_dispatch_test_conf (test_data_dir, 4707 "valid-config-files-system/debug-allow-all-pass.conf", TRUE)) 4708 return FALSE; 4709 4710 /* run select launch-helper activation tests on broken service files */ 4711 if (!bus_dispatch_test_conf_fail (test_data_dir, 4712 "valid-config-files-system/debug-allow-all-fail.conf")) 4713 return FALSE; 4714 #endif 4715 4716 return TRUE; 4717 } 4718 4719 dbus_bool_t 4720 bus_dispatch_sha1_test (const DBusString *test_data_dir) 4721 { 4722 BusContext *context; 4723 DBusConnection *foo; 4724 DBusError error; 4725 4726 dbus_error_init (&error); 4727 4728 /* Test SHA1 authentication */ 4729 _dbus_verbose ("Testing SHA1 context\n"); 4730 4731 context = bus_context_new_test (test_data_dir, 4732 "valid-config-files/debug-allow-all-sha1.conf"); 4733 if (context == NULL) 4734 return FALSE; 4735 4736 foo = dbus_connection_open_private (TEST_CONNECTION, &error); 4737 if (foo == NULL) 4738 _dbus_assert_not_reached ("could not alloc connection"); 4739 4740 if (!bus_setup_debug_client (foo)) 4741 _dbus_assert_not_reached ("could not set up connection"); 4742 4743 spin_connection_until_authenticated (context, foo); 4744 4745 if (!check_hello_message (context, foo)) 4746 _dbus_assert_not_reached ("hello message failed"); 4747 4748 if (!check_add_match_all (context, foo)) 4749 _dbus_assert_not_reached ("addmatch message failed"); 4750 4751 if (!check_no_leftovers (context)) 4752 { 4753 _dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n"); 4754 _dbus_assert_not_reached ("initial connection setup failed"); 4755 } 4756 4757 check1_try_iterations (context, "create_and_hello_sha1", 4758 check_hello_connection); 4759 4760 kill_client_connection_unchecked (foo); 4761 4762 bus_context_unref (context); 4763 4764 return TRUE; 4765 } 4766 4767 #ifdef HAVE_UNIX_FD_PASSING 4768 4769 dbus_bool_t 4770 bus_unix_fds_passing_test(const DBusString *test_data_dir) 4771 { 4772 BusContext *context; 4773 DBusConnection *foo, *bar; 4774 DBusError error; 4775 DBusMessage *m; 4776 dbus_bool_t b; 4777 int one[2], two[2], x, y, z; 4778 char r; 4779 4780 dbus_error_init (&error); 4781 4782 context = bus_context_new_test (test_data_dir, "valid-config-files/debug-allow-all.conf"); 4783 if (context == NULL) 4784 _dbus_assert_not_reached ("could not alloc context"); 4785 4786 foo = dbus_connection_open_private (TEST_CONNECTION, &error); 4787 if (foo == NULL) 4788 _dbus_assert_not_reached ("could not alloc connection"); 4789 4790 if (!bus_setup_debug_client (foo)) 4791 _dbus_assert_not_reached ("could not set up connection"); 4792 4793 spin_connection_until_authenticated (context, foo); 4794 4795 if (!check_hello_message (context, foo)) 4796 _dbus_assert_not_reached ("hello message failed"); 4797 4798 if (!check_add_match_all (context, foo)) 4799 _dbus_assert_not_reached ("AddMatch message failed"); 4800 4801 bar = dbus_connection_open_private (TEST_CONNECTION, &error); 4802 if (bar == NULL) 4803 _dbus_assert_not_reached ("could not alloc connection"); 4804 4805 if (!bus_setup_debug_client (bar)) 4806 _dbus_assert_not_reached ("could not set up connection"); 4807 4808 spin_connection_until_authenticated (context, bar); 4809 4810 if (!check_hello_message (context, bar)) 4811 _dbus_assert_not_reached ("hello message failed"); 4812 4813 if (!check_add_match_all (context, bar)) 4814 _dbus_assert_not_reached ("AddMatch message failed"); 4815 4816 if (!(m = dbus_message_new_signal("/", "a.b.c", "d"))) 4817 _dbus_assert_not_reached ("could not alloc message"); 4818 4819 if (!(_dbus_full_duplex_pipe(one, one+1, TRUE, &error))) 4820 _dbus_assert_not_reached("Failed to allocate pipe #1"); 4821 4822 if (!(_dbus_full_duplex_pipe(two, two+1, TRUE, &error))) 4823 _dbus_assert_not_reached("Failed to allocate pipe #2"); 4824 4825 if (!dbus_message_append_args(m, 4826 DBUS_TYPE_UNIX_FD, one, 4827 DBUS_TYPE_UNIX_FD, two, 4828 DBUS_TYPE_UNIX_FD, two, 4829 DBUS_TYPE_INVALID)) 4830 _dbus_assert_not_reached("Failed to attach fds."); 4831 4832 if (!_dbus_close(one[0], &error)) 4833 _dbus_assert_not_reached("Failed to close pipe #1 "); 4834 if (!_dbus_close(two[0], &error)) 4835 _dbus_assert_not_reached("Failed to close pipe #2 "); 4836 4837 if (!(dbus_connection_can_send_type(foo, DBUS_TYPE_UNIX_FD))) 4838 _dbus_assert_not_reached("Connection cannot do fd passing"); 4839 4840 if (!(dbus_connection_can_send_type(bar, DBUS_TYPE_UNIX_FD))) 4841 _dbus_assert_not_reached("Connection cannot do fd passing"); 4842 4843 if (!dbus_connection_send (foo, m, NULL)) 4844 _dbus_assert_not_reached("Failed to send fds"); 4845 4846 dbus_message_unref(m); 4847 4848 bus_test_run_clients_loop (SEND_PENDING (foo)); 4849 4850 bus_test_run_everything (context); 4851 4852 block_connection_until_message_from_bus (context, foo, "unix fd reception on foo"); 4853 4854 if (!(m = pop_message_waiting_for_memory (foo))) 4855 _dbus_assert_not_reached("Failed to receive msg"); 4856 4857 if (!dbus_message_is_signal(m, "a.b.c", "d")) 4858 _dbus_assert_not_reached("bogus message received"); 4859 4860 dbus_message_unref(m); 4861 4862 block_connection_until_message_from_bus (context, bar, "unix fd reception on bar"); 4863 4864 if (!(m = pop_message_waiting_for_memory (bar))) 4865 _dbus_assert_not_reached("Failed to receive msg"); 4866 4867 if (!dbus_message_is_signal(m, "a.b.c", "d")) 4868 _dbus_assert_not_reached("bogus message received"); 4869 4870 if (!dbus_message_get_args(m, 4871 &error, 4872 DBUS_TYPE_UNIX_FD, &x, 4873 DBUS_TYPE_UNIX_FD, &y, 4874 DBUS_TYPE_UNIX_FD, &z, 4875 DBUS_TYPE_INVALID)) 4876 _dbus_assert_not_reached("Failed to parse fds."); 4877 4878 dbus_message_unref(m); 4879 4880 if (write(x, "X", 1) != 1) 4881 _dbus_assert_not_reached("Failed to write to pipe #1"); 4882 if (write(y, "Y", 1) != 1) 4883 _dbus_assert_not_reached("Failed to write to pipe #2"); 4884 if (write(z, "Z", 1) != 1) 4885 _dbus_assert_not_reached("Failed to write to pipe #2/2nd fd"); 4886 4887 if (!_dbus_close(x, &error)) 4888 _dbus_assert_not_reached("Failed to close pipe #1/other side "); 4889 if (!_dbus_close(y, &error)) 4890 _dbus_assert_not_reached("Failed to close pipe #2/other side "); 4891 if (!_dbus_close(z, &error)) 4892 _dbus_assert_not_reached("Failed to close pipe #2/other size 2nd fd "); 4893 4894 if (read(one[1], &r, 1) != 1 || r != 'X') 4895 _dbus_assert_not_reached("Failed to read value from pipe."); 4896 if (read(two[1], &r, 1) != 1 || r != 'Y') 4897 _dbus_assert_not_reached("Failed to read value from pipe."); 4898 if (read(two[1], &r, 1) != 1 || r != 'Z') 4899 _dbus_assert_not_reached("Failed to read value from pipe."); 4900 4901 if (!_dbus_close(one[1], &error)) 4902 _dbus_assert_not_reached("Failed to close pipe #1 "); 4903 if (!_dbus_close(two[1], &error)) 4904 _dbus_assert_not_reached("Failed to close pipe #2 "); 4905 4906 _dbus_verbose ("Disconnecting foo\n"); 4907 kill_client_connection_unchecked (foo); 4908 4909 _dbus_verbose ("Disconnecting bar\n"); 4910 kill_client_connection_unchecked (bar); 4911 4912 bus_context_unref (context); 4913 4914 return TRUE; 4915 } 4916 #endif 4917 4918 #endif /* DBUS_BUILD_TESTS */ 4919
