1 /* -*- mode: C; c-file-style: "gnu" -*- */ 2 /* dbus-transport.c DBusTransport object (internal to D-Bus implementation) 3 * 4 * Copyright (C) 2002, 2003 Red Hat Inc. 5 * 6 * Licensed under the Academic Free License version 2.1 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include "dbus-transport-protected.h" 25 #include "dbus-transport-unix.h" 26 #include "dbus-transport-socket.h" 27 #include "dbus-connection-internal.h" 28 #include "dbus-watch.h" 29 #include "dbus-auth.h" 30 #include "dbus-address.h" 31 #ifdef DBUS_BUILD_TESTS 32 #include "dbus-server-debug-pipe.h" 33 #endif 34 35 /** 36 * @defgroup DBusTransport DBusTransport object 37 * @ingroup DBusInternals 38 * @brief "Backend" for a DBusConnection. 39 * 40 * Types and functions related to DBusTransport. A transport is an 41 * abstraction that can send and receive data via various kinds of 42 * network connections or other IPC mechanisms. 43 * 44 * @{ 45 */ 46 47 /** 48 * @typedef DBusTransport 49 * 50 * Opaque object representing a way message stream. 51 * DBusTransport abstracts various kinds of actual 52 * transport mechanism, such as different network protocols, 53 * or encryption schemes. 54 */ 55 56 static void 57 live_messages_size_notify (DBusCounter *counter, 58 void *user_data) 59 { 60 DBusTransport *transport = user_data; 61 62 _dbus_transport_ref (transport); 63 64 #if 0 65 _dbus_verbose ("Counter value is now %d\n", 66 (int) _dbus_counter_get_value (counter)); 67 #endif 68 69 /* disable or re-enable the read watch for the transport if 70 * required. 71 */ 72 if (transport->vtable->live_messages_changed) 73 (* transport->vtable->live_messages_changed) (transport); 74 75 _dbus_transport_unref (transport); 76 } 77 78 /** 79 * Initializes the base class members of DBusTransport. Chained up to 80 * by subclasses in their constructor. The server GUID is the 81 * globally unique ID for the server creating this connection 82 * and will be #NULL for the client side of a connection. The GUID 83 * is in hex format. 84 * 85 * @param transport the transport being created. 86 * @param vtable the subclass vtable. 87 * @param server_guid non-#NULL if this transport is on the server side of a connection 88 * @param address the address of the transport 89 * @returns #TRUE on success. 90 */ 91 dbus_bool_t 92 _dbus_transport_init_base (DBusTransport *transport, 93 const DBusTransportVTable *vtable, 94 const DBusString *server_guid, 95 const DBusString *address) 96 { 97 DBusMessageLoader *loader; 98 DBusAuth *auth; 99 DBusCounter *counter; 100 char *address_copy; 101 102 loader = _dbus_message_loader_new (); 103 if (loader == NULL) 104 return FALSE; 105 106 if (server_guid) 107 auth = _dbus_auth_server_new (server_guid); 108 else 109 auth = _dbus_auth_client_new (); 110 if (auth == NULL) 111 { 112 _dbus_message_loader_unref (loader); 113 return FALSE; 114 } 115 116 counter = _dbus_counter_new (); 117 if (counter == NULL) 118 { 119 _dbus_auth_unref (auth); 120 _dbus_message_loader_unref (loader); 121 return FALSE; 122 } 123 124 if (server_guid) 125 { 126 _dbus_assert (address == NULL); 127 address_copy = NULL; 128 } 129 else 130 { 131 _dbus_assert (address != NULL); 132 133 if (!_dbus_string_copy_data (address, &address_copy)) 134 { 135 _dbus_counter_unref (counter); 136 _dbus_auth_unref (auth); 137 _dbus_message_loader_unref (loader); 138 return FALSE; 139 } 140 } 141 142 transport->refcount = 1; 143 transport->vtable = vtable; 144 transport->loader = loader; 145 transport->auth = auth; 146 transport->live_messages_size = counter; 147 transport->authenticated = FALSE; 148 transport->disconnected = FALSE; 149 transport->is_server = (server_guid != NULL); 150 transport->send_credentials_pending = !transport->is_server; 151 transport->receive_credentials_pending = transport->is_server; 152 transport->address = address_copy; 153 154 transport->unix_user_function = NULL; 155 transport->unix_user_data = NULL; 156 transport->free_unix_user_data = NULL; 157 158 transport->expected_guid = NULL; 159 160 /* Try to default to something that won't totally hose the system, 161 * but doesn't impose too much of a limitation. 162 */ 163 transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63; 164 165 transport->credentials.pid = -1; 166 transport->credentials.uid = -1; 167 transport->credentials.gid = -1; 168 169 _dbus_counter_set_notify (transport->live_messages_size, 170 transport->max_live_messages_size, 171 live_messages_size_notify, 172 transport); 173 174 if (transport->address) 175 _dbus_verbose ("Initialized transport on address %s\n", transport->address); 176 177 return TRUE; 178 } 179 180 /** 181 * Finalizes base class members of DBusTransport. 182 * Chained up to from subclass finalizers. 183 * 184 * @param transport the transport. 185 */ 186 void 187 _dbus_transport_finalize_base (DBusTransport *transport) 188 { 189 if (!transport->disconnected) 190 _dbus_transport_disconnect (transport); 191 192 if (transport->free_unix_user_data != NULL) 193 (* transport->free_unix_user_data) (transport->unix_user_data); 194 195 _dbus_message_loader_unref (transport->loader); 196 _dbus_auth_unref (transport->auth); 197 _dbus_counter_set_notify (transport->live_messages_size, 198 0, NULL, NULL); 199 _dbus_counter_unref (transport->live_messages_size); 200 dbus_free (transport->address); 201 dbus_free (transport->expected_guid); 202 } 203 204 205 /** 206 * Verifies if a given D-Bus address is a valid address 207 * by attempting to connect to it. If it is, returns the 208 * opened DBusTransport object. If it isn't, returns #NULL 209 * and sets @p error. 210 * 211 * @param error address where an error can be returned. 212 * @returns a new transport, or #NULL on failure. 213 */ 214 static DBusTransport* 215 check_address (const char *address, DBusError *error) 216 { 217 DBusAddressEntry **entries; 218 DBusTransport *transport = NULL; 219 int len, i; 220 221 _dbus_assert (address != NULL); 222 _dbus_assert (*address != '\0'); 223 224 if (!dbus_parse_address (address, &entries, &len, error)) 225 return FALSE; /* not a valid address */ 226 227 for (i = 0; i < len; i++) 228 { 229 transport = _dbus_transport_open (entries[i], error); 230 if (transport != NULL) 231 break; 232 } 233 234 dbus_address_entries_free (entries); 235 return transport; 236 } 237 238 /** 239 * Creates a new transport for the "autostart" method. 240 * This creates a client-side of a transport. 241 * 242 * @param error address where an error can be returned. 243 * @returns a new transport, or #NULL on failure. 244 */ 245 static DBusTransport* 246 _dbus_transport_new_for_autolaunch (DBusError *error) 247 { 248 DBusString address; 249 DBusTransport *result = NULL; 250 251 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 252 253 if (!_dbus_string_init (&address)) 254 { 255 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL); 256 return NULL; 257 } 258 259 if (!_dbus_get_autolaunch_address (&address, error)) 260 { 261 _DBUS_ASSERT_ERROR_IS_SET (error); 262 goto out; 263 } 264 265 result = check_address (_dbus_string_get_const_data (&address), error); 266 if (result == NULL) 267 _DBUS_ASSERT_ERROR_IS_SET (error); 268 else 269 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 270 271 out: 272 _dbus_string_free (&address); 273 return result; 274 } 275 276 static DBusTransportOpenResult 277 _dbus_transport_open_autolaunch (DBusAddressEntry *entry, 278 DBusTransport **transport_p, 279 DBusError *error) 280 { 281 const char *method; 282 283 method = dbus_address_entry_get_method (entry); 284 _dbus_assert (method != NULL); 285 286 if (strcmp (method, "autolaunch") == 0) 287 { 288 *transport_p = _dbus_transport_new_for_autolaunch (error); 289 290 if (*transport_p == NULL) 291 { 292 _DBUS_ASSERT_ERROR_IS_SET (error); 293 return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT; 294 } 295 else 296 { 297 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 298 return DBUS_TRANSPORT_OPEN_OK; 299 } 300 } 301 else 302 { 303 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 304 return DBUS_TRANSPORT_OPEN_NOT_HANDLED; 305 } 306 } 307 308 static const struct { 309 DBusTransportOpenResult (* func) (DBusAddressEntry *entry, 310 DBusTransport **transport_p, 311 DBusError *error); 312 } open_funcs[] = { 313 { _dbus_transport_open_socket }, 314 { _dbus_transport_open_platform_specific }, 315 { _dbus_transport_open_autolaunch } 316 #ifdef DBUS_BUILD_TESTS 317 , { _dbus_transport_open_debug_pipe } 318 #endif 319 }; 320 321 /** 322 * Try to open a new transport for the given address entry. (This 323 * opens a client-side-of-the-connection transport.) 324 * 325 * @param entry the address entry 326 * @param error location to store reason for failure. 327 * @returns new transport of #NULL on failure. 328 */ 329 DBusTransport* 330 _dbus_transport_open (DBusAddressEntry *entry, 331 DBusError *error) 332 { 333 DBusTransport *transport; 334 const char *expected_guid_orig; 335 char *expected_guid; 336 int i; 337 DBusError tmp_error; 338 339 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 340 341 transport = NULL; 342 expected_guid_orig = dbus_address_entry_get_value (entry, "guid"); 343 expected_guid = _dbus_strdup (expected_guid_orig); 344 345 if (expected_guid_orig != NULL && expected_guid == NULL) 346 { 347 _DBUS_SET_OOM (error); 348 return NULL; 349 } 350 351 dbus_error_init (&tmp_error); 352 for (i = 0; i < (int) _DBUS_N_ELEMENTS (open_funcs); ++i) 353 { 354 DBusTransportOpenResult result; 355 356 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 357 result = (* open_funcs[i].func) (entry, &transport, &tmp_error); 358 359 switch (result) 360 { 361 case DBUS_TRANSPORT_OPEN_OK: 362 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 363 goto out; 364 break; 365 case DBUS_TRANSPORT_OPEN_NOT_HANDLED: 366 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 367 /* keep going through the loop of open funcs */ 368 break; 369 case DBUS_TRANSPORT_OPEN_BAD_ADDRESS: 370 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); 371 goto out; 372 break; 373 case DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT: 374 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); 375 goto out; 376 break; 377 } 378 } 379 380 out: 381 382 if (transport == NULL) 383 { 384 if (!dbus_error_is_set (&tmp_error)) 385 _dbus_set_bad_address (&tmp_error, 386 NULL, NULL, 387 "Unknown address type (examples of valid types are \"tcp\" and on UNIX \"unix\")"); 388 389 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); 390 dbus_move_error(&tmp_error, error); 391 dbus_free (expected_guid); 392 } 393 else 394 { 395 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); 396 transport->expected_guid = expected_guid; 397 } 398 399 return transport; 400 } 401 402 /** 403 * Increments the reference count for the transport. 404 * 405 * @param transport the transport. 406 * @returns the transport. 407 */ 408 DBusTransport * 409 _dbus_transport_ref (DBusTransport *transport) 410 { 411 _dbus_assert (transport->refcount > 0); 412 413 transport->refcount += 1; 414 415 return transport; 416 } 417 418 /** 419 * Decrements the reference count for the transport. 420 * Disconnects and finalizes the transport if 421 * the reference count reaches zero. 422 * 423 * @param transport the transport. 424 */ 425 void 426 _dbus_transport_unref (DBusTransport *transport) 427 { 428 _dbus_assert (transport != NULL); 429 _dbus_assert (transport->refcount > 0); 430 431 transport->refcount -= 1; 432 if (transport->refcount == 0) 433 { 434 _dbus_verbose ("%s: finalizing\n", _DBUS_FUNCTION_NAME); 435 436 _dbus_assert (transport->vtable->finalize != NULL); 437 438 (* transport->vtable->finalize) (transport); 439 } 440 } 441 442 /** 443 * Closes our end of the connection to a remote application. Further 444 * attempts to use this transport will fail. Only the first call to 445 * _dbus_transport_disconnect() will have an effect. 446 * 447 * @param transport the transport. 448 * 449 */ 450 void 451 _dbus_transport_disconnect (DBusTransport *transport) 452 { 453 _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME); 454 455 _dbus_assert (transport->vtable->disconnect != NULL); 456 457 if (transport->disconnected) 458 return; 459 460 (* transport->vtable->disconnect) (transport); 461 462 transport->disconnected = TRUE; 463 464 _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME); 465 } 466 467 /** 468 * Returns #TRUE if the transport has not been disconnected. 469 * Disconnection can result from _dbus_transport_disconnect() 470 * or because the server drops its end of the connection. 471 * 472 * @param transport the transport. 473 * @returns whether we're connected 474 */ 475 dbus_bool_t 476 _dbus_transport_get_is_connected (DBusTransport *transport) 477 { 478 return !transport->disconnected; 479 } 480 481 /** 482 * Returns #TRUE if we have been authenticated. Will return #TRUE 483 * even if the transport is disconnected. 484 * 485 * @todo we drop connection->mutex when calling the unix_user_function, 486 * which may not be safe really. 487 * 488 * @param transport the transport 489 * @returns whether we're authenticated 490 */ 491 dbus_bool_t 492 _dbus_transport_get_is_authenticated (DBusTransport *transport) 493 { 494 /* We don't want to run unix_user_function on Windows, but it 495 * can exist, which allows application code to just unconditionally 496 * set it and have it only be invoked when appropriate. 497 */ 498 dbus_bool_t on_windows = FALSE; 499 #ifdef DBUS_WIN 500 on_windows = TRUE; 501 #endif 502 503 if (transport->authenticated) 504 return TRUE; 505 else 506 { 507 dbus_bool_t maybe_authenticated; 508 509 if (transport->disconnected) 510 return FALSE; 511 512 /* paranoia ref since we call user callbacks sometimes */ 513 _dbus_connection_ref_unlocked (transport->connection); 514 515 maybe_authenticated = 516 (!(transport->send_credentials_pending || 517 transport->receive_credentials_pending)); 518 519 if (maybe_authenticated) 520 { 521 switch (_dbus_auth_do_work (transport->auth)) 522 { 523 case DBUS_AUTH_STATE_AUTHENTICATED: 524 /* leave as maybe_authenticated */ 525 break; 526 default: 527 maybe_authenticated = FALSE; 528 } 529 } 530 531 if (maybe_authenticated && !transport->is_server) 532 { 533 const char *server_guid; 534 535 server_guid = _dbus_auth_get_guid_from_server (transport->auth); 536 _dbus_assert (server_guid != NULL); 537 538 if (transport->expected_guid && 539 strcmp (transport->expected_guid, server_guid) != 0) 540 { 541 _dbus_verbose ("Client expected GUID '%s' and we got '%s' from the server\n", 542 transport->expected_guid, server_guid); 543 _dbus_transport_disconnect (transport); 544 _dbus_connection_unref_unlocked (transport->connection); 545 return FALSE; 546 } 547 548 if (transport->expected_guid == NULL) 549 { 550 transport->expected_guid = _dbus_strdup (server_guid); 551 552 if (transport->expected_guid == NULL) 553 { 554 _dbus_verbose ("No memory to complete auth in %s\n", _DBUS_FUNCTION_NAME); 555 return FALSE; 556 } 557 } 558 } 559 560 /* If we've authenticated as some identity, check that the auth 561 * identity is the same as our own identity. In the future, we 562 * may have API allowing applications to specify how this is 563 * done, for example they may allow connection as any identity, 564 * but then impose restrictions on certain identities. 565 * Or they may give certain identities extra privileges. 566 */ 567 568 if (maybe_authenticated && transport->is_server) 569 { 570 DBusCredentials auth_identity; 571 572 _dbus_auth_get_identity (transport->auth, &auth_identity); 573 574 if (transport->unix_user_function != NULL && !on_windows) 575 { 576 dbus_bool_t allow; 577 DBusConnection *connection; 578 DBusAllowUnixUserFunction unix_user_function; 579 void *unix_user_data; 580 581 /* Dropping the lock here probably isn't that safe. */ 582 583 connection = transport->connection; 584 unix_user_function = transport->unix_user_function; 585 unix_user_data = transport->unix_user_data; 586 587 _dbus_verbose ("unlock %s\n", _DBUS_FUNCTION_NAME); 588 _dbus_connection_unlock (connection); 589 590 allow = (* unix_user_function) (connection, 591 auth_identity.uid, 592 unix_user_data); 593 594 _dbus_verbose ("lock %s post unix user function\n", _DBUS_FUNCTION_NAME); 595 _dbus_connection_lock (connection); 596 597 if (allow) 598 { 599 _dbus_verbose ("Client UID "DBUS_UID_FORMAT" authorized\n", auth_identity.uid); 600 } 601 else 602 { 603 _dbus_verbose ("Client UID "DBUS_UID_FORMAT 604 " was rejected, disconnecting\n", 605 auth_identity.uid); 606 _dbus_transport_disconnect (transport); 607 _dbus_connection_unref_unlocked (connection); 608 return FALSE; 609 } 610 } 611 else 612 { 613 DBusCredentials our_identity; 614 615 _dbus_credentials_from_current_process (&our_identity); 616 617 if (!_dbus_credentials_match (&our_identity, 618 &auth_identity)) 619 { 620 _dbus_verbose ("Client authorized as UID "DBUS_UID_FORMAT 621 " but our UID is "DBUS_UID_FORMAT", disconnecting\n", 622 auth_identity.uid, our_identity.uid); 623 _dbus_transport_disconnect (transport); 624 _dbus_connection_unref_unlocked (transport->connection); 625 return FALSE; 626 } 627 else 628 { 629 _dbus_verbose ("Client authorized as UID "DBUS_UID_FORMAT 630 " matching our UID "DBUS_UID_FORMAT"\n", 631 auth_identity.uid, our_identity.uid); 632 } 633 } 634 } 635 636 transport->authenticated = maybe_authenticated; 637 638 _dbus_connection_unref_unlocked (transport->connection); 639 return maybe_authenticated; 640 } 641 } 642 643 /** 644 * Gets the address of a transport. It will be 645 * #NULL for a server-side transport. 646 * 647 * @param transport the transport 648 * @returns transport's address 649 */ 650 const char* 651 _dbus_transport_get_address (DBusTransport *transport) 652 { 653 return transport->address; 654 } 655 656 /** 657 * Handles a watch by reading data, writing data, or disconnecting 658 * the transport, as appropriate for the given condition. 659 * 660 * @param transport the transport. 661 * @param watch the watch. 662 * @param condition the current state of the watched file descriptor. 663 * @returns #FALSE if not enough memory to fully handle the watch 664 */ 665 dbus_bool_t 666 _dbus_transport_handle_watch (DBusTransport *transport, 667 DBusWatch *watch, 668 unsigned int condition) 669 { 670 dbus_bool_t retval; 671 672 _dbus_assert (transport->vtable->handle_watch != NULL); 673 674 if (transport->disconnected) 675 return TRUE; 676 677 if (dbus_watch_get_fd (watch) < 0) 678 { 679 _dbus_warn_check_failed ("Tried to handle an invalidated watch; this watch should have been removed\n"); 680 return TRUE; 681 } 682 683 _dbus_watch_sanitize_condition (watch, &condition); 684 685 _dbus_transport_ref (transport); 686 _dbus_watch_ref (watch); 687 retval = (* transport->vtable->handle_watch) (transport, watch, condition); 688 _dbus_watch_unref (watch); 689 _dbus_transport_unref (transport); 690 691 return retval; 692 } 693 694 /** 695 * Sets the connection using this transport. Allows the transport 696 * to add watches to the connection, queue incoming messages, 697 * and pull outgoing messages. 698 * 699 * @param transport the transport. 700 * @param connection the connection. 701 * @returns #FALSE if not enough memory 702 */ 703 dbus_bool_t 704 _dbus_transport_set_connection (DBusTransport *transport, 705 DBusConnection *connection) 706 { 707 _dbus_assert (transport->vtable->connection_set != NULL); 708 _dbus_assert (transport->connection == NULL); 709 710 transport->connection = connection; 711 712 _dbus_transport_ref (transport); 713 if (!(* transport->vtable->connection_set) (transport)) 714 transport->connection = NULL; 715 _dbus_transport_unref (transport); 716 717 return transport->connection != NULL; 718 } 719 720 /** 721 * Get the socket file descriptor, if any. 722 * 723 * @param transport the transport 724 * @param fd_p pointer to fill in with the descriptor 725 * @returns #TRUE if a descriptor was available 726 */ 727 dbus_bool_t 728 _dbus_transport_get_socket_fd (DBusTransport *transport, 729 int *fd_p) 730 { 731 dbus_bool_t retval; 732 733 if (transport->vtable->get_socket_fd == NULL) 734 return FALSE; 735 736 if (transport->disconnected) 737 return FALSE; 738 739 _dbus_transport_ref (transport); 740 741 retval = (* transport->vtable->get_socket_fd) (transport, 742 fd_p); 743 744 _dbus_transport_unref (transport); 745 746 return retval; 747 } 748 749 /** 750 * Performs a single poll()/select() on the transport's file 751 * descriptors and then reads/writes data as appropriate, 752 * queueing incoming messages and sending outgoing messages. 753 * This is the backend for _dbus_connection_do_iteration(). 754 * See _dbus_connection_do_iteration() for full details. 755 * 756 * @param transport the transport. 757 * @param flags indicates whether to read or write, and whether to block. 758 * @param timeout_milliseconds if blocking, timeout or -1 for no timeout. 759 */ 760 void 761 _dbus_transport_do_iteration (DBusTransport *transport, 762 unsigned int flags, 763 int timeout_milliseconds) 764 { 765 _dbus_assert (transport->vtable->do_iteration != NULL); 766 767 _dbus_verbose ("Transport iteration flags 0x%x timeout %d connected = %d\n", 768 flags, timeout_milliseconds, !transport->disconnected); 769 770 if ((flags & (DBUS_ITERATION_DO_WRITING | 771 DBUS_ITERATION_DO_READING)) == 0) 772 return; /* Nothing to do */ 773 774 if (transport->disconnected) 775 return; 776 777 _dbus_transport_ref (transport); 778 (* transport->vtable->do_iteration) (transport, flags, 779 timeout_milliseconds); 780 _dbus_transport_unref (transport); 781 782 _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME); 783 } 784 785 static dbus_bool_t 786 recover_unused_bytes (DBusTransport *transport) 787 { 788 if (_dbus_auth_needs_decoding (transport->auth)) 789 { 790 DBusString plaintext; 791 const DBusString *encoded; 792 DBusString *buffer; 793 int orig_len; 794 795 if (!_dbus_string_init (&plaintext)) 796 goto nomem; 797 798 _dbus_auth_get_unused_bytes (transport->auth, 799 &encoded); 800 801 if (!_dbus_auth_decode_data (transport->auth, 802 encoded, &plaintext)) 803 { 804 _dbus_string_free (&plaintext); 805 goto nomem; 806 } 807 808 _dbus_message_loader_get_buffer (transport->loader, 809 &buffer); 810 811 orig_len = _dbus_string_get_length (buffer); 812 813 if (!_dbus_string_move (&plaintext, 0, buffer, 814 orig_len)) 815 { 816 _dbus_string_free (&plaintext); 817 goto nomem; 818 } 819 820 _dbus_verbose (" %d unused bytes sent to message loader\n", 821 _dbus_string_get_length (buffer) - 822 orig_len); 823 824 _dbus_message_loader_return_buffer (transport->loader, 825 buffer, 826 _dbus_string_get_length (buffer) - 827 orig_len); 828 829 _dbus_auth_delete_unused_bytes (transport->auth); 830 831 _dbus_string_free (&plaintext); 832 } 833 else 834 { 835 const DBusString *bytes; 836 DBusString *buffer; 837 int orig_len; 838 dbus_bool_t succeeded; 839 840 _dbus_message_loader_get_buffer (transport->loader, 841 &buffer); 842 843 orig_len = _dbus_string_get_length (buffer); 844 845 _dbus_auth_get_unused_bytes (transport->auth, 846 &bytes); 847 848 succeeded = TRUE; 849 if (!_dbus_string_copy (bytes, 0, buffer, _dbus_string_get_length (buffer))) 850 succeeded = FALSE; 851 852 _dbus_verbose (" %d unused bytes sent to message loader\n", 853 _dbus_string_get_length (buffer) - 854 orig_len); 855 856 _dbus_message_loader_return_buffer (transport->loader, 857 buffer, 858 _dbus_string_get_length (buffer) - 859 orig_len); 860 861 if (succeeded) 862 _dbus_auth_delete_unused_bytes (transport->auth); 863 else 864 goto nomem; 865 } 866 867 return TRUE; 868 869 nomem: 870 _dbus_verbose ("Not enough memory to transfer unused bytes from auth conversation\n"); 871 return FALSE; 872 } 873 874 /** 875 * Reports our current dispatch status (whether there's buffered 876 * data to be queued as messages, or not, or we need memory). 877 * 878 * @param transport the transport 879 * @returns current status 880 */ 881 DBusDispatchStatus 882 _dbus_transport_get_dispatch_status (DBusTransport *transport) 883 { 884 if (_dbus_counter_get_value (transport->live_messages_size) >= transport->max_live_messages_size) 885 return DBUS_DISPATCH_COMPLETE; /* complete for now */ 886 887 if (!_dbus_transport_get_is_authenticated (transport)) 888 { 889 if (_dbus_auth_do_work (transport->auth) == 890 DBUS_AUTH_STATE_WAITING_FOR_MEMORY) 891 return DBUS_DISPATCH_NEED_MEMORY; 892 else if (!_dbus_transport_get_is_authenticated (transport)) 893 return DBUS_DISPATCH_COMPLETE; 894 } 895 896 if (!transport->unused_bytes_recovered && 897 !recover_unused_bytes (transport)) 898 return DBUS_DISPATCH_NEED_MEMORY; 899 900 transport->unused_bytes_recovered = TRUE; 901 902 if (!_dbus_message_loader_queue_messages (transport->loader)) 903 return DBUS_DISPATCH_NEED_MEMORY; 904 905 if (_dbus_message_loader_peek_message (transport->loader) != NULL) 906 return DBUS_DISPATCH_DATA_REMAINS; 907 else 908 return DBUS_DISPATCH_COMPLETE; 909 } 910 911 /** 912 * Processes data we've read while handling a watch, potentially 913 * converting some of it to messages and queueing those messages on 914 * the connection. 915 * 916 * @param transport the transport 917 * @returns #TRUE if we had enough memory to queue all messages 918 */ 919 dbus_bool_t 920 _dbus_transport_queue_messages (DBusTransport *transport) 921 { 922 DBusDispatchStatus status; 923 924 #if 0 925 _dbus_verbose ("_dbus_transport_queue_messages()\n"); 926 #endif 927 928 /* Queue any messages */ 929 while ((status = _dbus_transport_get_dispatch_status (transport)) == DBUS_DISPATCH_DATA_REMAINS) 930 { 931 DBusMessage *message; 932 DBusList *link; 933 934 link = _dbus_message_loader_pop_message_link (transport->loader); 935 _dbus_assert (link != NULL); 936 937 message = link->data; 938 939 _dbus_verbose ("queueing received message %p\n", message); 940 941 if (!_dbus_message_add_size_counter (message, transport->live_messages_size)) 942 { 943 _dbus_message_loader_putback_message_link (transport->loader, 944 link); 945 status = DBUS_DISPATCH_NEED_MEMORY; 946 break; 947 } 948 else 949 { 950 /* pass ownership of link and message ref to connection */ 951 _dbus_connection_queue_received_message_link (transport->connection, 952 link); 953 } 954 } 955 956 if (_dbus_message_loader_get_is_corrupted (transport->loader)) 957 { 958 _dbus_verbose ("Corrupted message stream, disconnecting\n"); 959 _dbus_transport_disconnect (transport); 960 } 961 962 return status != DBUS_DISPATCH_NEED_MEMORY; 963 } 964 965 /** 966 * See dbus_connection_set_max_message_size(). 967 * 968 * @param transport the transport 969 * @param size the max size of a single message 970 */ 971 void 972 _dbus_transport_set_max_message_size (DBusTransport *transport, 973 long size) 974 { 975 _dbus_message_loader_set_max_message_size (transport->loader, size); 976 } 977 978 /** 979 * See dbus_connection_get_max_message_size(). 980 * 981 * @param transport the transport 982 * @returns max message size 983 */ 984 long 985 _dbus_transport_get_max_message_size (DBusTransport *transport) 986 { 987 return _dbus_message_loader_get_max_message_size (transport->loader); 988 } 989 990 /** 991 * See dbus_connection_set_max_received_size(). 992 * 993 * @param transport the transport 994 * @param size the max size of all incoming messages 995 */ 996 void 997 _dbus_transport_set_max_received_size (DBusTransport *transport, 998 long size) 999 { 1000 transport->max_live_messages_size = size; 1001 _dbus_counter_set_notify (transport->live_messages_size, 1002 transport->max_live_messages_size, 1003 live_messages_size_notify, 1004 transport); 1005 } 1006 1007 1008 /** 1009 * See dbus_connection_get_max_received_size(). 1010 * 1011 * @param transport the transport 1012 * @returns max bytes for all live messages 1013 */ 1014 long 1015 _dbus_transport_get_max_received_size (DBusTransport *transport) 1016 { 1017 return transport->max_live_messages_size; 1018 } 1019 1020 /** 1021 * See dbus_connection_get_unix_user(). 1022 * 1023 * @param transport the transport 1024 * @param uid return location for the user ID 1025 * @returns #TRUE if uid is filled in with a valid user ID 1026 */ 1027 dbus_bool_t 1028 _dbus_transport_get_unix_user (DBusTransport *transport, 1029 unsigned long *uid) 1030 { 1031 DBusCredentials auth_identity; 1032 1033 *uid = _DBUS_INT32_MAX; /* better than some root or system user in 1034 * case of bugs in the caller. Caller should 1035 * never use this value on purpose, however. 1036 */ 1037 1038 if (!transport->authenticated) 1039 return FALSE; 1040 1041 _dbus_auth_get_identity (transport->auth, &auth_identity); 1042 1043 if (auth_identity.uid != DBUS_UID_UNSET) 1044 { 1045 *uid = auth_identity.uid; 1046 return TRUE; 1047 } 1048 else 1049 return FALSE; 1050 } 1051 1052 /** 1053 * See dbus_connection_get_unix_process_id(). 1054 * 1055 * @param transport the transport 1056 * @param pid return location for the process ID 1057 * @returns #TRUE if uid is filled in with a valid process ID 1058 */ 1059 dbus_bool_t 1060 _dbus_transport_get_unix_process_id (DBusTransport *transport, 1061 unsigned long *pid) 1062 { 1063 DBusCredentials auth_identity; 1064 1065 *pid = DBUS_PID_UNSET; /* Caller should never use this value on purpose, 1066 * but we set it to a safe number, INT_MAX, 1067 * just to root out possible bugs in bad callers. 1068 */ 1069 1070 if (!transport->authenticated) 1071 return FALSE; 1072 1073 _dbus_auth_get_identity (transport->auth, &auth_identity); 1074 1075 if (auth_identity.pid != DBUS_PID_UNSET) 1076 { 1077 *pid = auth_identity.pid; 1078 return TRUE; 1079 } 1080 else 1081 return FALSE; 1082 } 1083 1084 /** 1085 * See dbus_connection_set_unix_user_function(). 1086 * 1087 * @param transport the transport 1088 * @param function the predicate 1089 * @param data data to pass to the predicate 1090 * @param free_data_function function to free the data 1091 * @param old_data the old user data to be freed 1092 * @param old_free_data_function old free data function to free it with 1093 */ 1094 void 1095 _dbus_transport_set_unix_user_function (DBusTransport *transport, 1096 DBusAllowUnixUserFunction function, 1097 void *data, 1098 DBusFreeFunction free_data_function, 1099 void **old_data, 1100 DBusFreeFunction *old_free_data_function) 1101 { 1102 *old_data = transport->unix_user_data; 1103 *old_free_data_function = transport->free_unix_user_data; 1104 1105 transport->unix_user_function = function; 1106 transport->unix_user_data = data; 1107 transport->free_unix_user_data = free_data_function; 1108 } 1109 1110 /** 1111 * Sets the SASL authentication mechanisms supported by this transport. 1112 * 1113 * @param transport the transport 1114 * @param mechanisms the #NULL-terminated array of mechanisms 1115 * 1116 * @returns #FALSE if no memory 1117 */ 1118 dbus_bool_t 1119 _dbus_transport_set_auth_mechanisms (DBusTransport *transport, 1120 const char **mechanisms) 1121 { 1122 return _dbus_auth_set_mechanisms (transport->auth, mechanisms); 1123 } 1124 1125 1126 /** @} */ 1127
