1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2 /* dbus-connection.c DBusConnection object 3 * 4 * Copyright (C) 2002-2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 * 22 */ 23 24 #include <config.h> 25 #include "dbus-shared.h" 26 #include "dbus-connection.h" 27 #include "dbus-list.h" 28 #include "dbus-timeout.h" 29 #include "dbus-transport.h" 30 #include "dbus-watch.h" 31 #include "dbus-connection-internal.h" 32 #include "dbus-pending-call-internal.h" 33 #include "dbus-list.h" 34 #include "dbus-hash.h" 35 #include "dbus-message-internal.h" 36 #include "dbus-message-private.h" 37 #include "dbus-threads.h" 38 #include "dbus-protocol.h" 39 #include "dbus-dataslot.h" 40 #include "dbus-string.h" 41 #include "dbus-pending-call.h" 42 #include "dbus-object-tree.h" 43 #include "dbus-threads-internal.h" 44 #include "dbus-bus.h" 45 #include "dbus-marshal-basic.h" 46 47 #ifdef DBUS_DISABLE_CHECKS 48 #define TOOK_LOCK_CHECK(connection) 49 #define RELEASING_LOCK_CHECK(connection) 50 #define HAVE_LOCK_CHECK(connection) 51 #else 52 #define TOOK_LOCK_CHECK(connection) do { \ 53 _dbus_assert (!(connection)->have_connection_lock); \ 54 (connection)->have_connection_lock = TRUE; \ 55 } while (0) 56 #define RELEASING_LOCK_CHECK(connection) do { \ 57 _dbus_assert ((connection)->have_connection_lock); \ 58 (connection)->have_connection_lock = FALSE; \ 59 } while (0) 60 #define HAVE_LOCK_CHECK(connection) _dbus_assert ((connection)->have_connection_lock) 61 /* A "DO_NOT_HAVE_LOCK_CHECK" is impossible since we need the lock to check the flag */ 62 #endif 63 64 #define TRACE_LOCKS 0 65 66 #define CONNECTION_LOCK(connection) do { \ 67 if (TRACE_LOCKS) { _dbus_verbose ("LOCK\n"); } \ 68 _dbus_mutex_lock ((connection)->mutex); \ 69 TOOK_LOCK_CHECK (connection); \ 70 } while (0) 71 72 #define CONNECTION_UNLOCK(connection) do { \ 73 if (TRACE_LOCKS) { _dbus_verbose ("UNLOCK\n"); } \ 74 RELEASING_LOCK_CHECK (connection); \ 75 _dbus_mutex_unlock ((connection)->mutex); \ 76 } while (0) 77 78 #define SLOTS_LOCK(connection) do { \ 79 _dbus_mutex_lock ((connection)->slot_mutex); \ 80 } while (0) 81 82 #define SLOTS_UNLOCK(connection) do { \ 83 _dbus_mutex_unlock ((connection)->slot_mutex); \ 84 } while (0) 85 86 #define DISPATCH_STATUS_NAME(s) \ 87 ((s) == DBUS_DISPATCH_COMPLETE ? "complete" : \ 88 (s) == DBUS_DISPATCH_DATA_REMAINS ? "data remains" : \ 89 (s) == DBUS_DISPATCH_NEED_MEMORY ? "need memory" : \ 90 "???") 91 92 /** 93 * @defgroup DBusConnection DBusConnection 94 * @ingroup DBus 95 * @brief Connection to another application 96 * 97 * A DBusConnection represents a connection to another 98 * application. Messages can be sent and received via this connection. 99 * The other application may be a message bus; for convenience, the 100 * function dbus_bus_get() is provided to automatically open a 101 * connection to the well-known message buses. 102 * 103 * In brief a DBusConnection is a message queue associated with some 104 * message transport mechanism such as a socket. The connection 105 * maintains a queue of incoming messages and a queue of outgoing 106 * messages. 107 * 108 * Several functions use the following terms: 109 * <ul> 110 * <li><b>read</b> means to fill the incoming message queue by reading from the socket</li> 111 * <li><b>write</b> means to drain the outgoing queue by writing to the socket</li> 112 * <li><b>dispatch</b> means to drain the incoming queue by invoking application-provided message handlers</li> 113 * </ul> 114 * 115 * The function dbus_connection_read_write_dispatch() for example does all 116 * three of these things, offering a simple alternative to a main loop. 117 * 118 * In an application with a main loop, the read/write/dispatch 119 * operations are usually separate. 120 * 121 * The connection provides #DBusWatch and #DBusTimeout objects to 122 * the main loop. These are used to know when reading, writing, or 123 * dispatching should be performed. 124 * 125 * Incoming messages are processed 126 * by calling dbus_connection_dispatch(). dbus_connection_dispatch() 127 * runs any handlers registered for the topmost message in the message 128 * queue, then discards the message, then returns. 129 * 130 * dbus_connection_get_dispatch_status() indicates whether 131 * messages are currently in the queue that need dispatching. 132 * dbus_connection_set_dispatch_status_function() allows 133 * you to set a function to be used to monitor the dispatch status. 134 * 135 * If you're using GLib or Qt add-on libraries for D-Bus, there are 136 * special convenience APIs in those libraries that hide 137 * all the details of dispatch and watch/timeout monitoring. 138 * For example, dbus_connection_setup_with_g_main(). 139 * 140 * If you aren't using these add-on libraries, but want to process 141 * messages asynchronously, you must manually call 142 * dbus_connection_set_dispatch_status_function(), 143 * dbus_connection_set_watch_functions(), 144 * dbus_connection_set_timeout_functions() providing appropriate 145 * functions to integrate the connection with your application's main 146 * loop. This can be tricky to get right; main loops are not simple. 147 * 148 * If you don't need to be asynchronous, you can ignore #DBusWatch, 149 * #DBusTimeout, and dbus_connection_dispatch(). Instead, 150 * dbus_connection_read_write_dispatch() can be used. 151 * 152 * Or, in <em>very</em> simple applications, 153 * dbus_connection_pop_message() may be all you need, allowing you to 154 * avoid setting up any handler functions (see 155 * dbus_connection_add_filter(), 156 * dbus_connection_register_object_path() for more on handlers). 157 * 158 * When you use dbus_connection_send() or one of its variants to send 159 * a message, the message is added to the outgoing queue. It's 160 * actually written to the network later; either in 161 * dbus_watch_handle() invoked by your main loop, or in 162 * dbus_connection_flush() which blocks until it can write out the 163 * entire outgoing queue. The GLib/Qt add-on libraries again 164 * handle the details here for you by setting up watch functions. 165 * 166 * When a connection is disconnected, you are guaranteed to get a 167 * signal "Disconnected" from the interface 168 * #DBUS_INTERFACE_LOCAL, path 169 * #DBUS_PATH_LOCAL. 170 * 171 * You may not drop the last reference to a #DBusConnection 172 * until that connection has been disconnected. 173 * 174 * You may dispatch the unprocessed incoming message queue even if the 175 * connection is disconnected. However, "Disconnected" will always be 176 * the last message in the queue (obviously no messages are received 177 * after disconnection). 178 * 179 * After calling dbus_threads_init(), #DBusConnection has thread 180 * locks and drops them when invoking user callbacks, so in general is 181 * transparently threadsafe. However, #DBusMessage does NOT have 182 * thread locks; you must not send the same message to multiple 183 * #DBusConnection if those connections will be used from different threads, 184 * for example. 185 * 186 * Also, if you dispatch or pop messages from multiple threads, it 187 * may work in the sense that it won't crash, but it's tough to imagine 188 * sane results; it will be completely unpredictable which messages 189 * go to which threads. 190 * 191 * It's recommended to dispatch from a single thread. 192 * 193 * The most useful function to call from multiple threads at once 194 * is dbus_connection_send_with_reply_and_block(). That is, 195 * multiple threads can make method calls at the same time. 196 * 197 * If you aren't using threads, you can use a main loop and 198 * dbus_pending_call_set_notify() to achieve a similar result. 199 */ 200 201 /** 202 * @defgroup DBusConnectionInternals DBusConnection implementation details 203 * @ingroup DBusInternals 204 * @brief Implementation details of DBusConnection 205 * 206 * @{ 207 */ 208 209 /** 210 * Internal struct representing a message filter function 211 */ 212 typedef struct DBusMessageFilter DBusMessageFilter; 213 214 /** 215 * Internal struct representing a message filter function 216 */ 217 struct DBusMessageFilter 218 { 219 DBusAtomic refcount; /**< Reference count */ 220 DBusHandleMessageFunction function; /**< Function to call to filter */ 221 void *user_data; /**< User data for the function */ 222 DBusFreeFunction free_user_data_function; /**< Function to free the user data */ 223 }; 224 225 226 /** 227 * Internals of DBusPreallocatedSend 228 */ 229 struct DBusPreallocatedSend 230 { 231 DBusConnection *connection; /**< Connection we'd send the message to */ 232 DBusList *queue_link; /**< Preallocated link in the queue */ 233 DBusList *counter_link; /**< Preallocated link in the resource counter */ 234 }; 235 236 #ifdef HAVE_DECL_MSG_NOSIGNAL 237 static dbus_bool_t _dbus_modify_sigpipe = FALSE; 238 #else 239 static dbus_bool_t _dbus_modify_sigpipe = TRUE; 240 #endif 241 242 /** 243 * Implementation details of DBusConnection. All fields are private. 244 */ 245 struct DBusConnection 246 { 247 DBusAtomic refcount; /**< Reference count. */ 248 249 DBusMutex *mutex; /**< Lock on the entire DBusConnection */ 250 251 DBusMutex *dispatch_mutex; /**< Protects dispatch_acquired */ 252 DBusCondVar *dispatch_cond; /**< Notify when dispatch_acquired is available */ 253 DBusMutex *io_path_mutex; /**< Protects io_path_acquired */ 254 DBusCondVar *io_path_cond; /**< Notify when io_path_acquired is available */ 255 256 DBusList *outgoing_messages; /**< Queue of messages we need to send, send the end of the list first. */ 257 DBusList *incoming_messages; /**< Queue of messages we have received, end of the list received most recently. */ 258 259 DBusMessage *message_borrowed; /**< Filled in if the first incoming message has been borrowed; 260 * dispatch_acquired will be set by the borrower 261 */ 262 263 int n_outgoing; /**< Length of outgoing queue. */ 264 int n_incoming; /**< Length of incoming queue. */ 265 266 DBusCounter *outgoing_counter; /**< Counts size of outgoing messages. */ 267 268 DBusTransport *transport; /**< Object that sends/receives messages over network. */ 269 DBusWatchList *watches; /**< Stores active watches. */ 270 DBusTimeoutList *timeouts; /**< Stores active timeouts. */ 271 272 DBusList *filter_list; /**< List of filters. */ 273 274 DBusMutex *slot_mutex; /**< Lock on slot_list so overall connection lock need not be taken */ 275 DBusDataSlotList slot_list; /**< Data stored by allocated integer ID */ 276 277 DBusHashTable *pending_replies; /**< Hash of message serials to #DBusPendingCall. */ 278 279 dbus_uint32_t client_serial; /**< Client serial. Increments each time a message is sent */ 280 DBusList *disconnect_message_link; /**< Preallocated list node for queueing the disconnection message */ 281 282 DBusWakeupMainFunction wakeup_main_function; /**< Function to wake up the mainloop */ 283 void *wakeup_main_data; /**< Application data for wakeup_main_function */ 284 DBusFreeFunction free_wakeup_main_data; /**< free wakeup_main_data */ 285 286 DBusDispatchStatusFunction dispatch_status_function; /**< Function on dispatch status changes */ 287 void *dispatch_status_data; /**< Application data for dispatch_status_function */ 288 DBusFreeFunction free_dispatch_status_data; /**< free dispatch_status_data */ 289 290 DBusDispatchStatus last_dispatch_status; /**< The last dispatch status we reported to the application. */ 291 292 DBusList *link_cache; /**< A cache of linked list links to prevent contention 293 * for the global linked list mempool lock 294 */ 295 DBusObjectTree *objects; /**< Object path handlers registered with this connection */ 296 297 char *server_guid; /**< GUID of server if we are in shared_connections, #NULL if server GUID is unknown or connection is private */ 298 299 /* These two MUST be bools and not bitfields, because they are protected by a separate lock 300 * from connection->mutex and all bitfields in a word have to be read/written together. 301 * So you can't have a different lock for different bitfields in the same word. 302 */ 303 dbus_bool_t dispatch_acquired; /**< Someone has dispatch path (can drain incoming queue) */ 304 dbus_bool_t io_path_acquired; /**< Someone has transport io path (can use the transport to read/write messages) */ 305 306 unsigned int shareable : 1; /**< #TRUE if libdbus owns a reference to the connection and can return it from dbus_connection_open() more than once */ 307 308 unsigned int exit_on_disconnect : 1; /**< If #TRUE, exit after handling disconnect signal */ 309 310 unsigned int route_peer_messages : 1; /**< If #TRUE, if org.freedesktop.DBus.Peer messages have a bus name, don't handle them automatically */ 311 312 unsigned int disconnected_message_arrived : 1; /**< We popped or are dispatching the disconnected message. 313 * if the disconnect_message_link is NULL then we queued it, but 314 * this flag is whether it got to the head of the queue. 315 */ 316 unsigned int disconnected_message_processed : 1; /**< We did our default handling of the disconnected message, 317 * such as closing the connection. 318 */ 319 320 #ifndef DBUS_DISABLE_CHECKS 321 unsigned int have_connection_lock : 1; /**< Used to check locking */ 322 #endif 323 324 #ifndef DBUS_DISABLE_CHECKS 325 int generation; /**< _dbus_current_generation that should correspond to this connection */ 326 #endif 327 }; 328 329 static DBusDispatchStatus _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection); 330 static void _dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection, 331 DBusDispatchStatus new_status); 332 static void _dbus_connection_last_unref (DBusConnection *connection); 333 static void _dbus_connection_acquire_dispatch (DBusConnection *connection); 334 static void _dbus_connection_release_dispatch (DBusConnection *connection); 335 static DBusDispatchStatus _dbus_connection_flush_unlocked (DBusConnection *connection); 336 static void _dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection); 337 static dbus_bool_t _dbus_connection_get_is_connected_unlocked (DBusConnection *connection); 338 static dbus_bool_t _dbus_connection_peek_for_reply_unlocked (DBusConnection *connection, 339 dbus_uint32_t client_serial); 340 341 static DBusMessageFilter * 342 _dbus_message_filter_ref (DBusMessageFilter *filter) 343 { 344 _dbus_assert (filter->refcount.value > 0); 345 _dbus_atomic_inc (&filter->refcount); 346 347 return filter; 348 } 349 350 static void 351 _dbus_message_filter_unref (DBusMessageFilter *filter) 352 { 353 _dbus_assert (filter->refcount.value > 0); 354 355 if (_dbus_atomic_dec (&filter->refcount) == 1) 356 { 357 if (filter->free_user_data_function) 358 (* filter->free_user_data_function) (filter->user_data); 359 360 dbus_free (filter); 361 } 362 } 363 364 /** 365 * Acquires the connection lock. 366 * 367 * @param connection the connection. 368 */ 369 void 370 _dbus_connection_lock (DBusConnection *connection) 371 { 372 CONNECTION_LOCK (connection); 373 } 374 375 /** 376 * Releases the connection lock. 377 * 378 * @param connection the connection. 379 */ 380 void 381 _dbus_connection_unlock (DBusConnection *connection) 382 { 383 CONNECTION_UNLOCK (connection); 384 } 385 386 /** 387 * Wakes up the main loop if it is sleeping 388 * Needed if we're e.g. queueing outgoing messages 389 * on a thread while the mainloop sleeps. 390 * 391 * @param connection the connection. 392 */ 393 static void 394 _dbus_connection_wakeup_mainloop (DBusConnection *connection) 395 { 396 if (connection->wakeup_main_function) 397 (*connection->wakeup_main_function) (connection->wakeup_main_data); 398 } 399 400 #ifdef DBUS_BUILD_TESTS 401 /* For now this function isn't used */ 402 /** 403 * Adds a message to the incoming message queue, returning #FALSE 404 * if there's insufficient memory to queue the message. 405 * Does not take over refcount of the message. 406 * 407 * @param connection the connection. 408 * @param message the message to queue. 409 * @returns #TRUE on success. 410 */ 411 dbus_bool_t 412 _dbus_connection_queue_received_message (DBusConnection *connection, 413 DBusMessage *message) 414 { 415 DBusList *link; 416 417 link = _dbus_list_alloc_link (message); 418 if (link == NULL) 419 return FALSE; 420 421 dbus_message_ref (message); 422 _dbus_connection_queue_received_message_link (connection, link); 423 424 return TRUE; 425 } 426 427 /** 428 * Gets the locks so we can examine them 429 * 430 * @param connection the connection. 431 * @param mutex_loc return for the location of the main mutex pointer 432 * @param dispatch_mutex_loc return location of the dispatch mutex pointer 433 * @param io_path_mutex_loc return location of the io_path mutex pointer 434 * @param dispatch_cond_loc return location of the dispatch conditional 435 * variable pointer 436 * @param io_path_cond_loc return location of the io_path conditional 437 * variable pointer 438 */ 439 void 440 _dbus_connection_test_get_locks (DBusConnection *connection, 441 DBusMutex **mutex_loc, 442 DBusMutex **dispatch_mutex_loc, 443 DBusMutex **io_path_mutex_loc, 444 DBusCondVar **dispatch_cond_loc, 445 DBusCondVar **io_path_cond_loc) 446 { 447 *mutex_loc = connection->mutex; 448 *dispatch_mutex_loc = connection->dispatch_mutex; 449 *io_path_mutex_loc = connection->io_path_mutex; 450 *dispatch_cond_loc = connection->dispatch_cond; 451 *io_path_cond_loc = connection->io_path_cond; 452 } 453 #endif 454 455 /** 456 * Adds a message-containing list link to the incoming message queue, 457 * taking ownership of the link and the message's current refcount. 458 * Cannot fail due to lack of memory. 459 * 460 * @param connection the connection. 461 * @param link the message link to queue. 462 */ 463 void 464 _dbus_connection_queue_received_message_link (DBusConnection *connection, 465 DBusList *link) 466 { 467 DBusPendingCall *pending; 468 dbus_uint32_t reply_serial; 469 DBusMessage *message; 470 471 _dbus_assert (_dbus_transport_get_is_authenticated (connection->transport)); 472 473 _dbus_list_append_link (&connection->incoming_messages, 474 link); 475 message = link->data; 476 477 /* If this is a reply we're waiting on, remove timeout for it */ 478 reply_serial = dbus_message_get_reply_serial (message); 479 if (reply_serial != 0) 480 { 481 pending = _dbus_hash_table_lookup_int (connection->pending_replies, 482 reply_serial); 483 if (pending != NULL) 484 { 485 if (_dbus_pending_call_is_timeout_added_unlocked (pending)) 486 _dbus_connection_remove_timeout_unlocked (connection, 487 _dbus_pending_call_get_timeout_unlocked (pending)); 488 489 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 490 } 491 } 492 493 494 495 connection->n_incoming += 1; 496 497 _dbus_connection_wakeup_mainloop (connection); 498 499 _dbus_verbose ("Message %p (%s %s %s %s '%s' reply to %u) added to incoming queue %p, %d incoming\n", 500 message, 501 dbus_message_type_to_string (dbus_message_get_type (message)), 502 dbus_message_get_path (message) ? 503 dbus_message_get_path (message) : 504 "no path", 505 dbus_message_get_interface (message) ? 506 dbus_message_get_interface (message) : 507 "no interface", 508 dbus_message_get_member (message) ? 509 dbus_message_get_member (message) : 510 "no member", 511 dbus_message_get_signature (message), 512 dbus_message_get_reply_serial (message), 513 connection, 514 connection->n_incoming);} 515 516 /** 517 * Adds a link + message to the incoming message queue. 518 * Can't fail. Takes ownership of both link and message. 519 * 520 * @param connection the connection. 521 * @param link the list node and message to queue. 522 * 523 */ 524 void 525 _dbus_connection_queue_synthesized_message_link (DBusConnection *connection, 526 DBusList *link) 527 { 528 HAVE_LOCK_CHECK (connection); 529 530 _dbus_list_append_link (&connection->incoming_messages, link); 531 532 connection->n_incoming += 1; 533 534 _dbus_connection_wakeup_mainloop (connection); 535 536 _dbus_verbose ("Synthesized message %p added to incoming queue %p, %d incoming\n", 537 link->data, connection, connection->n_incoming); 538 } 539 540 541 /** 542 * Checks whether there are messages in the outgoing message queue. 543 * Called with connection lock held. 544 * 545 * @param connection the connection. 546 * @returns #TRUE if the outgoing queue is non-empty. 547 */ 548 dbus_bool_t 549 _dbus_connection_has_messages_to_send_unlocked (DBusConnection *connection) 550 { 551 HAVE_LOCK_CHECK (connection); 552 return connection->outgoing_messages != NULL; 553 } 554 555 /** 556 * Checks whether there are messages in the outgoing message queue. 557 * Use dbus_connection_flush() to block until all outgoing 558 * messages have been written to the underlying transport 559 * (such as a socket). 560 * 561 * @param connection the connection. 562 * @returns #TRUE if the outgoing queue is non-empty. 563 */ 564 dbus_bool_t 565 dbus_connection_has_messages_to_send (DBusConnection *connection) 566 { 567 dbus_bool_t v; 568 569 _dbus_return_val_if_fail (connection != NULL, FALSE); 570 571 CONNECTION_LOCK (connection); 572 v = _dbus_connection_has_messages_to_send_unlocked (connection); 573 CONNECTION_UNLOCK (connection); 574 575 return v; 576 } 577 578 /** 579 * Gets the next outgoing message. The message remains in the 580 * queue, and the caller does not own a reference to it. 581 * 582 * @param connection the connection. 583 * @returns the message to be sent. 584 */ 585 DBusMessage* 586 _dbus_connection_get_message_to_send (DBusConnection *connection) 587 { 588 HAVE_LOCK_CHECK (connection); 589 590 return _dbus_list_get_last (&connection->outgoing_messages); 591 } 592 593 /** 594 * Notifies the connection that a message has been sent, so the 595 * message can be removed from the outgoing queue. 596 * Called with the connection lock held. 597 * 598 * @param connection the connection. 599 * @param message the message that was sent. 600 */ 601 void 602 _dbus_connection_message_sent (DBusConnection *connection, 603 DBusMessage *message) 604 { 605 DBusList *link; 606 607 HAVE_LOCK_CHECK (connection); 608 609 /* This can be called before we even complete authentication, since 610 * it's called on disconnect to clean up the outgoing queue. 611 * It's also called as we successfully send each message. 612 */ 613 614 link = _dbus_list_get_last_link (&connection->outgoing_messages); 615 _dbus_assert (link != NULL); 616 _dbus_assert (link->data == message); 617 618 /* Save this link in the link cache */ 619 _dbus_list_unlink (&connection->outgoing_messages, 620 link); 621 _dbus_list_prepend_link (&connection->link_cache, link); 622 623 connection->n_outgoing -= 1; 624 625 _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from outgoing queue %p, %d left to send\n", 626 message, 627 dbus_message_type_to_string (dbus_message_get_type (message)), 628 dbus_message_get_path (message) ? 629 dbus_message_get_path (message) : 630 "no path", 631 dbus_message_get_interface (message) ? 632 dbus_message_get_interface (message) : 633 "no interface", 634 dbus_message_get_member (message) ? 635 dbus_message_get_member (message) : 636 "no member", 637 dbus_message_get_signature (message), 638 connection, connection->n_outgoing); 639 640 /* Save this link in the link cache also */ 641 _dbus_message_remove_counter (message, connection->outgoing_counter, 642 &link); 643 _dbus_list_prepend_link (&connection->link_cache, link); 644 645 dbus_message_unref (message); 646 } 647 648 /** Function to be called in protected_change_watch() with refcount held */ 649 typedef dbus_bool_t (* DBusWatchAddFunction) (DBusWatchList *list, 650 DBusWatch *watch); 651 /** Function to be called in protected_change_watch() with refcount held */ 652 typedef void (* DBusWatchRemoveFunction) (DBusWatchList *list, 653 DBusWatch *watch); 654 /** Function to be called in protected_change_watch() with refcount held */ 655 typedef void (* DBusWatchToggleFunction) (DBusWatchList *list, 656 DBusWatch *watch, 657 dbus_bool_t enabled); 658 659 static dbus_bool_t 660 protected_change_watch (DBusConnection *connection, 661 DBusWatch *watch, 662 DBusWatchAddFunction add_function, 663 DBusWatchRemoveFunction remove_function, 664 DBusWatchToggleFunction toggle_function, 665 dbus_bool_t enabled) 666 { 667 dbus_bool_t retval; 668 669 HAVE_LOCK_CHECK (connection); 670 671 /* The original purpose of protected_change_watch() was to hold a 672 * ref on the connection while dropping the connection lock, then 673 * calling out to the app. This was a broken hack that did not 674 * work, since the connection was in a hosed state (no WatchList 675 * field) while calling out. 676 * 677 * So for now we'll just keep the lock while calling out. This means 678 * apps are not allowed to call DBusConnection methods inside a 679 * watch function or they will deadlock. 680 * 681 * The "real fix" is to use the _and_unlock() pattern found 682 * elsewhere in the code, to defer calling out to the app until 683 * we're about to drop locks and return flow of control to the app 684 * anyway. 685 * 686 * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144 687 */ 688 689 if (connection->watches) 690 { 691 if (add_function) 692 retval = (* add_function) (connection->watches, watch); 693 else if (remove_function) 694 { 695 retval = TRUE; 696 (* remove_function) (connection->watches, watch); 697 } 698 else 699 { 700 retval = TRUE; 701 (* toggle_function) (connection->watches, watch, enabled); 702 } 703 return retval; 704 } 705 else 706 return FALSE; 707 } 708 709 710 /** 711 * Adds a watch using the connection's DBusAddWatchFunction if 712 * available. Otherwise records the watch to be added when said 713 * function is available. Also re-adds the watch if the 714 * DBusAddWatchFunction changes. May fail due to lack of memory. 715 * Connection lock should be held when calling this. 716 * 717 * @param connection the connection. 718 * @param watch the watch to add. 719 * @returns #TRUE on success. 720 */ 721 dbus_bool_t 722 _dbus_connection_add_watch_unlocked (DBusConnection *connection, 723 DBusWatch *watch) 724 { 725 return protected_change_watch (connection, watch, 726 _dbus_watch_list_add_watch, 727 NULL, NULL, FALSE); 728 } 729 730 /** 731 * Removes a watch using the connection's DBusRemoveWatchFunction 732 * if available. It's an error to call this function on a watch 733 * that was not previously added. 734 * Connection lock should be held when calling this. 735 * 736 * @param connection the connection. 737 * @param watch the watch to remove. 738 */ 739 void 740 _dbus_connection_remove_watch_unlocked (DBusConnection *connection, 741 DBusWatch *watch) 742 { 743 protected_change_watch (connection, watch, 744 NULL, 745 _dbus_watch_list_remove_watch, 746 NULL, FALSE); 747 } 748 749 /** 750 * Toggles a watch and notifies app via connection's 751 * DBusWatchToggledFunction if available. It's an error to call this 752 * function on a watch that was not previously added. 753 * Connection lock should be held when calling this. 754 * 755 * @param connection the connection. 756 * @param watch the watch to toggle. 757 * @param enabled whether to enable or disable 758 */ 759 void 760 _dbus_connection_toggle_watch_unlocked (DBusConnection *connection, 761 DBusWatch *watch, 762 dbus_bool_t enabled) 763 { 764 _dbus_assert (watch != NULL); 765 766 protected_change_watch (connection, watch, 767 NULL, NULL, 768 _dbus_watch_list_toggle_watch, 769 enabled); 770 } 771 772 /** Function to be called in protected_change_timeout() with refcount held */ 773 typedef dbus_bool_t (* DBusTimeoutAddFunction) (DBusTimeoutList *list, 774 DBusTimeout *timeout); 775 /** Function to be called in protected_change_timeout() with refcount held */ 776 typedef void (* DBusTimeoutRemoveFunction) (DBusTimeoutList *list, 777 DBusTimeout *timeout); 778 /** Function to be called in protected_change_timeout() with refcount held */ 779 typedef void (* DBusTimeoutToggleFunction) (DBusTimeoutList *list, 780 DBusTimeout *timeout, 781 dbus_bool_t enabled); 782 783 static dbus_bool_t 784 protected_change_timeout (DBusConnection *connection, 785 DBusTimeout *timeout, 786 DBusTimeoutAddFunction add_function, 787 DBusTimeoutRemoveFunction remove_function, 788 DBusTimeoutToggleFunction toggle_function, 789 dbus_bool_t enabled) 790 { 791 dbus_bool_t retval; 792 793 HAVE_LOCK_CHECK (connection); 794 795 /* The original purpose of protected_change_timeout() was to hold a 796 * ref on the connection while dropping the connection lock, then 797 * calling out to the app. This was a broken hack that did not 798 * work, since the connection was in a hosed state (no TimeoutList 799 * field) while calling out. 800 * 801 * So for now we'll just keep the lock while calling out. This means 802 * apps are not allowed to call DBusConnection methods inside a 803 * timeout function or they will deadlock. 804 * 805 * The "real fix" is to use the _and_unlock() pattern found 806 * elsewhere in the code, to defer calling out to the app until 807 * we're about to drop locks and return flow of control to the app 808 * anyway. 809 * 810 * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144 811 */ 812 813 if (connection->timeouts) 814 { 815 if (add_function) 816 retval = (* add_function) (connection->timeouts, timeout); 817 else if (remove_function) 818 { 819 retval = TRUE; 820 (* remove_function) (connection->timeouts, timeout); 821 } 822 else 823 { 824 retval = TRUE; 825 (* toggle_function) (connection->timeouts, timeout, enabled); 826 } 827 return retval; 828 } 829 else 830 return FALSE; 831 } 832 833 /** 834 * Adds a timeout using the connection's DBusAddTimeoutFunction if 835 * available. Otherwise records the timeout to be added when said 836 * function is available. Also re-adds the timeout if the 837 * DBusAddTimeoutFunction changes. May fail due to lack of memory. 838 * The timeout will fire repeatedly until removed. 839 * Connection lock should be held when calling this. 840 * 841 * @param connection the connection. 842 * @param timeout the timeout to add. 843 * @returns #TRUE on success. 844 */ 845 dbus_bool_t 846 _dbus_connection_add_timeout_unlocked (DBusConnection *connection, 847 DBusTimeout *timeout) 848 { 849 return protected_change_timeout (connection, timeout, 850 _dbus_timeout_list_add_timeout, 851 NULL, NULL, FALSE); 852 } 853 854 /** 855 * Removes a timeout using the connection's DBusRemoveTimeoutFunction 856 * if available. It's an error to call this function on a timeout 857 * that was not previously added. 858 * Connection lock should be held when calling this. 859 * 860 * @param connection the connection. 861 * @param timeout the timeout to remove. 862 */ 863 void 864 _dbus_connection_remove_timeout_unlocked (DBusConnection *connection, 865 DBusTimeout *timeout) 866 { 867 protected_change_timeout (connection, timeout, 868 NULL, 869 _dbus_timeout_list_remove_timeout, 870 NULL, FALSE); 871 } 872 873 /** 874 * Toggles a timeout and notifies app via connection's 875 * DBusTimeoutToggledFunction if available. It's an error to call this 876 * function on a timeout that was not previously added. 877 * Connection lock should be held when calling this. 878 * 879 * @param connection the connection. 880 * @param timeout the timeout to toggle. 881 * @param enabled whether to enable or disable 882 */ 883 void 884 _dbus_connection_toggle_timeout_unlocked (DBusConnection *connection, 885 DBusTimeout *timeout, 886 dbus_bool_t enabled) 887 { 888 protected_change_timeout (connection, timeout, 889 NULL, NULL, 890 _dbus_timeout_list_toggle_timeout, 891 enabled); 892 } 893 894 static dbus_bool_t 895 _dbus_connection_attach_pending_call_unlocked (DBusConnection *connection, 896 DBusPendingCall *pending) 897 { 898 dbus_uint32_t reply_serial; 899 DBusTimeout *timeout; 900 901 HAVE_LOCK_CHECK (connection); 902 903 reply_serial = _dbus_pending_call_get_reply_serial_unlocked (pending); 904 905 _dbus_assert (reply_serial != 0); 906 907 timeout = _dbus_pending_call_get_timeout_unlocked (pending); 908 909 if (timeout) 910 { 911 if (!_dbus_connection_add_timeout_unlocked (connection, timeout)) 912 return FALSE; 913 914 if (!_dbus_hash_table_insert_int (connection->pending_replies, 915 reply_serial, 916 pending)) 917 { 918 _dbus_connection_remove_timeout_unlocked (connection, timeout); 919 920 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 921 HAVE_LOCK_CHECK (connection); 922 return FALSE; 923 } 924 925 _dbus_pending_call_set_timeout_added_unlocked (pending, TRUE); 926 } 927 else 928 { 929 if (!_dbus_hash_table_insert_int (connection->pending_replies, 930 reply_serial, 931 pending)) 932 { 933 HAVE_LOCK_CHECK (connection); 934 return FALSE; 935 } 936 } 937 938 _dbus_pending_call_ref_unlocked (pending); 939 940 HAVE_LOCK_CHECK (connection); 941 942 return TRUE; 943 } 944 945 static void 946 free_pending_call_on_hash_removal (void *data) 947 { 948 DBusPendingCall *pending; 949 DBusConnection *connection; 950 951 if (data == NULL) 952 return; 953 954 pending = data; 955 956 connection = _dbus_pending_call_get_connection_unlocked (pending); 957 958 HAVE_LOCK_CHECK (connection); 959 960 if (_dbus_pending_call_is_timeout_added_unlocked (pending)) 961 { 962 _dbus_connection_remove_timeout_unlocked (connection, 963 _dbus_pending_call_get_timeout_unlocked (pending)); 964 965 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 966 } 967 968 /* FIXME 1.0? this is sort of dangerous and undesirable to drop the lock 969 * here, but the pending call finalizer could in principle call out to 970 * application code so we pretty much have to... some larger code reorg 971 * might be needed. 972 */ 973 _dbus_connection_ref_unlocked (connection); 974 _dbus_pending_call_unref_and_unlock (pending); 975 CONNECTION_LOCK (connection); 976 _dbus_connection_unref_unlocked (connection); 977 } 978 979 static void 980 _dbus_connection_detach_pending_call_unlocked (DBusConnection *connection, 981 DBusPendingCall *pending) 982 { 983 /* This ends up unlocking to call the pending call finalizer, which is unexpected to 984 * say the least. 985 */ 986 _dbus_hash_table_remove_int (connection->pending_replies, 987 _dbus_pending_call_get_reply_serial_unlocked (pending)); 988 } 989 990 static void 991 _dbus_connection_detach_pending_call_and_unlock (DBusConnection *connection, 992 DBusPendingCall *pending) 993 { 994 /* The idea here is to avoid finalizing the pending call 995 * with the lock held, since there's a destroy notifier 996 * in pending call that goes out to application code. 997 * 998 * There's an extra unlock inside the hash table 999 * "free pending call" function FIXME... 1000 */ 1001 _dbus_pending_call_ref_unlocked (pending); 1002 _dbus_hash_table_remove_int (connection->pending_replies, 1003 _dbus_pending_call_get_reply_serial_unlocked (pending)); 1004 1005 if (_dbus_pending_call_is_timeout_added_unlocked (pending)) 1006 _dbus_connection_remove_timeout_unlocked (connection, 1007 _dbus_pending_call_get_timeout_unlocked (pending)); 1008 1009 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 1010 1011 _dbus_pending_call_unref_and_unlock (pending); 1012 } 1013 1014 /** 1015 * Removes a pending call from the connection, such that 1016 * the pending reply will be ignored. May drop the last 1017 * reference to the pending call. 1018 * 1019 * @param connection the connection 1020 * @param pending the pending call 1021 */ 1022 void 1023 _dbus_connection_remove_pending_call (DBusConnection *connection, 1024 DBusPendingCall *pending) 1025 { 1026 CONNECTION_LOCK (connection); 1027 _dbus_connection_detach_pending_call_and_unlock (connection, pending); 1028 } 1029 1030 /** 1031 * Acquire the transporter I/O path. This must be done before 1032 * doing any I/O in the transporter. May sleep and drop the 1033 * IO path mutex while waiting for the I/O path. 1034 * 1035 * @param connection the connection. 1036 * @param timeout_milliseconds maximum blocking time, or -1 for no limit. 1037 * @returns TRUE if the I/O path was acquired. 1038 */ 1039 static dbus_bool_t 1040 _dbus_connection_acquire_io_path (DBusConnection *connection, 1041 int timeout_milliseconds) 1042 { 1043 dbus_bool_t we_acquired; 1044 1045 HAVE_LOCK_CHECK (connection); 1046 1047 /* We don't want the connection to vanish */ 1048 _dbus_connection_ref_unlocked (connection); 1049 1050 /* We will only touch io_path_acquired which is protected by our mutex */ 1051 CONNECTION_UNLOCK (connection); 1052 1053 _dbus_verbose ("locking io_path_mutex\n"); 1054 _dbus_mutex_lock (connection->io_path_mutex); 1055 1056 _dbus_verbose ("start connection->io_path_acquired = %d timeout = %d\n", 1057 connection->io_path_acquired, timeout_milliseconds); 1058 1059 we_acquired = FALSE; 1060 1061 if (connection->io_path_acquired) 1062 { 1063 if (timeout_milliseconds != -1) 1064 { 1065 _dbus_verbose ("waiting %d for IO path to be acquirable\n", 1066 timeout_milliseconds); 1067 1068 if (!_dbus_condvar_wait_timeout (connection->io_path_cond, 1069 connection->io_path_mutex, 1070 timeout_milliseconds)) 1071 { 1072 /* We timed out before anyone signaled. */ 1073 /* (writing the loop to handle the !timedout case by 1074 * waiting longer if needed is a pain since dbus 1075 * wraps pthread_cond_timedwait to take a relative 1076 * time instead of absolute, something kind of stupid 1077 * on our part. for now it doesn't matter, we will just 1078 * end up back here eventually.) 1079 */ 1080 } 1081 } 1082 else 1083 { 1084 while (connection->io_path_acquired) 1085 { 1086 _dbus_verbose ("waiting for IO path to be acquirable\n"); 1087 _dbus_condvar_wait (connection->io_path_cond, 1088 connection->io_path_mutex); 1089 } 1090 } 1091 } 1092 1093 if (!connection->io_path_acquired) 1094 { 1095 we_acquired = TRUE; 1096 connection->io_path_acquired = TRUE; 1097 } 1098 1099 _dbus_verbose ("end connection->io_path_acquired = %d we_acquired = %d\n", 1100 connection->io_path_acquired, we_acquired); 1101 1102 _dbus_verbose ("unlocking io_path_mutex\n"); 1103 _dbus_mutex_unlock (connection->io_path_mutex); 1104 1105 CONNECTION_LOCK (connection); 1106 1107 HAVE_LOCK_CHECK (connection); 1108 1109 _dbus_connection_unref_unlocked (connection); 1110 1111 return we_acquired; 1112 } 1113 1114 /** 1115 * Release the I/O path when you're done with it. Only call 1116 * after you've acquired the I/O. Wakes up at most one thread 1117 * currently waiting to acquire the I/O path. 1118 * 1119 * @param connection the connection. 1120 */ 1121 static void 1122 _dbus_connection_release_io_path (DBusConnection *connection) 1123 { 1124 HAVE_LOCK_CHECK (connection); 1125 1126 _dbus_verbose ("locking io_path_mutex\n"); 1127 _dbus_mutex_lock (connection->io_path_mutex); 1128 1129 _dbus_assert (connection->io_path_acquired); 1130 1131 _dbus_verbose ("start connection->io_path_acquired = %d\n", 1132 connection->io_path_acquired); 1133 1134 connection->io_path_acquired = FALSE; 1135 _dbus_condvar_wake_one (connection->io_path_cond); 1136 1137 _dbus_verbose ("unlocking io_path_mutex\n"); 1138 _dbus_mutex_unlock (connection->io_path_mutex); 1139 } 1140 1141 /** 1142 * Queues incoming messages and sends outgoing messages for this 1143 * connection, optionally blocking in the process. Each call to 1144 * _dbus_connection_do_iteration_unlocked() will call select() or poll() one 1145 * time and then read or write data if possible. 1146 * 1147 * The purpose of this function is to be able to flush outgoing 1148 * messages or queue up incoming messages without returning 1149 * control to the application and causing reentrancy weirdness. 1150 * 1151 * The flags parameter allows you to specify whether to 1152 * read incoming messages, write outgoing messages, or both, 1153 * and whether to block if no immediate action is possible. 1154 * 1155 * The timeout_milliseconds parameter does nothing unless the 1156 * iteration is blocking. 1157 * 1158 * If there are no outgoing messages and DBUS_ITERATION_DO_READING 1159 * wasn't specified, then it's impossible to block, even if 1160 * you specify DBUS_ITERATION_BLOCK; in that case the function 1161 * returns immediately. 1162 * 1163 * If pending is not NULL then a check is made if the pending call 1164 * is completed after the io path has been required. If the call 1165 * has been completed nothing is done. This must be done since 1166 * the _dbus_connection_acquire_io_path releases the connection 1167 * lock for a while. 1168 * 1169 * Called with connection lock held. 1170 * 1171 * @param connection the connection. 1172 * @param pending the pending call that should be checked or NULL 1173 * @param flags iteration flags. 1174 * @param timeout_milliseconds maximum blocking time, or -1 for no limit. 1175 */ 1176 void 1177 _dbus_connection_do_iteration_unlocked (DBusConnection *connection, 1178 DBusPendingCall *pending, 1179 unsigned int flags, 1180 int timeout_milliseconds) 1181 { 1182 _dbus_verbose ("start\n"); 1183 1184 HAVE_LOCK_CHECK (connection); 1185 1186 if (connection->n_outgoing == 0) 1187 flags &= ~DBUS_ITERATION_DO_WRITING; 1188 1189 if (_dbus_connection_acquire_io_path (connection, 1190 (flags & DBUS_ITERATION_BLOCK) ? timeout_milliseconds : 0)) 1191 { 1192 HAVE_LOCK_CHECK (connection); 1193 1194 if ( (pending != NULL) && _dbus_pending_call_get_completed_unlocked(pending)) 1195 { 1196 _dbus_verbose ("pending call completed while acquiring I/O path"); 1197 } 1198 else if ( (pending != NULL) && 1199 _dbus_connection_peek_for_reply_unlocked (connection, 1200 _dbus_pending_call_get_reply_serial_unlocked (pending))) 1201 { 1202 _dbus_verbose ("pending call completed while acquiring I/O path (reply found in queue)"); 1203 } 1204 else 1205 { 1206 _dbus_transport_do_iteration (connection->transport, 1207 flags, timeout_milliseconds); 1208 } 1209 1210 _dbus_connection_release_io_path (connection); 1211 } 1212 1213 HAVE_LOCK_CHECK (connection); 1214 1215 _dbus_verbose ("end\n"); 1216 } 1217 1218 /** 1219 * Creates a new connection for the given transport. A transport 1220 * represents a message stream that uses some concrete mechanism, such 1221 * as UNIX domain sockets. May return #NULL if insufficient 1222 * memory exists to create the connection. 1223 * 1224 * @param transport the transport. 1225 * @returns the new connection, or #NULL on failure. 1226 */ 1227 DBusConnection* 1228 _dbus_connection_new_for_transport (DBusTransport *transport) 1229 { 1230 DBusConnection *connection; 1231 DBusWatchList *watch_list; 1232 DBusTimeoutList *timeout_list; 1233 DBusHashTable *pending_replies; 1234 DBusList *disconnect_link; 1235 DBusMessage *disconnect_message; 1236 DBusCounter *outgoing_counter; 1237 DBusObjectTree *objects; 1238 1239 watch_list = NULL; 1240 connection = NULL; 1241 pending_replies = NULL; 1242 timeout_list = NULL; 1243 disconnect_link = NULL; 1244 disconnect_message = NULL; 1245 outgoing_counter = NULL; 1246 objects = NULL; 1247 1248 watch_list = _dbus_watch_list_new (); 1249 if (watch_list == NULL) 1250 goto error; 1251 1252 timeout_list = _dbus_timeout_list_new (); 1253 if (timeout_list == NULL) 1254 goto error; 1255 1256 pending_replies = 1257 _dbus_hash_table_new (DBUS_HASH_INT, 1258 NULL, 1259 (DBusFreeFunction)free_pending_call_on_hash_removal); 1260 if (pending_replies == NULL) 1261 goto error; 1262 1263 connection = dbus_new0 (DBusConnection, 1); 1264 if (connection == NULL) 1265 goto error; 1266 1267 _dbus_mutex_new_at_location (&connection->mutex); 1268 if (connection->mutex == NULL) 1269 goto error; 1270 1271 _dbus_mutex_new_at_location (&connection->io_path_mutex); 1272 if (connection->io_path_mutex == NULL) 1273 goto error; 1274 1275 _dbus_mutex_new_at_location (&connection->dispatch_mutex); 1276 if (connection->dispatch_mutex == NULL) 1277 goto error; 1278 1279 _dbus_condvar_new_at_location (&connection->dispatch_cond); 1280 if (connection->dispatch_cond == NULL) 1281 goto error; 1282 1283 _dbus_condvar_new_at_location (&connection->io_path_cond); 1284 if (connection->io_path_cond == NULL) 1285 goto error; 1286 1287 _dbus_mutex_new_at_location (&connection->slot_mutex); 1288 if (connection->slot_mutex == NULL) 1289 goto error; 1290 1291 disconnect_message = dbus_message_new_signal (DBUS_PATH_LOCAL, 1292 DBUS_INTERFACE_LOCAL, 1293 "Disconnected"); 1294 1295 if (disconnect_message == NULL) 1296 goto error; 1297 1298 disconnect_link = _dbus_list_alloc_link (disconnect_message); 1299 if (disconnect_link == NULL) 1300 goto error; 1301 1302 outgoing_counter = _dbus_counter_new (); 1303 if (outgoing_counter == NULL) 1304 goto error; 1305 1306 objects = _dbus_object_tree_new (connection); 1307 if (objects == NULL) 1308 goto error; 1309 1310 if (_dbus_modify_sigpipe) 1311 _dbus_disable_sigpipe (); 1312 1313 connection->refcount.value = 1; 1314 connection->transport = transport; 1315 connection->watches = watch_list; 1316 connection->timeouts = timeout_list; 1317 connection->pending_replies = pending_replies; 1318 connection->outgoing_counter = outgoing_counter; 1319 connection->filter_list = NULL; 1320 connection->last_dispatch_status = DBUS_DISPATCH_COMPLETE; /* so we're notified first time there's data */ 1321 connection->objects = objects; 1322 connection->exit_on_disconnect = FALSE; 1323 connection->shareable = FALSE; 1324 connection->route_peer_messages = FALSE; 1325 connection->disconnected_message_arrived = FALSE; 1326 connection->disconnected_message_processed = FALSE; 1327 1328 #ifndef DBUS_DISABLE_CHECKS 1329 connection->generation = _dbus_current_generation; 1330 #endif 1331 1332 _dbus_data_slot_list_init (&connection->slot_list); 1333 1334 connection->client_serial = 1; 1335 1336 connection->disconnect_message_link = disconnect_link; 1337 1338 CONNECTION_LOCK (connection); 1339 1340 if (!_dbus_transport_set_connection (transport, connection)) 1341 { 1342 CONNECTION_UNLOCK (connection); 1343 1344 goto error; 1345 } 1346 1347 _dbus_transport_ref (transport); 1348 1349 CONNECTION_UNLOCK (connection); 1350 1351 return connection; 1352 1353 error: 1354 if (disconnect_message != NULL) 1355 dbus_message_unref (disconnect_message); 1356 1357 if (disconnect_link != NULL) 1358 _dbus_list_free_link (disconnect_link); 1359 1360 if (connection != NULL) 1361 { 1362 _dbus_condvar_free_at_location (&connection->io_path_cond); 1363 _dbus_condvar_free_at_location (&connection->dispatch_cond); 1364 _dbus_mutex_free_at_location (&connection->mutex); 1365 _dbus_mutex_free_at_location (&connection->io_path_mutex); 1366 _dbus_mutex_free_at_location (&connection->dispatch_mutex); 1367 _dbus_mutex_free_at_location (&connection->slot_mutex); 1368 dbus_free (connection); 1369 } 1370 if (pending_replies) 1371 _dbus_hash_table_unref (pending_replies); 1372 1373 if (watch_list) 1374 _dbus_watch_list_free (watch_list); 1375 1376 if (timeout_list) 1377 _dbus_timeout_list_free (timeout_list); 1378 1379 if (outgoing_counter) 1380 _dbus_counter_unref (outgoing_counter); 1381 1382 if (objects) 1383 _dbus_object_tree_unref (objects); 1384 1385 return NULL; 1386 } 1387 1388 /** 1389 * Increments the reference count of a DBusConnection. 1390 * Requires that the caller already holds the connection lock. 1391 * 1392 * @param connection the connection. 1393 * @returns the connection. 1394 */ 1395 DBusConnection * 1396 _dbus_connection_ref_unlocked (DBusConnection *connection) 1397 { 1398 _dbus_assert (connection != NULL); 1399 _dbus_assert (connection->generation == _dbus_current_generation); 1400 1401 HAVE_LOCK_CHECK (connection); 1402 1403 _dbus_atomic_inc (&connection->refcount); 1404 1405 return connection; 1406 } 1407 1408 /** 1409 * Decrements the reference count of a DBusConnection. 1410 * Requires that the caller already holds the connection lock. 1411 * 1412 * @param connection the connection. 1413 */ 1414 void 1415 _dbus_connection_unref_unlocked (DBusConnection *connection) 1416 { 1417 dbus_bool_t last_unref; 1418 1419 HAVE_LOCK_CHECK (connection); 1420 1421 _dbus_assert (connection != NULL); 1422 1423 last_unref = (_dbus_atomic_dec (&connection->refcount) == 1); 1424 1425 if (last_unref) 1426 _dbus_connection_last_unref (connection); 1427 } 1428 1429 static dbus_uint32_t 1430 _dbus_connection_get_next_client_serial (DBusConnection *connection) 1431 { 1432 dbus_uint32_t serial; 1433 1434 serial = connection->client_serial++; 1435 1436 if (connection->client_serial == 0) 1437 connection->client_serial = 1; 1438 1439 return serial; 1440 } 1441 1442 /** 1443 * A callback for use with dbus_watch_new() to create a DBusWatch. 1444 * 1445 * @todo This is basically a hack - we could delete _dbus_transport_handle_watch() 1446 * and the virtual handle_watch in DBusTransport if we got rid of it. 1447 * The reason this is some work is threading, see the _dbus_connection_handle_watch() 1448 * implementation. 1449 * 1450 * @param watch the watch. 1451 * @param condition the current condition of the file descriptors being watched. 1452 * @param data must be a pointer to a #DBusConnection 1453 * @returns #FALSE if the IO condition may not have been fully handled due to lack of memory 1454 */ 1455 dbus_bool_t 1456 _dbus_connection_handle_watch (DBusWatch *watch, 1457 unsigned int condition, 1458 void *data) 1459 { 1460 DBusConnection *connection; 1461 dbus_bool_t retval; 1462 DBusDispatchStatus status; 1463 1464 connection = data; 1465 1466 _dbus_verbose ("start\n"); 1467 1468 CONNECTION_LOCK (connection); 1469 1470 if (!_dbus_connection_acquire_io_path (connection, 1)) 1471 { 1472 /* another thread is handling the message */ 1473 CONNECTION_UNLOCK (connection); 1474 return TRUE; 1475 } 1476 1477 HAVE_LOCK_CHECK (connection); 1478 retval = _dbus_transport_handle_watch (connection->transport, 1479 watch, condition); 1480 1481 _dbus_connection_release_io_path (connection); 1482 1483 HAVE_LOCK_CHECK (connection); 1484 1485 _dbus_verbose ("middle\n"); 1486 1487 status = _dbus_connection_get_dispatch_status_unlocked (connection); 1488 1489 /* this calls out to user code */ 1490 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 1491 1492 _dbus_verbose ("end\n"); 1493 1494 return retval; 1495 } 1496 1497 _DBUS_DEFINE_GLOBAL_LOCK (shared_connections); 1498 static DBusHashTable *shared_connections = NULL; 1499 static DBusList *shared_connections_no_guid = NULL; 1500 1501 static void 1502 close_connection_on_shutdown (DBusConnection *connection) 1503 { 1504 DBusMessage *message; 1505 1506 dbus_connection_ref (connection); 1507 _dbus_connection_close_possibly_shared (connection); 1508 1509 /* Churn through to the Disconnected message */ 1510 while ((message = dbus_connection_pop_message (connection))) 1511 { 1512 dbus_message_unref (message); 1513 } 1514 dbus_connection_unref (connection); 1515 } 1516 1517 static void 1518 shared_connections_shutdown (void *data) 1519 { 1520 int n_entries; 1521 1522 _DBUS_LOCK (shared_connections); 1523 1524 /* This is a little bit unpleasant... better ideas? */ 1525 while ((n_entries = _dbus_hash_table_get_n_entries (shared_connections)) > 0) 1526 { 1527 DBusConnection *connection; 1528 DBusHashIter iter; 1529 1530 _dbus_hash_iter_init (shared_connections, &iter); 1531 _dbus_hash_iter_next (&iter); 1532 1533 connection = _dbus_hash_iter_get_value (&iter); 1534 1535 _DBUS_UNLOCK (shared_connections); 1536 close_connection_on_shutdown (connection); 1537 _DBUS_LOCK (shared_connections); 1538 1539 /* The connection should now be dead and not in our hash ... */ 1540 _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) < n_entries); 1541 } 1542 1543 _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) == 0); 1544 1545 _dbus_hash_table_unref (shared_connections); 1546 shared_connections = NULL; 1547 1548 if (shared_connections_no_guid != NULL) 1549 { 1550 DBusConnection *connection; 1551 connection = _dbus_list_pop_first (&shared_connections_no_guid); 1552 while (connection != NULL) 1553 { 1554 _DBUS_UNLOCK (shared_connections); 1555 close_connection_on_shutdown (connection); 1556 _DBUS_LOCK (shared_connections); 1557 connection = _dbus_list_pop_first (&shared_connections_no_guid); 1558 } 1559 } 1560 1561 shared_connections_no_guid = NULL; 1562 1563 _DBUS_UNLOCK (shared_connections); 1564 } 1565 1566 static dbus_bool_t 1567 connection_lookup_shared (DBusAddressEntry *entry, 1568 DBusConnection **result) 1569 { 1570 _dbus_verbose ("checking for existing connection\n"); 1571 1572 *result = NULL; 1573 1574 _DBUS_LOCK (shared_connections); 1575 1576 if (shared_connections == NULL) 1577 { 1578 _dbus_verbose ("creating shared_connections hash table\n"); 1579 1580 shared_connections = _dbus_hash_table_new (DBUS_HASH_STRING, 1581 dbus_free, 1582 NULL); 1583 if (shared_connections == NULL) 1584 { 1585 _DBUS_UNLOCK (shared_connections); 1586 return FALSE; 1587 } 1588 1589 if (!_dbus_register_shutdown_func (shared_connections_shutdown, NULL)) 1590 { 1591 _dbus_hash_table_unref (shared_connections); 1592 shared_connections = NULL; 1593 _DBUS_UNLOCK (shared_connections); 1594 return FALSE; 1595 } 1596 1597 _dbus_verbose (" successfully created shared_connections\n"); 1598 1599 _DBUS_UNLOCK (shared_connections); 1600 return TRUE; /* no point looking up in the hash we just made */ 1601 } 1602 else 1603 { 1604 const char *guid; 1605 1606 guid = dbus_address_entry_get_value (entry, "guid"); 1607 1608 if (guid != NULL) 1609 { 1610 DBusConnection *connection; 1611 1612 connection = _dbus_hash_table_lookup_string (shared_connections, 1613 guid); 1614 1615 if (connection) 1616 { 1617 /* The DBusConnection can't be finalized without taking 1618 * the shared_connections lock to remove it from the 1619 * hash. So it's safe to ref the connection here. 1620 * However, it may be disconnected if the Disconnected 1621 * message hasn't been processed yet, in which case we 1622 * want to pretend it isn't in the hash and avoid 1623 * returning it. 1624 * 1625 * The idea is to avoid ever returning a disconnected connection 1626 * from dbus_connection_open(). We could just synchronously 1627 * drop our shared ref to the connection on connection disconnect, 1628 * and then assert here that the connection is connected, but 1629 * that causes reentrancy headaches. 1630 */ 1631 CONNECTION_LOCK (connection); 1632 if (_dbus_connection_get_is_connected_unlocked (connection)) 1633 { 1634 _dbus_connection_ref_unlocked (connection); 1635 *result = connection; 1636 _dbus_verbose ("looked up existing connection to server guid %s\n", 1637 guid); 1638 } 1639 else 1640 { 1641 _dbus_verbose ("looked up existing connection to server guid %s but it was disconnected so ignoring it\n", 1642 guid); 1643 } 1644 CONNECTION_UNLOCK (connection); 1645 } 1646 } 1647 1648 _DBUS_UNLOCK (shared_connections); 1649 return TRUE; 1650 } 1651 } 1652 1653 static dbus_bool_t 1654 connection_record_shared_unlocked (DBusConnection *connection, 1655 const char *guid) 1656 { 1657 char *guid_key; 1658 char *guid_in_connection; 1659 1660 HAVE_LOCK_CHECK (connection); 1661 _dbus_assert (connection->server_guid == NULL); 1662 _dbus_assert (connection->shareable); 1663 1664 /* get a hard ref on this connection, even if 1665 * we won't in fact store it in the hash, we still 1666 * need to hold a ref on it until it's disconnected. 1667 */ 1668 _dbus_connection_ref_unlocked (connection); 1669 1670 if (guid == NULL) 1671 { 1672 _DBUS_LOCK (shared_connections); 1673 1674 if (!_dbus_list_prepend (&shared_connections_no_guid, connection)) 1675 { 1676 _DBUS_UNLOCK (shared_connections); 1677 return FALSE; 1678 } 1679 1680 _DBUS_UNLOCK (shared_connections); 1681 return TRUE; /* don't store in the hash */ 1682 } 1683 1684 /* A separate copy of the key is required in the hash table, because 1685 * we don't have a lock on the connection when we are doing a hash 1686 * lookup. 1687 */ 1688 1689 guid_key = _dbus_strdup (guid); 1690 if (guid_key == NULL) 1691 return FALSE; 1692 1693 guid_in_connection = _dbus_strdup (guid); 1694 if (guid_in_connection == NULL) 1695 { 1696 dbus_free (guid_key); 1697 return FALSE; 1698 } 1699 1700 _DBUS_LOCK (shared_connections); 1701 _dbus_assert (shared_connections != NULL); 1702 1703 if (!_dbus_hash_table_insert_string (shared_connections, 1704 guid_key, connection)) 1705 { 1706 dbus_free (guid_key); 1707 dbus_free (guid_in_connection); 1708 _DBUS_UNLOCK (shared_connections); 1709 return FALSE; 1710 } 1711 1712 connection->server_guid = guid_in_connection; 1713 1714 _dbus_verbose ("stored connection to %s to be shared\n", 1715 connection->server_guid); 1716 1717 _DBUS_UNLOCK (shared_connections); 1718 1719 _dbus_assert (connection->server_guid != NULL); 1720 1721 return TRUE; 1722 } 1723 1724 static void 1725 connection_forget_shared_unlocked (DBusConnection *connection) 1726 { 1727 HAVE_LOCK_CHECK (connection); 1728 1729 if (!connection->shareable) 1730 return; 1731 1732 _DBUS_LOCK (shared_connections); 1733 1734 if (connection->server_guid != NULL) 1735 { 1736 _dbus_verbose ("dropping connection to %s out of the shared table\n", 1737 connection->server_guid); 1738 1739 if (!_dbus_hash_table_remove_string (shared_connections, 1740 connection->server_guid)) 1741 _dbus_assert_not_reached ("connection was not in the shared table"); 1742 1743 dbus_free (connection->server_guid); 1744 connection->server_guid = NULL; 1745 } 1746 else 1747 { 1748 _dbus_list_remove (&shared_connections_no_guid, connection); 1749 } 1750 1751 _DBUS_UNLOCK (shared_connections); 1752 1753 /* remove our reference held on all shareable connections */ 1754 _dbus_connection_unref_unlocked (connection); 1755 } 1756 1757 static DBusConnection* 1758 connection_try_from_address_entry (DBusAddressEntry *entry, 1759 DBusError *error) 1760 { 1761 DBusTransport *transport; 1762 DBusConnection *connection; 1763 1764 transport = _dbus_transport_open (entry, error); 1765 1766 if (transport == NULL) 1767 { 1768 _DBUS_ASSERT_ERROR_IS_SET (error); 1769 return NULL; 1770 } 1771 1772 connection = _dbus_connection_new_for_transport (transport); 1773 1774 _dbus_transport_unref (transport); 1775 1776 if (connection == NULL) 1777 { 1778 _DBUS_SET_OOM (error); 1779 return NULL; 1780 } 1781 1782 #ifndef DBUS_DISABLE_CHECKS 1783 _dbus_assert (!connection->have_connection_lock); 1784 #endif 1785 return connection; 1786 } 1787 1788 /* 1789 * If the shared parameter is true, then any existing connection will 1790 * be used (and if a new connection is created, it will be available 1791 * for use by others). If the shared parameter is false, a new 1792 * connection will always be created, and the new connection will 1793 * never be returned to other callers. 1794 * 1795 * @param address the address 1796 * @param shared whether the connection is shared or private 1797 * @param error error return 1798 * @returns the connection or #NULL on error 1799 */ 1800 static DBusConnection* 1801 _dbus_connection_open_internal (const char *address, 1802 dbus_bool_t shared, 1803 DBusError *error) 1804 { 1805 DBusConnection *connection; 1806 DBusAddressEntry **entries; 1807 DBusError tmp_error = DBUS_ERROR_INIT; 1808 DBusError first_error = DBUS_ERROR_INIT; 1809 int len, i; 1810 1811 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1812 1813 _dbus_verbose ("opening %s connection to: %s\n", 1814 shared ? "shared" : "private", address); 1815 1816 if (!dbus_parse_address (address, &entries, &len, error)) 1817 return NULL; 1818 1819 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1820 1821 connection = NULL; 1822 1823 for (i = 0; i < len; i++) 1824 { 1825 if (shared) 1826 { 1827 if (!connection_lookup_shared (entries[i], &connection)) 1828 _DBUS_SET_OOM (&tmp_error); 1829 } 1830 1831 if (connection == NULL) 1832 { 1833 connection = connection_try_from_address_entry (entries[i], 1834 &tmp_error); 1835 1836 if (connection != NULL && shared) 1837 { 1838 const char *guid; 1839 1840 connection->shareable = TRUE; 1841 1842 /* guid may be NULL */ 1843 guid = dbus_address_entry_get_value (entries[i], "guid"); 1844 1845 CONNECTION_LOCK (connection); 1846 1847 if (!connection_record_shared_unlocked (connection, guid)) 1848 { 1849 _DBUS_SET_OOM (&tmp_error); 1850 _dbus_connection_close_possibly_shared_and_unlock (connection); 1851 dbus_connection_unref (connection); 1852 connection = NULL; 1853 } 1854 else 1855 CONNECTION_UNLOCK (connection); 1856 } 1857 } 1858 1859 if (connection) 1860 break; 1861 1862 _DBUS_ASSERT_ERROR_CONTENT_IS_SET (&tmp_error); 1863 1864 if (i == 0) 1865 dbus_move_error (&tmp_error, &first_error); 1866 else 1867 dbus_error_free (&tmp_error); 1868 } 1869 1870 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 1871 _DBUS_ASSERT_ERROR_CONTENT_IS_CLEAR (&tmp_error); 1872 1873 if (connection == NULL) 1874 { 1875 _DBUS_ASSERT_ERROR_CONTENT_IS_SET (&first_error); 1876 dbus_move_error (&first_error, error); 1877 } 1878 else 1879 dbus_error_free (&first_error); 1880 1881 dbus_address_entries_free (entries); 1882 return connection; 1883 } 1884 1885 /** 1886 * Closes a shared OR private connection, while dbus_connection_close() can 1887 * only be used on private connections. Should only be called by the 1888 * dbus code that owns the connection - an owner must be known, 1889 * the open/close state is like malloc/free, not like ref/unref. 1890 * 1891 * @param connection the connection 1892 */ 1893 void 1894 _dbus_connection_close_possibly_shared (DBusConnection *connection) 1895 { 1896 _dbus_assert (connection != NULL); 1897 _dbus_assert (connection->generation == _dbus_current_generation); 1898 1899 CONNECTION_LOCK (connection); 1900 _dbus_connection_close_possibly_shared_and_unlock (connection); 1901 } 1902 1903 static DBusPreallocatedSend* 1904 _dbus_connection_preallocate_send_unlocked (DBusConnection *connection) 1905 { 1906 DBusPreallocatedSend *preallocated; 1907 1908 HAVE_LOCK_CHECK (connection); 1909 1910 _dbus_assert (connection != NULL); 1911 1912 preallocated = dbus_new (DBusPreallocatedSend, 1); 1913 if (preallocated == NULL) 1914 return NULL; 1915 1916 if (connection->link_cache != NULL) 1917 { 1918 preallocated->queue_link = 1919 _dbus_list_pop_first_link (&connection->link_cache); 1920 preallocated->queue_link->data = NULL; 1921 } 1922 else 1923 { 1924 preallocated->queue_link = _dbus_list_alloc_link (NULL); 1925 if (preallocated->queue_link == NULL) 1926 goto failed_0; 1927 } 1928 1929 if (connection->link_cache != NULL) 1930 { 1931 preallocated->counter_link = 1932 _dbus_list_pop_first_link (&connection->link_cache); 1933 preallocated->counter_link->data = connection->outgoing_counter; 1934 } 1935 else 1936 { 1937 preallocated->counter_link = _dbus_list_alloc_link (connection->outgoing_counter); 1938 if (preallocated->counter_link == NULL) 1939 goto failed_1; 1940 } 1941 1942 _dbus_counter_ref (preallocated->counter_link->data); 1943 1944 preallocated->connection = connection; 1945 1946 return preallocated; 1947 1948 failed_1: 1949 _dbus_list_free_link (preallocated->queue_link); 1950 failed_0: 1951 dbus_free (preallocated); 1952 1953 return NULL; 1954 } 1955 1956 /* Called with lock held, does not update dispatch status */ 1957 static void 1958 _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *connection, 1959 DBusPreallocatedSend *preallocated, 1960 DBusMessage *message, 1961 dbus_uint32_t *client_serial) 1962 { 1963 dbus_uint32_t serial; 1964 const char *sig; 1965 1966 preallocated->queue_link->data = message; 1967 _dbus_list_prepend_link (&connection->outgoing_messages, 1968 preallocated->queue_link); 1969 1970 _dbus_message_add_counter_link (message, 1971 preallocated->counter_link); 1972 1973 dbus_free (preallocated); 1974 preallocated = NULL; 1975 1976 dbus_message_ref (message); 1977 1978 connection->n_outgoing += 1; 1979 1980 sig = dbus_message_get_signature (message); 1981 1982 _dbus_verbose ("Message %p (%s %s %s %s '%s') for %s added to outgoing queue %p, %d pending to send\n", 1983 message, 1984 dbus_message_type_to_string (dbus_message_get_type (message)), 1985 dbus_message_get_path (message) ? 1986 dbus_message_get_path (message) : 1987 "no path", 1988 dbus_message_get_interface (message) ? 1989 dbus_message_get_interface (message) : 1990 "no interface", 1991 dbus_message_get_member (message) ? 1992 dbus_message_get_member (message) : 1993 "no member", 1994 sig, 1995 dbus_message_get_destination (message) ? 1996 dbus_message_get_destination (message) : 1997 "null", 1998 connection, 1999 connection->n_outgoing); 2000 2001 if (dbus_message_get_serial (message) == 0) 2002 { 2003 serial = _dbus_connection_get_next_client_serial (connection); 2004 dbus_message_set_serial (message, serial); 2005 if (client_serial) 2006 *client_serial = serial; 2007 } 2008 else 2009 { 2010 if (client_serial) 2011 *client_serial = dbus_message_get_serial (message); 2012 } 2013 2014 _dbus_verbose ("Message %p serial is %u\n", 2015 message, dbus_message_get_serial (message)); 2016 2017 dbus_message_lock (message); 2018 2019 /* Now we need to run an iteration to hopefully just write the messages 2020 * out immediately, and otherwise get them queued up 2021 */ 2022 _dbus_connection_do_iteration_unlocked (connection, 2023 NULL, 2024 DBUS_ITERATION_DO_WRITING, 2025 -1); 2026 2027 /* If stuff is still queued up, be sure we wake up the main loop */ 2028 if (connection->n_outgoing > 0) 2029 _dbus_connection_wakeup_mainloop (connection); 2030 } 2031 2032 static void 2033 _dbus_connection_send_preallocated_and_unlock (DBusConnection *connection, 2034 DBusPreallocatedSend *preallocated, 2035 DBusMessage *message, 2036 dbus_uint32_t *client_serial) 2037 { 2038 DBusDispatchStatus status; 2039 2040 HAVE_LOCK_CHECK (connection); 2041 2042 _dbus_connection_send_preallocated_unlocked_no_update (connection, 2043 preallocated, 2044 message, client_serial); 2045 2046 _dbus_verbose ("middle\n"); 2047 status = _dbus_connection_get_dispatch_status_unlocked (connection); 2048 2049 /* this calls out to user code */ 2050 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 2051 } 2052 2053 /** 2054 * Like dbus_connection_send(), but assumes the connection 2055 * is already locked on function entry, and unlocks before returning. 2056 * 2057 * @param connection the connection 2058 * @param message the message to send 2059 * @param client_serial return location for client serial of sent message 2060 * @returns #FALSE on out-of-memory 2061 */ 2062 dbus_bool_t 2063 _dbus_connection_send_and_unlock (DBusConnection *connection, 2064 DBusMessage *message, 2065 dbus_uint32_t *client_serial) 2066 { 2067 DBusPreallocatedSend *preallocated; 2068 2069 _dbus_assert (connection != NULL); 2070 _dbus_assert (message != NULL); 2071 2072 preallocated = _dbus_connection_preallocate_send_unlocked (connection); 2073 if (preallocated == NULL) 2074 { 2075 CONNECTION_UNLOCK (connection); 2076 return FALSE; 2077 } 2078 2079 _dbus_connection_send_preallocated_and_unlock (connection, 2080 preallocated, 2081 message, 2082 client_serial); 2083 return TRUE; 2084 } 2085 2086 /** 2087 * Used internally to handle the semantics of dbus_server_set_new_connection_function(). 2088 * If the new connection function does not ref the connection, we want to close it. 2089 * 2090 * A bit of a hack, probably the new connection function should have returned a value 2091 * for whether to close, or should have had to close the connection itself if it 2092 * didn't want it. 2093 * 2094 * But, this works OK as long as the new connection function doesn't do anything 2095 * crazy like keep the connection around without ref'ing it. 2096 * 2097 * We have to lock the connection across refcount check and close in case 2098 * the new connection function spawns a thread that closes and unrefs. 2099 * In that case, if the app thread 2100 * closes and unrefs first, we'll harmlessly close again; if the app thread 2101 * still has the ref, we'll close and then the app will close harmlessly. 2102 * If the app unrefs without closing, the app is broken since if the 2103 * app refs from the new connection function it is supposed to also close. 2104 * 2105 * If we didn't atomically check the refcount and close with the lock held 2106 * though, we could screw this up. 2107 * 2108 * @param connection the connection 2109 */ 2110 void 2111 _dbus_connection_close_if_only_one_ref (DBusConnection *connection) 2112 { 2113 dbus_int32_t tmp_refcount; 2114 2115 CONNECTION_LOCK (connection); 2116 2117 /* We increment and then decrement the refcount, because there is no 2118 * _dbus_atomic_get (mirroring the fact that there's no InterlockedGet 2119 * on Windows). */ 2120 _dbus_atomic_inc (&connection->refcount); 2121 tmp_refcount = _dbus_atomic_dec (&connection->refcount); 2122 2123 /* The caller should have one ref, and this function temporarily took 2124 * one more, which is reflected in this count even though we already 2125 * released it (relying on the caller's ref) due to _dbus_atomic_dec 2126 * semantics */ 2127 _dbus_assert (tmp_refcount >= 2); 2128 2129 if (tmp_refcount == 2) 2130 _dbus_connection_close_possibly_shared_and_unlock (connection); 2131 else 2132 CONNECTION_UNLOCK (connection); 2133 } 2134 2135 2136 /** 2137 * When a function that blocks has been called with a timeout, and we 2138 * run out of memory, the time to wait for memory is based on the 2139 * timeout. If the caller was willing to block a long time we wait a 2140 * relatively long time for memory, if they were only willing to block 2141 * briefly then we retry for memory at a rapid rate. 2142 * 2143 * @timeout_milliseconds the timeout requested for blocking 2144 */ 2145 static void 2146 _dbus_memory_pause_based_on_timeout (int timeout_milliseconds) 2147 { 2148 if (timeout_milliseconds == -1) 2149 _dbus_sleep_milliseconds (1000); 2150 else if (timeout_milliseconds < 100) 2151 ; /* just busy loop */ 2152 else if (timeout_milliseconds <= 1000) 2153 _dbus_sleep_milliseconds (timeout_milliseconds / 3); 2154 else 2155 _dbus_sleep_milliseconds (1000); 2156 } 2157 2158 static DBusMessage * 2159 generate_local_error_message (dbus_uint32_t serial, 2160 char *error_name, 2161 char *error_msg) 2162 { 2163 DBusMessage *message; 2164 message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR); 2165 if (!message) 2166 goto out; 2167 2168 if (!dbus_message_set_error_name (message, error_name)) 2169 { 2170 dbus_message_unref (message); 2171 message = NULL; 2172 goto out; 2173 } 2174 2175 dbus_message_set_no_reply (message, TRUE); 2176 2177 if (!dbus_message_set_reply_serial (message, 2178 serial)) 2179 { 2180 dbus_message_unref (message); 2181 message = NULL; 2182 goto out; 2183 } 2184 2185 if (error_msg != NULL) 2186 { 2187 DBusMessageIter iter; 2188 2189 dbus_message_iter_init_append (message, &iter); 2190 if (!dbus_message_iter_append_basic (&iter, 2191 DBUS_TYPE_STRING, 2192 &error_msg)) 2193 { 2194 dbus_message_unref (message); 2195 message = NULL; 2196 goto out; 2197 } 2198 } 2199 2200 out: 2201 return message; 2202 } 2203 2204 /* 2205 * Peek the incoming queue to see if we got reply for a specific serial 2206 */ 2207 static dbus_bool_t 2208 _dbus_connection_peek_for_reply_unlocked (DBusConnection *connection, 2209 dbus_uint32_t client_serial) 2210 { 2211 DBusList *link; 2212 HAVE_LOCK_CHECK (connection); 2213 2214 link = _dbus_list_get_first_link (&connection->incoming_messages); 2215 2216 while (link != NULL) 2217 { 2218 DBusMessage *reply = link->data; 2219 2220 if (dbus_message_get_reply_serial (reply) == client_serial) 2221 { 2222 _dbus_verbose ("%s reply to %d found in queue\n", _DBUS_FUNCTION_NAME, client_serial); 2223 return TRUE; 2224 } 2225 link = _dbus_list_get_next_link (&connection->incoming_messages, link); 2226 } 2227 2228 return FALSE; 2229 } 2230 2231 /* This is slightly strange since we can pop a message here without 2232 * the dispatch lock. 2233 */ 2234 static DBusMessage* 2235 check_for_reply_unlocked (DBusConnection *connection, 2236 dbus_uint32_t client_serial) 2237 { 2238 DBusList *link; 2239 2240 HAVE_LOCK_CHECK (connection); 2241 2242 link = _dbus_list_get_first_link (&connection->incoming_messages); 2243 2244 while (link != NULL) 2245 { 2246 DBusMessage *reply = link->data; 2247 2248 if (dbus_message_get_reply_serial (reply) == client_serial) 2249 { 2250 _dbus_list_remove_link (&connection->incoming_messages, link); 2251 connection->n_incoming -= 1; 2252 return reply; 2253 } 2254 link = _dbus_list_get_next_link (&connection->incoming_messages, link); 2255 } 2256 2257 return NULL; 2258 } 2259 2260 static void 2261 connection_timeout_and_complete_all_pending_calls_unlocked (DBusConnection *connection) 2262 { 2263 /* We can't iterate over the hash in the normal way since we'll be 2264 * dropping the lock for each item. So we restart the 2265 * iter each time as we drain the hash table. 2266 */ 2267 2268 while (_dbus_hash_table_get_n_entries (connection->pending_replies) > 0) 2269 { 2270 DBusPendingCall *pending; 2271 DBusHashIter iter; 2272 2273 _dbus_hash_iter_init (connection->pending_replies, &iter); 2274 _dbus_hash_iter_next (&iter); 2275 2276 pending = _dbus_hash_iter_get_value (&iter); 2277 _dbus_pending_call_ref_unlocked (pending); 2278 2279 _dbus_pending_call_queue_timeout_error_unlocked (pending, 2280 connection); 2281 2282 if (_dbus_pending_call_is_timeout_added_unlocked (pending)) 2283 _dbus_connection_remove_timeout_unlocked (connection, 2284 _dbus_pending_call_get_timeout_unlocked (pending)); 2285 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 2286 _dbus_hash_iter_remove_entry (&iter); 2287 2288 _dbus_pending_call_unref_and_unlock (pending); 2289 CONNECTION_LOCK (connection); 2290 } 2291 HAVE_LOCK_CHECK (connection); 2292 } 2293 2294 static void 2295 complete_pending_call_and_unlock (DBusConnection *connection, 2296 DBusPendingCall *pending, 2297 DBusMessage *message) 2298 { 2299 _dbus_pending_call_set_reply_unlocked (pending, message); 2300 _dbus_pending_call_ref_unlocked (pending); /* in case there's no app with a ref held */ 2301 _dbus_connection_detach_pending_call_and_unlock (connection, pending); 2302 2303 /* Must be called unlocked since it invokes app callback */ 2304 _dbus_pending_call_complete (pending); 2305 dbus_pending_call_unref (pending); 2306 } 2307 2308 static dbus_bool_t 2309 check_for_reply_and_update_dispatch_unlocked (DBusConnection *connection, 2310 DBusPendingCall *pending) 2311 { 2312 DBusMessage *reply; 2313 DBusDispatchStatus status; 2314 2315 reply = check_for_reply_unlocked (connection, 2316 _dbus_pending_call_get_reply_serial_unlocked (pending)); 2317 if (reply != NULL) 2318 { 2319 _dbus_verbose ("checked for reply\n"); 2320 2321 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): got reply\n"); 2322 2323 complete_pending_call_and_unlock (connection, pending, reply); 2324 dbus_message_unref (reply); 2325 2326 CONNECTION_LOCK (connection); 2327 status = _dbus_connection_get_dispatch_status_unlocked (connection); 2328 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 2329 dbus_pending_call_unref (pending); 2330 2331 return TRUE; 2332 } 2333 2334 return FALSE; 2335 } 2336 2337 /** 2338 * Blocks until a pending call times out or gets a reply. 2339 * 2340 * Does not re-enter the main loop or run filter/path-registered 2341 * callbacks. The reply to the message will not be seen by 2342 * filter callbacks. 2343 * 2344 * Returns immediately if pending call already got a reply. 2345 * 2346 * @todo could use performance improvements (it keeps scanning 2347 * the whole message queue for example) 2348 * 2349 * @param pending the pending call we block for a reply on 2350 */ 2351 void 2352 _dbus_connection_block_pending_call (DBusPendingCall *pending) 2353 { 2354 long start_tv_sec, start_tv_usec; 2355 long tv_sec, tv_usec; 2356 DBusDispatchStatus status; 2357 DBusConnection *connection; 2358 dbus_uint32_t client_serial; 2359 DBusTimeout *timeout; 2360 int timeout_milliseconds, elapsed_milliseconds; 2361 2362 _dbus_assert (pending != NULL); 2363 2364 if (dbus_pending_call_get_completed (pending)) 2365 return; 2366 2367 dbus_pending_call_ref (pending); /* necessary because the call could be canceled */ 2368 2369 connection = _dbus_pending_call_get_connection_and_lock (pending); 2370 2371 /* Flush message queue - note, can affect dispatch status */ 2372 _dbus_connection_flush_unlocked (connection); 2373 2374 client_serial = _dbus_pending_call_get_reply_serial_unlocked (pending); 2375 2376 /* note that timeout_milliseconds is limited to a smallish value 2377 * in _dbus_pending_call_new() so overflows aren't possible 2378 * below 2379 */ 2380 timeout = _dbus_pending_call_get_timeout_unlocked (pending); 2381 if (timeout) 2382 { 2383 timeout_milliseconds = dbus_timeout_get_interval (timeout); 2384 _dbus_get_current_time (&start_tv_sec, &start_tv_usec); 2385 2386 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block %d milliseconds for reply serial %u from %ld sec %ld usec\n", 2387 timeout_milliseconds, 2388 client_serial, 2389 start_tv_sec, start_tv_usec); 2390 } 2391 else 2392 { 2393 timeout_milliseconds = -1; 2394 2395 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block for reply serial %u\n", client_serial); 2396 } 2397 2398 /* check to see if we already got the data off the socket */ 2399 /* from another blocked pending call */ 2400 if (check_for_reply_and_update_dispatch_unlocked (connection, pending)) 2401 return; 2402 2403 /* Now we wait... */ 2404 /* always block at least once as we know we don't have the reply yet */ 2405 _dbus_connection_do_iteration_unlocked (connection, 2406 pending, 2407 DBUS_ITERATION_DO_READING | 2408 DBUS_ITERATION_BLOCK, 2409 timeout_milliseconds); 2410 2411 recheck_status: 2412 2413 _dbus_verbose ("top of recheck\n"); 2414 2415 HAVE_LOCK_CHECK (connection); 2416 2417 /* queue messages and get status */ 2418 2419 status = _dbus_connection_get_dispatch_status_unlocked (connection); 2420 2421 /* the get_completed() is in case a dispatch() while we were blocking 2422 * got the reply instead of us. 2423 */ 2424 if (_dbus_pending_call_get_completed_unlocked (pending)) 2425 { 2426 _dbus_verbose ("Pending call completed by dispatch\n"); 2427 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 2428 dbus_pending_call_unref (pending); 2429 return; 2430 } 2431 2432 if (status == DBUS_DISPATCH_DATA_REMAINS) 2433 { 2434 if (check_for_reply_and_update_dispatch_unlocked (connection, pending)) 2435 return; 2436 } 2437 2438 _dbus_get_current_time (&tv_sec, &tv_usec); 2439 elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 + 2440 (tv_usec - start_tv_usec) / 1000; 2441 2442 if (!_dbus_connection_get_is_connected_unlocked (connection)) 2443 { 2444 DBusMessage *error_msg; 2445 2446 error_msg = generate_local_error_message (client_serial, 2447 DBUS_ERROR_DISCONNECTED, 2448 "Connection was disconnected before a reply was received"); 2449 2450 /* on OOM error_msg is set to NULL */ 2451 complete_pending_call_and_unlock (connection, pending, error_msg); 2452 dbus_pending_call_unref (pending); 2453 return; 2454 } 2455 else if (connection->disconnect_message_link == NULL) 2456 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): disconnected\n"); 2457 else if (timeout == NULL) 2458 { 2459 if (status == DBUS_DISPATCH_NEED_MEMORY) 2460 { 2461 /* Try sleeping a bit, as we aren't sure we need to block for reading, 2462 * we may already have a reply in the buffer and just can't process 2463 * it. 2464 */ 2465 _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n"); 2466 2467 _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds); 2468 } 2469 else 2470 { 2471 /* block again, we don't have the reply buffered yet. */ 2472 _dbus_connection_do_iteration_unlocked (connection, 2473 pending, 2474 DBUS_ITERATION_DO_READING | 2475 DBUS_ITERATION_BLOCK, 2476 timeout_milliseconds - elapsed_milliseconds); 2477 } 2478 2479 goto recheck_status; 2480 } 2481 else if (tv_sec < start_tv_sec) 2482 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): clock set backward\n"); 2483 else if (elapsed_milliseconds < timeout_milliseconds) 2484 { 2485 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): %d milliseconds remain\n", timeout_milliseconds - elapsed_milliseconds); 2486 2487 if (status == DBUS_DISPATCH_NEED_MEMORY) 2488 { 2489 /* Try sleeping a bit, as we aren't sure we need to block for reading, 2490 * we may already have a reply in the buffer and just can't process 2491 * it. 2492 */ 2493 _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n"); 2494 2495 _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds); 2496 } 2497 else 2498 { 2499 /* block again, we don't have the reply buffered yet. */ 2500 _dbus_connection_do_iteration_unlocked (connection, 2501 NULL, 2502 DBUS_ITERATION_DO_READING | 2503 DBUS_ITERATION_BLOCK, 2504 timeout_milliseconds - elapsed_milliseconds); 2505 } 2506 2507 goto recheck_status; 2508 } 2509 2510 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): Waited %d milliseconds and got no reply\n", 2511 elapsed_milliseconds); 2512 2513 _dbus_assert (!_dbus_pending_call_get_completed_unlocked (pending)); 2514 2515 /* unlock and call user code */ 2516 complete_pending_call_and_unlock (connection, pending, NULL); 2517 2518 /* update user code on dispatch status */ 2519 CONNECTION_LOCK (connection); 2520 status = _dbus_connection_get_dispatch_status_unlocked (connection); 2521 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 2522 dbus_pending_call_unref (pending); 2523 } 2524 2525 /** @} */ 2526 2527 /** 2528 * @addtogroup DBusConnection 2529 * 2530 * @{ 2531 */ 2532 2533 /** 2534 * Gets a connection to a remote address. If a connection to the given 2535 * address already exists, returns the existing connection with its 2536 * reference count incremented. Otherwise, returns a new connection 2537 * and saves the new connection for possible re-use if a future call 2538 * to dbus_connection_open() asks to connect to the same server. 2539 * 2540 * Use dbus_connection_open_private() to get a dedicated connection 2541 * not shared with other callers of dbus_connection_open(). 2542 * 2543 * If the open fails, the function returns #NULL, and provides a 2544 * reason for the failure in the error parameter. Pass #NULL for the 2545 * error parameter if you aren't interested in the reason for 2546 * failure. 2547 * 2548 * Because this connection is shared, no user of the connection 2549 * may call dbus_connection_close(). However, when you are done with the 2550 * connection you should call dbus_connection_unref(). 2551 * 2552 * @note Prefer dbus_connection_open() to dbus_connection_open_private() 2553 * unless you have good reason; connections are expensive enough 2554 * that it's wasteful to create lots of connections to the same 2555 * server. 2556 * 2557 * @param address the address. 2558 * @param error address where an error can be returned. 2559 * @returns new connection, or #NULL on failure. 2560 */ 2561 DBusConnection* 2562 dbus_connection_open (const char *address, 2563 DBusError *error) 2564 { 2565 DBusConnection *connection; 2566 2567 _dbus_return_val_if_fail (address != NULL, NULL); 2568 _dbus_return_val_if_error_is_set (error, NULL); 2569 2570 connection = _dbus_connection_open_internal (address, 2571 TRUE, 2572 error); 2573 2574 return connection; 2575 } 2576 2577 /** 2578 * Opens a new, dedicated connection to a remote address. Unlike 2579 * dbus_connection_open(), always creates a new connection. 2580 * This connection will not be saved or recycled by libdbus. 2581 * 2582 * If the open fails, the function returns #NULL, and provides a 2583 * reason for the failure in the error parameter. Pass #NULL for the 2584 * error parameter if you aren't interested in the reason for 2585 * failure. 2586 * 2587 * When you are done with this connection, you must 2588 * dbus_connection_close() to disconnect it, 2589 * and dbus_connection_unref() to free the connection object. 2590 * 2591 * (The dbus_connection_close() can be skipped if the 2592 * connection is already known to be disconnected, for example 2593 * if you are inside a handler for the Disconnected signal.) 2594 * 2595 * @note Prefer dbus_connection_open() to dbus_connection_open_private() 2596 * unless you have good reason; connections are expensive enough 2597 * that it's wasteful to create lots of connections to the same 2598 * server. 2599 * 2600 * @param address the address. 2601 * @param error address where an error can be returned. 2602 * @returns new connection, or #NULL on failure. 2603 */ 2604 DBusConnection* 2605 dbus_connection_open_private (const char *address, 2606 DBusError *error) 2607 { 2608 DBusConnection *connection; 2609 2610 _dbus_return_val_if_fail (address != NULL, NULL); 2611 _dbus_return_val_if_error_is_set (error, NULL); 2612 2613 connection = _dbus_connection_open_internal (address, 2614 FALSE, 2615 error); 2616 2617 return connection; 2618 } 2619 2620 /** 2621 * Increments the reference count of a DBusConnection. 2622 * 2623 * @param connection the connection. 2624 * @returns the connection. 2625 */ 2626 DBusConnection * 2627 dbus_connection_ref (DBusConnection *connection) 2628 { 2629 _dbus_return_val_if_fail (connection != NULL, NULL); 2630 _dbus_return_val_if_fail (connection->generation == _dbus_current_generation, NULL); 2631 2632 _dbus_atomic_inc (&connection->refcount); 2633 2634 return connection; 2635 } 2636 2637 static void 2638 free_outgoing_message (void *element, 2639 void *data) 2640 { 2641 DBusMessage *message = element; 2642 DBusConnection *connection = data; 2643 2644 _dbus_message_remove_counter (message, 2645 connection->outgoing_counter, 2646 NULL); 2647 dbus_message_unref (message); 2648 } 2649 2650 /* This is run without the mutex held, but after the last reference 2651 * to the connection has been dropped we should have no thread-related 2652 * problems 2653 */ 2654 static void 2655 _dbus_connection_last_unref (DBusConnection *connection) 2656 { 2657 DBusList *link; 2658 2659 _dbus_verbose ("Finalizing connection %p\n", connection); 2660 2661 _dbus_assert (connection->refcount.value == 0); 2662 2663 /* You have to disconnect the connection before unref:ing it. Otherwise 2664 * you won't get the disconnected message. 2665 */ 2666 _dbus_assert (!_dbus_transport_get_is_connected (connection->transport)); 2667 _dbus_assert (connection->server_guid == NULL); 2668 2669 /* ---- We're going to call various application callbacks here, hope it doesn't break anything... */ 2670 _dbus_object_tree_free_all_unlocked (connection->objects); 2671 2672 dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL); 2673 dbus_connection_set_wakeup_main_function (connection, NULL, NULL, NULL); 2674 dbus_connection_set_unix_user_function (connection, NULL, NULL, NULL); 2675 2676 _dbus_watch_list_free (connection->watches); 2677 connection->watches = NULL; 2678 2679 _dbus_timeout_list_free (connection->timeouts); 2680 connection->timeouts = NULL; 2681 2682 _dbus_data_slot_list_free (&connection->slot_list); 2683 2684 link = _dbus_list_get_first_link (&connection->filter_list); 2685 while (link != NULL) 2686 { 2687 DBusMessageFilter *filter = link->data; 2688 DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link); 2689 2690 filter->function = NULL; 2691 _dbus_message_filter_unref (filter); /* calls app callback */ 2692 link->data = NULL; 2693 2694 link = next; 2695 } 2696 _dbus_list_clear (&connection->filter_list); 2697 2698 /* ---- Done with stuff that invokes application callbacks */ 2699 2700 _dbus_object_tree_unref (connection->objects); 2701 2702 _dbus_hash_table_unref (connection->pending_replies); 2703 connection->pending_replies = NULL; 2704 2705 _dbus_list_clear (&connection->filter_list); 2706 2707 _dbus_list_foreach (&connection->outgoing_messages, 2708 free_outgoing_message, 2709 connection); 2710 _dbus_list_clear (&connection->outgoing_messages); 2711 2712 _dbus_list_foreach (&connection->incoming_messages, 2713 (DBusForeachFunction) dbus_message_unref, 2714 NULL); 2715 _dbus_list_clear (&connection->incoming_messages); 2716 2717 _dbus_counter_unref (connection->outgoing_counter); 2718 2719 _dbus_transport_unref (connection->transport); 2720 2721 if (connection->disconnect_message_link) 2722 { 2723 DBusMessage *message = connection->disconnect_message_link->data; 2724 dbus_message_unref (message); 2725 _dbus_list_free_link (connection->disconnect_message_link); 2726 } 2727 2728 _dbus_list_clear (&connection->link_cache); 2729 2730 _dbus_condvar_free_at_location (&connection->dispatch_cond); 2731 _dbus_condvar_free_at_location (&connection->io_path_cond); 2732 2733 _dbus_mutex_free_at_location (&connection->io_path_mutex); 2734 _dbus_mutex_free_at_location (&connection->dispatch_mutex); 2735 2736 _dbus_mutex_free_at_location (&connection->slot_mutex); 2737 2738 _dbus_mutex_free_at_location (&connection->mutex); 2739 2740 dbus_free (connection); 2741 } 2742 2743 /** 2744 * Decrements the reference count of a DBusConnection, and finalizes 2745 * it if the count reaches zero. 2746 * 2747 * Note: it is a bug to drop the last reference to a connection that 2748 * is still connected. 2749 * 2750 * For shared connections, libdbus will own a reference 2751 * as long as the connection is connected, so you can know that either 2752 * you don't have the last reference, or it's OK to drop the last reference. 2753 * Most connections are shared. dbus_connection_open() and dbus_bus_get() 2754 * return shared connections. 2755 * 2756 * For private connections, the creator of the connection must arrange for 2757 * dbus_connection_close() to be called prior to dropping the last reference. 2758 * Private connections come from dbus_connection_open_private() or dbus_bus_get_private(). 2759 * 2760 * @param connection the connection. 2761 */ 2762 void 2763 dbus_connection_unref (DBusConnection *connection) 2764 { 2765 dbus_bool_t last_unref; 2766 2767 _dbus_return_if_fail (connection != NULL); 2768 _dbus_return_if_fail (connection->generation == _dbus_current_generation); 2769 2770 last_unref = (_dbus_atomic_dec (&connection->refcount) == 1); 2771 2772 if (last_unref) 2773 { 2774 #ifndef DBUS_DISABLE_CHECKS 2775 if (_dbus_transport_get_is_connected (connection->transport)) 2776 { 2777 _dbus_warn_check_failed ("The last reference on a connection was dropped without closing the connection. This is a bug in an application. See dbus_connection_unref() documentation for details.\n%s", 2778 connection->shareable ? 2779 "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection.\n" : 2780 "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.\n"); 2781 return; 2782 } 2783 #endif 2784 _dbus_connection_last_unref (connection); 2785 } 2786 } 2787 2788 /* 2789 * Note that the transport can disconnect itself (other end drops us) 2790 * and in that case this function never runs. So this function must 2791 * not do anything more than disconnect the transport and update the 2792 * dispatch status. 2793 * 2794 * If the transport self-disconnects, then we assume someone will 2795 * dispatch the connection to cause the dispatch status update. 2796 */ 2797 static void 2798 _dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection) 2799 { 2800 DBusDispatchStatus status; 2801 2802 HAVE_LOCK_CHECK (connection); 2803 2804 _dbus_verbose ("Disconnecting %p\n", connection); 2805 2806 /* We need to ref because update_dispatch_status_and_unlock will unref 2807 * the connection if it was shared and libdbus was the only remaining 2808 * refcount holder. 2809 */ 2810 _dbus_connection_ref_unlocked (connection); 2811 2812 _dbus_transport_disconnect (connection->transport); 2813 2814 /* This has the side effect of queuing the disconnect message link 2815 * (unless we don't have enough memory, possibly, so don't assert it). 2816 * After the disconnect message link is queued, dbus_bus_get/dbus_connection_open 2817 * should never again return the newly-disconnected connection. 2818 * 2819 * However, we only unref the shared connection and exit_on_disconnect when 2820 * the disconnect message reaches the head of the message queue, 2821 * NOT when it's first queued. 2822 */ 2823 status = _dbus_connection_get_dispatch_status_unlocked (connection); 2824 2825 /* This calls out to user code */ 2826 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 2827 2828 /* Could also call out to user code */ 2829 dbus_connection_unref (connection); 2830 } 2831 2832 /** 2833 * Closes a private connection, so no further data can be sent or received. 2834 * This disconnects the transport (such as a socket) underlying the 2835 * connection. 2836 * 2837 * Attempts to send messages after closing a connection are safe, but will result in 2838 * error replies generated locally in libdbus. 2839 * 2840 * This function does not affect the connection's reference count. It's 2841 * safe to close a connection more than once; all calls after the 2842 * first do nothing. It's impossible to "reopen" a connection, a 2843 * new connection must be created. This function may result in a call 2844 * to the DBusDispatchStatusFunction set with 2845 * dbus_connection_set_dispatch_status_function(), as the disconnect 2846 * message it generates needs to be dispatched. 2847 * 2848 * If a connection is dropped by the remote application, it will 2849 * close itself. 2850 * 2851 * You must close a connection prior to releasing the last reference to 2852 * the connection. If you dbus_connection_unref() for the last time 2853 * without closing the connection, the results are undefined; it 2854 * is a bug in your program and libdbus will try to print a warning. 2855 * 2856 * You may not close a shared connection. Connections created with 2857 * dbus_connection_open() or dbus_bus_get() are shared. 2858 * These connections are owned by libdbus, and applications should 2859 * only unref them, never close them. Applications can know it is 2860 * safe to unref these connections because libdbus will be holding a 2861 * reference as long as the connection is open. Thus, either the 2862 * connection is closed and it is OK to drop the last reference, 2863 * or the connection is open and the app knows it does not have the 2864 * last reference. 2865 * 2866 * Connections created with dbus_connection_open_private() or 2867 * dbus_bus_get_private() are not kept track of or referenced by 2868 * libdbus. The creator of these connections is responsible for 2869 * calling dbus_connection_close() prior to releasing the last 2870 * reference, if the connection is not already disconnected. 2871 * 2872 * @param connection the private (unshared) connection to close 2873 */ 2874 void 2875 dbus_connection_close (DBusConnection *connection) 2876 { 2877 _dbus_return_if_fail (connection != NULL); 2878 _dbus_return_if_fail (connection->generation == _dbus_current_generation); 2879 2880 CONNECTION_LOCK (connection); 2881 2882 #ifndef DBUS_DISABLE_CHECKS 2883 if (connection->shareable) 2884 { 2885 CONNECTION_UNLOCK (connection); 2886 2887 _dbus_warn_check_failed ("Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.\n"); 2888 return; 2889 } 2890 #endif 2891 2892 _dbus_connection_close_possibly_shared_and_unlock (connection); 2893 } 2894 2895 static dbus_bool_t 2896 _dbus_connection_get_is_connected_unlocked (DBusConnection *connection) 2897 { 2898 HAVE_LOCK_CHECK (connection); 2899 return _dbus_transport_get_is_connected (connection->transport); 2900 } 2901 2902 /** 2903 * Gets whether the connection is currently open. A connection may 2904 * become disconnected when the remote application closes its end, or 2905 * exits; a connection may also be disconnected with 2906 * dbus_connection_close(). 2907 * 2908 * There are not separate states for "closed" and "disconnected," the two 2909 * terms are synonymous. This function should really be called 2910 * get_is_open() but for historical reasons is not. 2911 * 2912 * @param connection the connection. 2913 * @returns #TRUE if the connection is still alive. 2914 */ 2915 dbus_bool_t 2916 dbus_connection_get_is_connected (DBusConnection *connection) 2917 { 2918 dbus_bool_t res; 2919 2920 _dbus_return_val_if_fail (connection != NULL, FALSE); 2921 2922 CONNECTION_LOCK (connection); 2923 res = _dbus_connection_get_is_connected_unlocked (connection); 2924 CONNECTION_UNLOCK (connection); 2925 2926 return res; 2927 } 2928 2929 /** 2930 * Gets whether the connection was authenticated. (Note that 2931 * if the connection was authenticated then disconnected, 2932 * this function still returns #TRUE) 2933 * 2934 * @param connection the connection 2935 * @returns #TRUE if the connection was ever authenticated 2936 */ 2937 dbus_bool_t 2938 dbus_connection_get_is_authenticated (DBusConnection *connection) 2939 { 2940 dbus_bool_t res; 2941 2942 _dbus_return_val_if_fail (connection != NULL, FALSE); 2943 2944 CONNECTION_LOCK (connection); 2945 res = _dbus_transport_get_is_authenticated (connection->transport); 2946 CONNECTION_UNLOCK (connection); 2947 2948 return res; 2949 } 2950 2951 /** 2952 * Gets whether the connection is not authenticated as a specific 2953 * user. If the connection is not authenticated, this function 2954 * returns #TRUE, and if it is authenticated but as an anonymous user, 2955 * it returns #TRUE. If it is authenticated as a specific user, then 2956 * this returns #FALSE. (Note that if the connection was authenticated 2957 * as anonymous then disconnected, this function still returns #TRUE.) 2958 * 2959 * If the connection is not anonymous, you can use 2960 * dbus_connection_get_unix_user() and 2961 * dbus_connection_get_windows_user() to see who it's authorized as. 2962 * 2963 * If you want to prevent non-anonymous authorization, use 2964 * dbus_server_set_auth_mechanisms() to remove the mechanisms that 2965 * allow proving user identity (i.e. only allow the ANONYMOUS 2966 * mechanism). 2967 * 2968 * @param connection the connection 2969 * @returns #TRUE if not authenticated or authenticated as anonymous 2970 */ 2971 dbus_bool_t 2972 dbus_connection_get_is_anonymous (DBusConnection *connection) 2973 { 2974 dbus_bool_t res; 2975 2976 _dbus_return_val_if_fail (connection != NULL, FALSE); 2977 2978 CONNECTION_LOCK (connection); 2979 res = _dbus_transport_get_is_anonymous (connection->transport); 2980 CONNECTION_UNLOCK (connection); 2981 2982 return res; 2983 } 2984 2985 /** 2986 * Gets the ID of the server address we are authenticated to, if this 2987 * connection is on the client side. If the connection is on the 2988 * server side, this will always return #NULL - use dbus_server_get_id() 2989 * to get the ID of your own server, if you are the server side. 2990 * 2991 * If a client-side connection is not authenticated yet, the ID may be 2992 * available if it was included in the server address, but may not be 2993 * available. The only way to be sure the server ID is available 2994 * is to wait for authentication to complete. 2995 * 2996 * In general, each mode of connecting to a given server will have 2997 * its own ID. So for example, if the session bus daemon is listening 2998 * on UNIX domain sockets and on TCP, then each of those modalities 2999 * will have its own server ID. 3000 * 3001 * If you want an ID that identifies an entire session bus, look at 3002 * dbus_bus_get_id() instead (which is just a convenience wrapper 3003 * around the org.freedesktop.DBus.GetId method invoked on the bus). 3004 * 3005 * You can also get a machine ID; see dbus_get_local_machine_id() to 3006 * get the machine you are on. There isn't a convenience wrapper, but 3007 * you can invoke org.freedesktop.DBus.Peer.GetMachineId on any peer 3008 * to get the machine ID on the other end. 3009 * 3010 * The D-Bus specification describes the server ID and other IDs in a 3011 * bit more detail. 3012 * 3013 * @param connection the connection 3014 * @returns the server ID or #NULL if no memory or the connection is server-side 3015 */ 3016 char* 3017 dbus_connection_get_server_id (DBusConnection *connection) 3018 { 3019 char *id; 3020 3021 _dbus_return_val_if_fail (connection != NULL, NULL); 3022 3023 CONNECTION_LOCK (connection); 3024 id = _dbus_strdup (_dbus_transport_get_server_id (connection->transport)); 3025 CONNECTION_UNLOCK (connection); 3026 3027 return id; 3028 } 3029 3030 /** 3031 * Tests whether a certain type can be send via the connection. This 3032 * will always return TRUE for all types, with the exception of 3033 * DBUS_TYPE_UNIX_FD. The function will return TRUE for 3034 * DBUS_TYPE_UNIX_FD only on systems that know Unix file descriptors 3035 * and can send them via the chosen transport and when the remote side 3036 * supports this. 3037 * 3038 * This function can be used to do runtime checking for types that 3039 * might be unknown to the specific D-Bus client implementation 3040 * version, i.e. it will return FALSE for all types this 3041 * implementation does not know. 3042 * 3043 * @param connection the connection 3044 * @param type the type to check 3045 * @returns TRUE if the type may be send via the connection 3046 */ 3047 dbus_bool_t 3048 dbus_connection_can_send_type(DBusConnection *connection, 3049 int type) 3050 { 3051 _dbus_return_val_if_fail (connection != NULL, FALSE); 3052 3053 if (!_dbus_type_is_valid(type)) 3054 return FALSE; 3055 3056 if (type != DBUS_TYPE_UNIX_FD) 3057 return TRUE; 3058 3059 #ifdef HAVE_UNIX_FD_PASSING 3060 { 3061 dbus_bool_t b; 3062 3063 CONNECTION_LOCK(connection); 3064 b = _dbus_transport_can_pass_unix_fd(connection->transport); 3065 CONNECTION_UNLOCK(connection); 3066 3067 return b; 3068 } 3069 #endif 3070 3071 return FALSE; 3072 } 3073 3074 /** 3075 * Set whether _exit() should be called when the connection receives a 3076 * disconnect signal. The call to _exit() comes after any handlers for 3077 * the disconnect signal run; handlers can cancel the exit by calling 3078 * this function. 3079 * 3080 * By default, exit_on_disconnect is #FALSE; but for message bus 3081 * connections returned from dbus_bus_get() it will be toggled on 3082 * by default. 3083 * 3084 * @param connection the connection 3085 * @param exit_on_disconnect #TRUE if _exit() should be called after a disconnect signal 3086 */ 3087 void 3088 dbus_connection_set_exit_on_disconnect (DBusConnection *connection, 3089 dbus_bool_t exit_on_disconnect) 3090 { 3091 _dbus_return_if_fail (connection != NULL); 3092 3093 CONNECTION_LOCK (connection); 3094 connection->exit_on_disconnect = exit_on_disconnect != FALSE; 3095 CONNECTION_UNLOCK (connection); 3096 } 3097 3098 /** 3099 * Preallocates resources needed to send a message, allowing the message 3100 * to be sent without the possibility of memory allocation failure. 3101 * Allows apps to create a future guarantee that they can send 3102 * a message regardless of memory shortages. 3103 * 3104 * @param connection the connection we're preallocating for. 3105 * @returns the preallocated resources, or #NULL 3106 */ 3107 DBusPreallocatedSend* 3108 dbus_connection_preallocate_send (DBusConnection *connection) 3109 { 3110 DBusPreallocatedSend *preallocated; 3111 3112 _dbus_return_val_if_fail (connection != NULL, NULL); 3113 3114 CONNECTION_LOCK (connection); 3115 3116 preallocated = 3117 _dbus_connection_preallocate_send_unlocked (connection); 3118 3119 CONNECTION_UNLOCK (connection); 3120 3121 return preallocated; 3122 } 3123 3124 /** 3125 * Frees preallocated message-sending resources from 3126 * dbus_connection_preallocate_send(). Should only 3127 * be called if the preallocated resources are not used 3128 * to send a message. 3129 * 3130 * @param connection the connection 3131 * @param preallocated the resources 3132 */ 3133 void 3134 dbus_connection_free_preallocated_send (DBusConnection *connection, 3135 DBusPreallocatedSend *preallocated) 3136 { 3137 _dbus_return_if_fail (connection != NULL); 3138 _dbus_return_if_fail (preallocated != NULL); 3139 _dbus_return_if_fail (connection == preallocated->connection); 3140 3141 _dbus_list_free_link (preallocated->queue_link); 3142 _dbus_counter_unref (preallocated->counter_link->data); 3143 _dbus_list_free_link (preallocated->counter_link); 3144 dbus_free (preallocated); 3145 } 3146 3147 /** 3148 * Sends a message using preallocated resources. This function cannot fail. 3149 * It works identically to dbus_connection_send() in other respects. 3150 * Preallocated resources comes from dbus_connection_preallocate_send(). 3151 * This function "consumes" the preallocated resources, they need not 3152 * be freed separately. 3153 * 3154 * @param connection the connection 3155 * @param preallocated the preallocated resources 3156 * @param message the message to send 3157 * @param client_serial return location for client serial assigned to the message 3158 */ 3159 void 3160 dbus_connection_send_preallocated (DBusConnection *connection, 3161 DBusPreallocatedSend *preallocated, 3162 DBusMessage *message, 3163 dbus_uint32_t *client_serial) 3164 { 3165 _dbus_return_if_fail (connection != NULL); 3166 _dbus_return_if_fail (preallocated != NULL); 3167 _dbus_return_if_fail (message != NULL); 3168 _dbus_return_if_fail (preallocated->connection == connection); 3169 _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL || 3170 dbus_message_get_member (message) != NULL); 3171 _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL || 3172 (dbus_message_get_interface (message) != NULL && 3173 dbus_message_get_member (message) != NULL)); 3174 3175 CONNECTION_LOCK (connection); 3176 3177 #ifdef HAVE_UNIX_FD_PASSING 3178 3179 if (!_dbus_transport_can_pass_unix_fd(connection->transport) && 3180 message->n_unix_fds > 0) 3181 { 3182 /* Refuse to send fds on a connection that cannot handle 3183 them. Unfortunately we cannot return a proper error here, so 3184 the best we can is just return. */ 3185 CONNECTION_UNLOCK (connection); 3186 return; 3187 } 3188 3189 #endif 3190 3191 _dbus_connection_send_preallocated_and_unlock (connection, 3192 preallocated, 3193 message, client_serial); 3194 } 3195 3196 static dbus_bool_t 3197 _dbus_connection_send_unlocked_no_update (DBusConnection *connection, 3198 DBusMessage *message, 3199 dbus_uint32_t *client_serial) 3200 { 3201 DBusPreallocatedSend *preallocated; 3202 3203 _dbus_assert (connection != NULL); 3204 _dbus_assert (message != NULL); 3205 3206 preallocated = _dbus_connection_preallocate_send_unlocked (connection); 3207 if (preallocated == NULL) 3208 return FALSE; 3209 3210 _dbus_connection_send_preallocated_unlocked_no_update (connection, 3211 preallocated, 3212 message, 3213 client_serial); 3214 return TRUE; 3215 } 3216 3217 /** 3218 * Adds a message to the outgoing message queue. Does not block to 3219 * write the message to the network; that happens asynchronously. To 3220 * force the message to be written, call dbus_connection_flush() however 3221 * it is not necessary to call dbus_connection_flush() by hand; the 3222 * message will be sent the next time the main loop is run. 3223 * dbus_connection_flush() should only be used, for example, if 3224 * the application was expected to exit before running the main loop. 3225 * 3226 * Because this only queues the message, the only reason it can 3227 * fail is lack of memory. Even if the connection is disconnected, 3228 * no error will be returned. If the function fails due to lack of memory, 3229 * it returns #FALSE. The function will never fail for other reasons; even 3230 * if the connection is disconnected, you can queue an outgoing message, 3231 * though obviously it won't be sent. 3232 * 3233 * The message serial is used by the remote application to send a 3234 * reply; see dbus_message_get_serial() or the D-Bus specification. 3235 * 3236 * dbus_message_unref() can be called as soon as this method returns 3237 * as the message queue will hold its own ref until the message is sent. 3238 * 3239 * @param connection the connection. 3240 * @param message the message to write. 3241 * @param serial return location for message serial, or #NULL if you don't care 3242 * @returns #TRUE on success. 3243 */ 3244 dbus_bool_t 3245 dbus_connection_send (DBusConnection *connection, 3246 DBusMessage *message, 3247 dbus_uint32_t *serial) 3248 { 3249 _dbus_return_val_if_fail (connection != NULL, FALSE); 3250 _dbus_return_val_if_fail (message != NULL, FALSE); 3251 3252 CONNECTION_LOCK (connection); 3253 3254 #ifdef HAVE_UNIX_FD_PASSING 3255 3256 if (!_dbus_transport_can_pass_unix_fd(connection->transport) && 3257 message->n_unix_fds > 0) 3258 { 3259 /* Refuse to send fds on a connection that cannot handle 3260 them. Unfortunately we cannot return a proper error here, so 3261 the best we can is just return. */ 3262 CONNECTION_UNLOCK (connection); 3263 return FALSE; 3264 } 3265 3266 #endif 3267 3268 return _dbus_connection_send_and_unlock (connection, 3269 message, 3270 serial); 3271 } 3272 3273 static dbus_bool_t 3274 reply_handler_timeout (void *data) 3275 { 3276 DBusConnection *connection; 3277 DBusDispatchStatus status; 3278 DBusPendingCall *pending = data; 3279 3280 connection = _dbus_pending_call_get_connection_and_lock (pending); 3281 3282 _dbus_pending_call_queue_timeout_error_unlocked (pending, 3283 connection); 3284 _dbus_connection_remove_timeout_unlocked (connection, 3285 _dbus_pending_call_get_timeout_unlocked (pending)); 3286 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE); 3287 3288 _dbus_verbose ("middle\n"); 3289 status = _dbus_connection_get_dispatch_status_unlocked (connection); 3290 3291 /* Unlocks, and calls out to user code */ 3292 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 3293 3294 return TRUE; 3295 } 3296 3297 /** 3298 * Queues a message to send, as with dbus_connection_send(), 3299 * but also returns a #DBusPendingCall used to receive a reply to the 3300 * message. If no reply is received in the given timeout_milliseconds, 3301 * this function expires the pending reply and generates a synthetic 3302 * error reply (generated in-process, not by the remote application) 3303 * indicating that a timeout occurred. 3304 * 3305 * A #DBusPendingCall will see a reply message before any filters or 3306 * registered object path handlers. See dbus_connection_dispatch() for 3307 * details on when handlers are run. 3308 * 3309 * A #DBusPendingCall will always see exactly one reply message, 3310 * unless it's cancelled with dbus_pending_call_cancel(). 3311 * 3312 * If #NULL is passed for the pending_return, the #DBusPendingCall 3313 * will still be generated internally, and used to track 3314 * the message reply timeout. This means a timeout error will 3315 * occur if no reply arrives, unlike with dbus_connection_send(). 3316 * 3317 * If -1 is passed for the timeout, a sane default timeout is used. -1 3318 * is typically the best value for the timeout for this reason, unless 3319 * you want a very short or very long timeout. If INT_MAX is passed for 3320 * the timeout, no timeout will be set and the call will block forever. 3321 * 3322 * @warning if the connection is disconnected or you try to send Unix 3323 * file descriptors on a connection that does not support them, the 3324 * #DBusPendingCall will be set to #NULL, so be careful with this. 3325 * 3326 * @param connection the connection 3327 * @param message the message to send 3328 * @param pending_return return location for a #DBusPendingCall 3329 * object, or #NULL if connection is disconnected or when you try to 3330 * send Unix file descriptors on a connection that does not support 3331 * them. 3332 * @param timeout_milliseconds timeout in milliseconds, -1 for default or INT_MAX for no timeout 3333 * @returns #FALSE if no memory, #TRUE otherwise. 3334 * 3335 */ 3336 dbus_bool_t 3337 dbus_connection_send_with_reply (DBusConnection *connection, 3338 DBusMessage *message, 3339 DBusPendingCall **pending_return, 3340 int timeout_milliseconds) 3341 { 3342 DBusPendingCall *pending; 3343 dbus_int32_t serial = -1; 3344 DBusDispatchStatus status; 3345 3346 _dbus_return_val_if_fail (connection != NULL, FALSE); 3347 _dbus_return_val_if_fail (message != NULL, FALSE); 3348 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE); 3349 3350 if (pending_return) 3351 *pending_return = NULL; 3352 3353 CONNECTION_LOCK (connection); 3354 3355 #ifdef HAVE_UNIX_FD_PASSING 3356 3357 if (!_dbus_transport_can_pass_unix_fd(connection->transport) && 3358 message->n_unix_fds > 0) 3359 { 3360 /* Refuse to send fds on a connection that cannot handle 3361 them. Unfortunately we cannot return a proper error here, so 3362 the best we can do is return TRUE but leave *pending_return 3363 as NULL. */ 3364 CONNECTION_UNLOCK (connection); 3365 return TRUE; 3366 } 3367 3368 #endif 3369 3370 if (!_dbus_connection_get_is_connected_unlocked (connection)) 3371 { 3372 CONNECTION_UNLOCK (connection); 3373 3374 return TRUE; 3375 } 3376 3377 pending = _dbus_pending_call_new_unlocked (connection, 3378 timeout_milliseconds, 3379 reply_handler_timeout); 3380 3381 if (pending == NULL) 3382 { 3383 CONNECTION_UNLOCK (connection); 3384 return FALSE; 3385 } 3386 3387 /* Assign a serial to the message */ 3388 serial = dbus_message_get_serial (message); 3389 if (serial == 0) 3390 { 3391 serial = _dbus_connection_get_next_client_serial (connection); 3392 dbus_message_set_serial (message, serial); 3393 } 3394 3395 if (!_dbus_pending_call_set_timeout_error_unlocked (pending, message, serial)) 3396 goto error; 3397 3398 /* Insert the serial in the pending replies hash; 3399 * hash takes a refcount on DBusPendingCall. 3400 * Also, add the timeout. 3401 */ 3402 if (!_dbus_connection_attach_pending_call_unlocked (connection, 3403 pending)) 3404 goto error; 3405 3406 if (!_dbus_connection_send_unlocked_no_update (connection, message, NULL)) 3407 { 3408 _dbus_connection_detach_pending_call_and_unlock (connection, 3409 pending); 3410 goto error_unlocked; 3411 } 3412 3413 if (pending_return) 3414 *pending_return = pending; /* hand off refcount */ 3415 else 3416 { 3417 _dbus_connection_detach_pending_call_unlocked (connection, pending); 3418 /* we still have a ref to the pending call in this case, we unref 3419 * after unlocking, below 3420 */ 3421 } 3422 3423 status = _dbus_connection_get_dispatch_status_unlocked (connection); 3424 3425 /* this calls out to user code */ 3426 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 3427 3428 if (pending_return == NULL) 3429 dbus_pending_call_unref (pending); 3430 3431 return TRUE; 3432 3433 error: 3434 CONNECTION_UNLOCK (connection); 3435 error_unlocked: 3436 dbus_pending_call_unref (pending); 3437 return FALSE; 3438 } 3439 3440 /** 3441 * Sends a message and blocks a certain time period while waiting for 3442 * a reply. This function does not reenter the main loop, 3443 * i.e. messages other than the reply are queued up but not 3444 * processed. This function is used to invoke method calls on a 3445 * remote object. 3446 * 3447 * If a normal reply is received, it is returned, and removed from the 3448 * incoming message queue. If it is not received, #NULL is returned 3449 * and the error is set to #DBUS_ERROR_NO_REPLY. If an error reply is 3450 * received, it is converted to a #DBusError and returned as an error, 3451 * then the reply message is deleted and #NULL is returned. If 3452 * something else goes wrong, result is set to whatever is 3453 * appropriate, such as #DBUS_ERROR_NO_MEMORY or 3454 * #DBUS_ERROR_DISCONNECTED. 3455 * 3456 * @warning While this function blocks the calling thread will not be 3457 * processing the incoming message queue. This means you can end up 3458 * deadlocked if the application you're talking to needs you to reply 3459 * to a method. To solve this, either avoid the situation, block in a 3460 * separate thread from the main connection-dispatching thread, or use 3461 * dbus_pending_call_set_notify() to avoid blocking. 3462 * 3463 * @param connection the connection 3464 * @param message the message to send 3465 * @param timeout_milliseconds timeout in milliseconds, -1 for default or INT_MAX for no timeout. 3466 * @param error return location for error message 3467 * @returns the message that is the reply or #NULL with an error code if the 3468 * function fails. 3469 */ 3470 DBusMessage* 3471 dbus_connection_send_with_reply_and_block (DBusConnection *connection, 3472 DBusMessage *message, 3473 int timeout_milliseconds, 3474 DBusError *error) 3475 { 3476 DBusMessage *reply; 3477 DBusPendingCall *pending; 3478 3479 _dbus_return_val_if_fail (connection != NULL, NULL); 3480 _dbus_return_val_if_fail (message != NULL, NULL); 3481 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, NULL); 3482 _dbus_return_val_if_error_is_set (error, NULL); 3483 3484 #ifdef HAVE_UNIX_FD_PASSING 3485 3486 CONNECTION_LOCK (connection); 3487 if (!_dbus_transport_can_pass_unix_fd(connection->transport) && 3488 message->n_unix_fds > 0) 3489 { 3490 CONNECTION_UNLOCK (connection); 3491 dbus_set_error(error, DBUS_ERROR_FAILED, "Cannot send file descriptors on this connection."); 3492 return NULL; 3493 } 3494 CONNECTION_UNLOCK (connection); 3495 3496 #endif 3497 3498 if (!dbus_connection_send_with_reply (connection, message, 3499 &pending, timeout_milliseconds)) 3500 { 3501 _DBUS_SET_OOM (error); 3502 return NULL; 3503 } 3504 3505 if (pending == NULL) 3506 { 3507 dbus_set_error (error, DBUS_ERROR_DISCONNECTED, "Connection is closed"); 3508 return NULL; 3509 } 3510 3511 dbus_pending_call_block (pending); 3512 3513 reply = dbus_pending_call_steal_reply (pending); 3514 dbus_pending_call_unref (pending); 3515 3516 /* call_complete_and_unlock() called from pending_call_block() should 3517 * always fill this in. 3518 */ 3519 _dbus_assert (reply != NULL); 3520 3521 if (dbus_set_error_from_message (error, reply)) 3522 { 3523 dbus_message_unref (reply); 3524 return NULL; 3525 } 3526 else 3527 return reply; 3528 } 3529 3530 /** 3531 * Blocks until the outgoing message queue is empty. 3532 * Assumes connection lock already held. 3533 * 3534 * If you call this, you MUST call update_dispatch_status afterword... 3535 * 3536 * @param connection the connection. 3537 */ 3538 static DBusDispatchStatus 3539 _dbus_connection_flush_unlocked (DBusConnection *connection) 3540 { 3541 /* We have to specify DBUS_ITERATION_DO_READING here because 3542 * otherwise we could have two apps deadlock if they are both doing 3543 * a flush(), and the kernel buffers fill up. This could change the 3544 * dispatch status. 3545 */ 3546 DBusDispatchStatus status; 3547 3548 HAVE_LOCK_CHECK (connection); 3549 3550 while (connection->n_outgoing > 0 && 3551 _dbus_connection_get_is_connected_unlocked (connection)) 3552 { 3553 _dbus_verbose ("doing iteration in\n"); 3554 HAVE_LOCK_CHECK (connection); 3555 _dbus_connection_do_iteration_unlocked (connection, 3556 NULL, 3557 DBUS_ITERATION_DO_READING | 3558 DBUS_ITERATION_DO_WRITING | 3559 DBUS_ITERATION_BLOCK, 3560 -1); 3561 } 3562 3563 HAVE_LOCK_CHECK (connection); 3564 _dbus_verbose ("middle\n"); 3565 status = _dbus_connection_get_dispatch_status_unlocked (connection); 3566 3567 HAVE_LOCK_CHECK (connection); 3568 return status; 3569 } 3570 3571 /** 3572 * Blocks until the outgoing message queue is empty. 3573 * 3574 * @param connection the connection. 3575 */ 3576 void 3577 dbus_connection_flush (DBusConnection *connection) 3578 { 3579 /* We have to specify DBUS_ITERATION_DO_READING here because 3580 * otherwise we could have two apps deadlock if they are both doing 3581 * a flush(), and the kernel buffers fill up. This could change the 3582 * dispatch status. 3583 */ 3584 DBusDispatchStatus status; 3585 3586 _dbus_return_if_fail (connection != NULL); 3587 3588 CONNECTION_LOCK (connection); 3589 3590 status = _dbus_connection_flush_unlocked (connection); 3591 3592 HAVE_LOCK_CHECK (connection); 3593 /* Unlocks and calls out to user code */ 3594 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 3595 3596 _dbus_verbose ("end\n"); 3597 } 3598 3599 /** 3600 * This function implements dbus_connection_read_write_dispatch() and 3601 * dbus_connection_read_write() (they pass a different value for the 3602 * dispatch parameter). 3603 * 3604 * @param connection the connection 3605 * @param timeout_milliseconds max time to block or -1 for infinite 3606 * @param dispatch dispatch new messages or leave them on the incoming queue 3607 * @returns #TRUE if the disconnect message has not been processed 3608 */ 3609 static dbus_bool_t 3610 _dbus_connection_read_write_dispatch (DBusConnection *connection, 3611 int timeout_milliseconds, 3612 dbus_bool_t dispatch) 3613 { 3614 DBusDispatchStatus dstatus; 3615 dbus_bool_t progress_possible; 3616 3617 /* Need to grab a ref here in case we're a private connection and 3618 * the user drops the last ref in a handler we call; see bug 3619 * https://bugs.freedesktop.org/show_bug.cgi?id=15635 3620 */ 3621 dbus_connection_ref (connection); 3622 dstatus = dbus_connection_get_dispatch_status (connection); 3623 3624 if (dispatch && dstatus == DBUS_DISPATCH_DATA_REMAINS) 3625 { 3626 _dbus_verbose ("doing dispatch\n"); 3627 dbus_connection_dispatch (connection); 3628 CONNECTION_LOCK (connection); 3629 } 3630 else if (dstatus == DBUS_DISPATCH_NEED_MEMORY) 3631 { 3632 _dbus_verbose ("pausing for memory\n"); 3633 _dbus_memory_pause_based_on_timeout (timeout_milliseconds); 3634 CONNECTION_LOCK (connection); 3635 } 3636 else 3637 { 3638 CONNECTION_LOCK (connection); 3639 if (_dbus_connection_get_is_connected_unlocked (connection)) 3640 { 3641 _dbus_verbose ("doing iteration\n"); 3642 _dbus_connection_do_iteration_unlocked (connection, 3643 NULL, 3644 DBUS_ITERATION_DO_READING | 3645 DBUS_ITERATION_DO_WRITING | 3646 DBUS_ITERATION_BLOCK, 3647 timeout_milliseconds); 3648 } 3649 } 3650 3651 HAVE_LOCK_CHECK (connection); 3652 /* If we can dispatch, we can make progress until the Disconnected message 3653 * has been processed; if we can only read/write, we can make progress 3654 * as long as the transport is open. 3655 */ 3656 if (dispatch) 3657 progress_possible = connection->n_incoming != 0 || 3658 connection->disconnect_message_link != NULL; 3659 else 3660 progress_possible = _dbus_connection_get_is_connected_unlocked (connection); 3661 3662 CONNECTION_UNLOCK (connection); 3663 3664 dbus_connection_unref (connection); 3665 3666 return progress_possible; /* TRUE if we can make more progress */ 3667 } 3668 3669 3670 /** 3671 * This function is intended for use with applications that don't want 3672 * to write a main loop and deal with #DBusWatch and #DBusTimeout. An 3673 * example usage would be: 3674 * 3675 * @code 3676 * while (dbus_connection_read_write_dispatch (connection, -1)) 3677 * ; // empty loop body 3678 * @endcode 3679 * 3680 * In this usage you would normally have set up a filter function to look 3681 * at each message as it is dispatched. The loop terminates when the last 3682 * message from the connection (the disconnected signal) is processed. 3683 * 3684 * If there are messages to dispatch, this function will 3685 * dbus_connection_dispatch() once, and return. If there are no 3686 * messages to dispatch, this function will block until it can read or 3687 * write, then read or write, then return. 3688 * 3689 * The way to think of this function is that it either makes some sort 3690 * of progress, or it blocks. Note that, while it is blocked on I/O, it 3691 * cannot be interrupted (even by other threads), which makes this function 3692 * unsuitable for applications that do more than just react to received 3693 * messages. 3694 * 3695 * The return value indicates whether the disconnect message has been 3696 * processed, NOT whether the connection is connected. This is 3697 * important because even after disconnecting, you want to process any 3698 * messages you received prior to the disconnect. 3699 * 3700 * @param connection the connection 3701 * @param timeout_milliseconds max time to block or -1 for infinite 3702 * @returns #TRUE if the disconnect message has not been processed 3703 */ 3704 dbus_bool_t 3705 dbus_connection_read_write_dispatch (DBusConnection *connection, 3706 int timeout_milliseconds) 3707 { 3708 _dbus_return_val_if_fail (connection != NULL, FALSE); 3709 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE); 3710 return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, TRUE); 3711 } 3712 3713 3714 /** 3715 * This function is intended for use with applications that want to 3716 * dispatch all the events in the incoming/outgoing queue before returning. 3717 * The function just calls dbus_connection_read_write_dispatch till 3718 * the incoming queue is empty. 3719 * 3720 * @param connection the connection 3721 * @param timeout_milliseconds max time to block or -1 for infinite 3722 * @returns #TRUE if the disconnect message has not been processed 3723 */ 3724 dbus_bool_t 3725 dbus_connection_read_write_dispatch_greedy (DBusConnection *connection, 3726 int timeout_milliseconds) 3727 { 3728 dbus_bool_t ret, progress_possible; 3729 int pre_incoming, pre_outgoing; 3730 do 3731 { 3732 pre_incoming = connection->n_incoming; 3733 pre_outgoing = connection->n_outgoing; 3734 ret = dbus_connection_read_write_dispatch(connection, timeout_milliseconds); 3735 /* No need to take a lock here. If another 'reader' thread has read the packet, 3736 * dbus_connection_read_write_dispatch will just return. If a writer 3737 * writes a packet between the call and the check, it will get processed 3738 * in the next call to the function. 3739 */ 3740 if ((pre_incoming != connection->n_incoming || 3741 pre_outgoing != connection->n_outgoing) && 3742 (connection->n_incoming > 0 || 3743 connection->n_outgoing > 0)) { 3744 progress_possible = TRUE; 3745 } else { 3746 progress_possible = FALSE; 3747 } 3748 } while (ret == TRUE && progress_possible); 3749 return ret; 3750 } 3751 3752 3753 /** 3754 * This function is intended for use with applications that don't want to 3755 * write a main loop and deal with #DBusWatch and #DBusTimeout. See also 3756 * dbus_connection_read_write_dispatch(). 3757 * 3758 * As long as the connection is open, this function will block until it can 3759 * read or write, then read or write, then return #TRUE. 3760 * 3761 * If the connection is closed, the function returns #FALSE. 3762 * 3763 * The return value indicates whether reading or writing is still 3764 * possible, i.e. whether the connection is connected. 3765 * 3766 * Note that even after disconnection, messages may remain in the 3767 * incoming queue that need to be 3768 * processed. dbus_connection_read_write_dispatch() dispatches 3769 * incoming messages for you; with dbus_connection_read_write() you 3770 * have to arrange to drain the incoming queue yourself. 3771 * 3772 * @param connection the connection 3773 * @param timeout_milliseconds max time to block or -1 for infinite 3774 * @returns #TRUE if still connected 3775 */ 3776 dbus_bool_t 3777 dbus_connection_read_write (DBusConnection *connection, 3778 int timeout_milliseconds) 3779 { 3780 _dbus_return_val_if_fail (connection != NULL, FALSE); 3781 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE); 3782 return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, FALSE); 3783 } 3784 3785 /* We need to call this anytime we pop the head of the queue, and then 3786 * update_dispatch_status_and_unlock needs to be called afterward 3787 * which will "process" the disconnected message and set 3788 * disconnected_message_processed. 3789 */ 3790 static void 3791 check_disconnected_message_arrived_unlocked (DBusConnection *connection, 3792 DBusMessage *head_of_queue) 3793 { 3794 HAVE_LOCK_CHECK (connection); 3795 3796 /* checking that the link is NULL is an optimization to avoid the is_signal call */ 3797 if (connection->disconnect_message_link == NULL && 3798 dbus_message_is_signal (head_of_queue, 3799 DBUS_INTERFACE_LOCAL, 3800 "Disconnected")) 3801 { 3802 connection->disconnected_message_arrived = TRUE; 3803 } 3804 } 3805 3806 /** 3807 * Returns the first-received message from the incoming message queue, 3808 * leaving it in the queue. If the queue is empty, returns #NULL. 3809 * 3810 * The caller does not own a reference to the returned message, and 3811 * must either return it using dbus_connection_return_message() or 3812 * keep it after calling dbus_connection_steal_borrowed_message(). No 3813 * one can get at the message while its borrowed, so return it as 3814 * quickly as possible and don't keep a reference to it after 3815 * returning it. If you need to keep the message, make a copy of it. 3816 * 3817 * dbus_connection_dispatch() will block if called while a borrowed 3818 * message is outstanding; only one piece of code can be playing with 3819 * the incoming queue at a time. This function will block if called 3820 * during a dbus_connection_dispatch(). 3821 * 3822 * @param connection the connection. 3823 * @returns next message in the incoming queue. 3824 */ 3825 DBusMessage* 3826 dbus_connection_borrow_message (DBusConnection *connection) 3827 { 3828 DBusDispatchStatus status; 3829 DBusMessage *message; 3830 3831 _dbus_return_val_if_fail (connection != NULL, NULL); 3832 3833 _dbus_verbose ("start\n"); 3834 3835 /* this is called for the side effect that it queues 3836 * up any messages from the transport 3837 */ 3838 status = dbus_connection_get_dispatch_status (connection); 3839 if (status != DBUS_DISPATCH_DATA_REMAINS) 3840 return NULL; 3841 3842 CONNECTION_LOCK (connection); 3843 3844 _dbus_connection_acquire_dispatch (connection); 3845 3846 /* While a message is outstanding, the dispatch lock is held */ 3847 _dbus_assert (connection->message_borrowed == NULL); 3848 3849 connection->message_borrowed = _dbus_list_get_first (&connection->incoming_messages); 3850 3851 message = connection->message_borrowed; 3852 3853 check_disconnected_message_arrived_unlocked (connection, message); 3854 3855 /* Note that we KEEP the dispatch lock until the message is returned */ 3856 if (message == NULL) 3857 _dbus_connection_release_dispatch (connection); 3858 3859 CONNECTION_UNLOCK (connection); 3860 3861 /* We don't update dispatch status until it's returned or stolen */ 3862 3863 return message; 3864 } 3865 3866 /** 3867 * Used to return a message after peeking at it using 3868 * dbus_connection_borrow_message(). Only called if 3869 * message from dbus_connection_borrow_message() was non-#NULL. 3870 * 3871 * @param connection the connection 3872 * @param message the message from dbus_connection_borrow_message() 3873 */ 3874 void 3875 dbus_connection_return_message (DBusConnection *connection, 3876 DBusMessage *message) 3877 { 3878 DBusDispatchStatus status; 3879 3880 _dbus_return_if_fail (connection != NULL); 3881 _dbus_return_if_fail (message != NULL); 3882 _dbus_return_if_fail (message == connection->message_borrowed); 3883 _dbus_return_if_fail (connection->dispatch_acquired); 3884 3885 CONNECTION_LOCK (connection); 3886 3887 _dbus_assert (message == connection->message_borrowed); 3888 3889 connection->message_borrowed = NULL; 3890 3891 _dbus_connection_release_dispatch (connection); 3892 3893 status = _dbus_connection_get_dispatch_status_unlocked (connection); 3894 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 3895 } 3896 3897 /** 3898 * Used to keep a message after peeking at it using 3899 * dbus_connection_borrow_message(). Before using this function, see 3900 * the caveats/warnings in the documentation for 3901 * dbus_connection_pop_message(). 3902 * 3903 * @param connection the connection 3904 * @param message the message from dbus_connection_borrow_message() 3905 */ 3906 void 3907 dbus_connection_steal_borrowed_message (DBusConnection *connection, 3908 DBusMessage *message) 3909 { 3910 DBusMessage *pop_message; 3911 DBusDispatchStatus status; 3912 3913 _dbus_return_if_fail (connection != NULL); 3914 _dbus_return_if_fail (message != NULL); 3915 _dbus_return_if_fail (message == connection->message_borrowed); 3916 _dbus_return_if_fail (connection->dispatch_acquired); 3917 3918 CONNECTION_LOCK (connection); 3919 3920 _dbus_assert (message == connection->message_borrowed); 3921 3922 pop_message = _dbus_list_pop_first (&connection->incoming_messages); 3923 _dbus_assert (message == pop_message); 3924 3925 connection->n_incoming -= 1; 3926 3927 _dbus_verbose ("Incoming message %p stolen from queue, %d incoming\n", 3928 message, connection->n_incoming); 3929 3930 connection->message_borrowed = NULL; 3931 3932 _dbus_connection_release_dispatch (connection); 3933 3934 status = _dbus_connection_get_dispatch_status_unlocked (connection); 3935 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 3936 } 3937 3938 /* See dbus_connection_pop_message, but requires the caller to own 3939 * the lock before calling. May drop the lock while running. 3940 */ 3941 static DBusList* 3942 _dbus_connection_pop_message_link_unlocked (DBusConnection *connection) 3943 { 3944 HAVE_LOCK_CHECK (connection); 3945 3946 _dbus_assert (connection->message_borrowed == NULL); 3947 3948 if (connection->n_incoming > 0) 3949 { 3950 DBusList *link; 3951 3952 link = _dbus_list_pop_first_link (&connection->incoming_messages); 3953 connection->n_incoming -= 1; 3954 3955 _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from incoming queue %p, %d incoming\n", 3956 link->data, 3957 dbus_message_type_to_string (dbus_message_get_type (link->data)), 3958 dbus_message_get_path (link->data) ? 3959 dbus_message_get_path (link->data) : 3960 "no path", 3961 dbus_message_get_interface (link->data) ? 3962 dbus_message_get_interface (link->data) : 3963 "no interface", 3964 dbus_message_get_member (link->data) ? 3965 dbus_message_get_member (link->data) : 3966 "no member", 3967 dbus_message_get_signature (link->data), 3968 connection, connection->n_incoming); 3969 3970 check_disconnected_message_arrived_unlocked (connection, link->data); 3971 3972 return link; 3973 } 3974 else 3975 return NULL; 3976 } 3977 3978 /* See dbus_connection_pop_message, but requires the caller to own 3979 * the lock before calling. May drop the lock while running. 3980 */ 3981 static DBusMessage* 3982 _dbus_connection_pop_message_unlocked (DBusConnection *connection) 3983 { 3984 DBusList *link; 3985 3986 HAVE_LOCK_CHECK (connection); 3987 3988 link = _dbus_connection_pop_message_link_unlocked (connection); 3989 3990 if (link != NULL) 3991 { 3992 DBusMessage *message; 3993 3994 message = link->data; 3995 3996 _dbus_list_free_link (link); 3997 3998 return message; 3999 } 4000 else 4001 return NULL; 4002 } 4003 4004 static void 4005 _dbus_connection_putback_message_link_unlocked (DBusConnection *connection, 4006 DBusList *message_link) 4007 { 4008 HAVE_LOCK_CHECK (connection); 4009 4010 _dbus_assert (message_link != NULL); 4011 /* You can't borrow a message while a link is outstanding */ 4012 _dbus_assert (connection->message_borrowed == NULL); 4013 /* We had to have the dispatch lock across the pop/putback */ 4014 _dbus_assert (connection->dispatch_acquired); 4015 4016 _dbus_list_prepend_link (&connection->incoming_messages, 4017 message_link); 4018 connection->n_incoming += 1; 4019 4020 _dbus_verbose ("Message %p (%s %s %s '%s') put back into queue %p, %d incoming\n", 4021 message_link->data, 4022 dbus_message_type_to_string (dbus_message_get_type (message_link->data)), 4023 dbus_message_get_interface (message_link->data) ? 4024 dbus_message_get_interface (message_link->data) : 4025 "no interface", 4026 dbus_message_get_member (message_link->data) ? 4027 dbus_message_get_member (message_link->data) : 4028 "no member", 4029 dbus_message_get_signature (message_link->data), 4030 connection, connection->n_incoming); 4031 } 4032 4033 /** 4034 * Returns the first-received message from the incoming message queue, 4035 * removing it from the queue. The caller owns a reference to the 4036 * returned message. If the queue is empty, returns #NULL. 4037 * 4038 * This function bypasses any message handlers that are registered, 4039 * and so using it is usually wrong. Instead, let the main loop invoke 4040 * dbus_connection_dispatch(). Popping messages manually is only 4041 * useful in very simple programs that don't share a #DBusConnection 4042 * with any libraries or other modules. 4043 * 4044 * There is a lock that covers all ways of accessing the incoming message 4045 * queue, so dbus_connection_dispatch(), dbus_connection_pop_message(), 4046 * dbus_connection_borrow_message(), etc. will all block while one of the others 4047 * in the group is running. 4048 * 4049 * @param connection the connection. 4050 * @returns next message in the incoming queue. 4051 */ 4052 DBusMessage* 4053 dbus_connection_pop_message (DBusConnection *connection) 4054 { 4055 DBusMessage *message; 4056 DBusDispatchStatus status; 4057 4058 _dbus_verbose ("start\n"); 4059 4060 /* this is called for the side effect that it queues 4061 * up any messages from the transport 4062 */ 4063 status = dbus_connection_get_dispatch_status (connection); 4064 if (status != DBUS_DISPATCH_DATA_REMAINS) 4065 return NULL; 4066 4067 CONNECTION_LOCK (connection); 4068 _dbus_connection_acquire_dispatch (connection); 4069 HAVE_LOCK_CHECK (connection); 4070 4071 message = _dbus_connection_pop_message_unlocked (connection); 4072 4073 _dbus_verbose ("Returning popped message %p\n", message); 4074 4075 _dbus_connection_release_dispatch (connection); 4076 4077 status = _dbus_connection_get_dispatch_status_unlocked (connection); 4078 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 4079 4080 return message; 4081 } 4082 4083 /** 4084 * Acquire the dispatcher. This is a separate lock so the main 4085 * connection lock can be dropped to call out to application dispatch 4086 * handlers. 4087 * 4088 * @param connection the connection. 4089 */ 4090 static void 4091 _dbus_connection_acquire_dispatch (DBusConnection *connection) 4092 { 4093 HAVE_LOCK_CHECK (connection); 4094 4095 _dbus_connection_ref_unlocked (connection); 4096 CONNECTION_UNLOCK (connection); 4097 4098 _dbus_verbose ("locking dispatch_mutex\n"); 4099 _dbus_mutex_lock (connection->dispatch_mutex); 4100 4101 while (connection->dispatch_acquired) 4102 { 4103 _dbus_verbose ("waiting for dispatch to be acquirable\n"); 4104 _dbus_condvar_wait (connection->dispatch_cond, 4105 connection->dispatch_mutex); 4106 } 4107 4108 _dbus_assert (!connection->dispatch_acquired); 4109 4110 connection->dispatch_acquired = TRUE; 4111 4112 _dbus_verbose ("unlocking dispatch_mutex\n"); 4113 _dbus_mutex_unlock (connection->dispatch_mutex); 4114 4115 CONNECTION_LOCK (connection); 4116 _dbus_connection_unref_unlocked (connection); 4117 } 4118 4119 /** 4120 * Release the dispatcher when you're done with it. Only call 4121 * after you've acquired the dispatcher. Wakes up at most one 4122 * thread currently waiting to acquire the dispatcher. 4123 * 4124 * @param connection the connection. 4125 */ 4126 static void 4127 _dbus_connection_release_dispatch (DBusConnection *connection) 4128 { 4129 HAVE_LOCK_CHECK (connection); 4130 4131 _dbus_verbose ("locking dispatch_mutex\n"); 4132 _dbus_mutex_lock (connection->dispatch_mutex); 4133 4134 _dbus_assert (connection->dispatch_acquired); 4135 4136 connection->dispatch_acquired = FALSE; 4137 _dbus_condvar_wake_one (connection->dispatch_cond); 4138 4139 _dbus_verbose ("unlocking dispatch_mutex\n"); 4140 _dbus_mutex_unlock (connection->dispatch_mutex); 4141 } 4142 4143 static void 4144 _dbus_connection_failed_pop (DBusConnection *connection, 4145 DBusList *message_link) 4146 { 4147 _dbus_list_prepend_link (&connection->incoming_messages, 4148 message_link); 4149 connection->n_incoming += 1; 4150 } 4151 4152 /* Note this may be called multiple times since we don't track whether we already did it */ 4153 static void 4154 notify_disconnected_unlocked (DBusConnection *connection) 4155 { 4156 HAVE_LOCK_CHECK (connection); 4157 4158 /* Set the weakref in dbus-bus.c to NULL, so nobody will get a disconnected 4159 * connection from dbus_bus_get(). We make the same guarantee for 4160 * dbus_connection_open() but in a different way since we don't want to 4161 * unref right here; we instead check for connectedness before returning 4162 * the connection from the hash. 4163 */ 4164 _dbus_bus_notify_shared_connection_disconnected_unlocked (connection); 4165 4166 /* Dump the outgoing queue, we aren't going to be able to 4167 * send it now, and we'd like accessors like 4168 * dbus_connection_get_outgoing_size() to be accurate. 4169 */ 4170 if (connection->n_outgoing > 0) 4171 { 4172 DBusList *link; 4173 4174 _dbus_verbose ("Dropping %d outgoing messages since we're disconnected\n", 4175 connection->n_outgoing); 4176 4177 while ((link = _dbus_list_get_last_link (&connection->outgoing_messages))) 4178 { 4179 _dbus_connection_message_sent (connection, link->data); 4180 } 4181 } 4182 } 4183 4184 /* Note this may be called multiple times since we don't track whether we already did it */ 4185 static DBusDispatchStatus 4186 notify_disconnected_and_dispatch_complete_unlocked (DBusConnection *connection) 4187 { 4188 HAVE_LOCK_CHECK (connection); 4189 4190 if (connection->disconnect_message_link != NULL) 4191 { 4192 _dbus_verbose ("Sending disconnect message\n"); 4193 4194 /* If we have pending calls, queue their timeouts - we want the Disconnected 4195 * to be the last message, after these timeouts. 4196 */ 4197 connection_timeout_and_complete_all_pending_calls_unlocked (connection); 4198 4199 /* We haven't sent the disconnect message already, 4200 * and all real messages have been queued up. 4201 */ 4202 _dbus_connection_queue_synthesized_message_link (connection, 4203 connection->disconnect_message_link); 4204 connection->disconnect_message_link = NULL; 4205 4206 return DBUS_DISPATCH_DATA_REMAINS; 4207 } 4208 4209 return DBUS_DISPATCH_COMPLETE; 4210 } 4211 4212 static DBusDispatchStatus 4213 _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection) 4214 { 4215 HAVE_LOCK_CHECK (connection); 4216 4217 if (connection->n_incoming > 0) 4218 return DBUS_DISPATCH_DATA_REMAINS; 4219 else if (!_dbus_transport_queue_messages (connection->transport)) 4220 return DBUS_DISPATCH_NEED_MEMORY; 4221 else 4222 { 4223 DBusDispatchStatus status; 4224 dbus_bool_t is_connected; 4225 4226 status = _dbus_transport_get_dispatch_status (connection->transport); 4227 is_connected = _dbus_transport_get_is_connected (connection->transport); 4228 4229 _dbus_verbose ("dispatch status = %s is_connected = %d\n", 4230 DISPATCH_STATUS_NAME (status), is_connected); 4231 4232 if (!is_connected) 4233 { 4234 /* It's possible this would be better done by having an explicit 4235 * notification from _dbus_transport_disconnect() that would 4236 * synchronously do this, instead of waiting for the next dispatch 4237 * status check. However, probably not good to change until it causes 4238 * a problem. 4239 */ 4240 notify_disconnected_unlocked (connection); 4241 4242 /* I'm not sure this is needed; the idea is that we want to 4243 * queue the Disconnected only after we've read all the 4244 * messages, but if we're disconnected maybe we are guaranteed 4245 * to have read them all ? 4246 */ 4247 if (status == DBUS_DISPATCH_COMPLETE) 4248 status = notify_disconnected_and_dispatch_complete_unlocked (connection); 4249 } 4250 4251 if (status != DBUS_DISPATCH_COMPLETE) 4252 return status; 4253 else if (connection->n_incoming > 0) 4254 return DBUS_DISPATCH_DATA_REMAINS; 4255 else 4256 return DBUS_DISPATCH_COMPLETE; 4257 } 4258 } 4259 4260 static void 4261 _dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection, 4262 DBusDispatchStatus new_status) 4263 { 4264 dbus_bool_t changed; 4265 DBusDispatchStatusFunction function; 4266 void *data; 4267 4268 HAVE_LOCK_CHECK (connection); 4269 4270 _dbus_connection_ref_unlocked (connection); 4271 4272 changed = new_status != connection->last_dispatch_status; 4273 4274 connection->last_dispatch_status = new_status; 4275 4276 function = connection->dispatch_status_function; 4277 data = connection->dispatch_status_data; 4278 4279 if (connection->disconnected_message_arrived && 4280 !connection->disconnected_message_processed) 4281 { 4282 connection->disconnected_message_processed = TRUE; 4283 4284 /* this does an unref, but we have a ref 4285 * so we should not run the finalizer here 4286 * inside the lock. 4287 */ 4288 connection_forget_shared_unlocked (connection); 4289 4290 if (connection->exit_on_disconnect) 4291 { 4292 CONNECTION_UNLOCK (connection); 4293 4294 _dbus_verbose ("Exiting on Disconnected signal\n"); 4295 _dbus_exit (1); 4296 _dbus_assert_not_reached ("Call to exit() returned"); 4297 } 4298 } 4299 4300 /* We drop the lock */ 4301 CONNECTION_UNLOCK (connection); 4302 4303 if (changed && function) 4304 { 4305 _dbus_verbose ("Notifying of change to dispatch status of %p now %d (%s)\n", 4306 connection, new_status, 4307 DISPATCH_STATUS_NAME (new_status)); 4308 (* function) (connection, new_status, data); 4309 } 4310 4311 dbus_connection_unref (connection); 4312 } 4313 4314 /** 4315 * Gets the current state of the incoming message queue. 4316 * #DBUS_DISPATCH_DATA_REMAINS indicates that the message queue 4317 * may contain messages. #DBUS_DISPATCH_COMPLETE indicates that the 4318 * incoming queue is empty. #DBUS_DISPATCH_NEED_MEMORY indicates that 4319 * there could be data, but we can't know for sure without more 4320 * memory. 4321 * 4322 * To process the incoming message queue, use dbus_connection_dispatch() 4323 * or (in rare cases) dbus_connection_pop_message(). 4324 * 4325 * Note, #DBUS_DISPATCH_DATA_REMAINS really means that either we 4326 * have messages in the queue, or we have raw bytes buffered up 4327 * that need to be parsed. When these bytes are parsed, they 4328 * may not add up to an entire message. Thus, it's possible 4329 * to see a status of #DBUS_DISPATCH_DATA_REMAINS but not 4330 * have a message yet. 4331 * 4332 * In particular this happens on initial connection, because all sorts 4333 * of authentication protocol stuff has to be parsed before the 4334 * first message arrives. 4335 * 4336 * @param connection the connection. 4337 * @returns current dispatch status 4338 */ 4339 DBusDispatchStatus 4340 dbus_connection_get_dispatch_status (DBusConnection *connection) 4341 { 4342 DBusDispatchStatus status; 4343 4344 _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE); 4345 4346 _dbus_verbose ("start\n"); 4347 4348 CONNECTION_LOCK (connection); 4349 4350 status = _dbus_connection_get_dispatch_status_unlocked (connection); 4351 4352 CONNECTION_UNLOCK (connection); 4353 4354 return status; 4355 } 4356 4357 /** 4358 * Filter funtion for handling the Peer standard interface. 4359 */ 4360 static DBusHandlerResult 4361 _dbus_connection_peer_filter_unlocked_no_update (DBusConnection *connection, 4362 DBusMessage *message) 4363 { 4364 if (connection->route_peer_messages && dbus_message_get_destination (message) != NULL) 4365 { 4366 /* This means we're letting the bus route this message */ 4367 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 4368 } 4369 else if (dbus_message_is_method_call (message, 4370 DBUS_INTERFACE_PEER, 4371 "Ping")) 4372 { 4373 DBusMessage *ret; 4374 dbus_bool_t sent; 4375 4376 ret = dbus_message_new_method_return (message); 4377 if (ret == NULL) 4378 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4379 4380 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL); 4381 4382 dbus_message_unref (ret); 4383 4384 if (!sent) 4385 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4386 4387 return DBUS_HANDLER_RESULT_HANDLED; 4388 } 4389 else if (dbus_message_is_method_call (message, 4390 DBUS_INTERFACE_PEER, 4391 "GetMachineId")) 4392 { 4393 DBusMessage *ret; 4394 dbus_bool_t sent; 4395 DBusString uuid; 4396 4397 ret = dbus_message_new_method_return (message); 4398 if (ret == NULL) 4399 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4400 4401 sent = FALSE; 4402 _dbus_string_init (&uuid); 4403 if (_dbus_get_local_machine_uuid_encoded (&uuid)) 4404 { 4405 const char *v_STRING = _dbus_string_get_const_data (&uuid); 4406 if (dbus_message_append_args (ret, 4407 DBUS_TYPE_STRING, &v_STRING, 4408 DBUS_TYPE_INVALID)) 4409 { 4410 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL); 4411 } 4412 } 4413 _dbus_string_free (&uuid); 4414 4415 dbus_message_unref (ret); 4416 4417 if (!sent) 4418 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4419 4420 return DBUS_HANDLER_RESULT_HANDLED; 4421 } 4422 else if (dbus_message_has_interface (message, DBUS_INTERFACE_PEER)) 4423 { 4424 /* We need to bounce anything else with this interface, otherwise apps 4425 * could start extending the interface and when we added extensions 4426 * here to DBusConnection we'd break those apps. 4427 */ 4428 4429 DBusMessage *ret; 4430 dbus_bool_t sent; 4431 4432 ret = dbus_message_new_error (message, 4433 DBUS_ERROR_UNKNOWN_METHOD, 4434 "Unknown method invoked on org.freedesktop.DBus.Peer interface"); 4435 if (ret == NULL) 4436 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4437 4438 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL); 4439 4440 dbus_message_unref (ret); 4441 4442 if (!sent) 4443 return DBUS_HANDLER_RESULT_NEED_MEMORY; 4444 4445 return DBUS_HANDLER_RESULT_HANDLED; 4446 } 4447 else 4448 { 4449 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 4450 } 4451 } 4452 4453 /** 4454 * Processes all builtin filter functions 4455 * 4456 * If the spec specifies a standard interface 4457 * they should be processed from this method 4458 **/ 4459 static DBusHandlerResult 4460 _dbus_connection_run_builtin_filters_unlocked_no_update (DBusConnection *connection, 4461 DBusMessage *message) 4462 { 4463 /* We just run one filter for now but have the option to run more 4464 if the spec calls for it in the future */ 4465 4466 return _dbus_connection_peer_filter_unlocked_no_update (connection, message); 4467 } 4468 4469 /** 4470 * Processes any incoming data. 4471 * 4472 * If there's incoming raw data that has not yet been parsed, it is 4473 * parsed, which may or may not result in adding messages to the 4474 * incoming queue. 4475 * 4476 * The incoming data buffer is filled when the connection reads from 4477 * its underlying transport (such as a socket). Reading usually 4478 * happens in dbus_watch_handle() or dbus_connection_read_write(). 4479 * 4480 * If there are complete messages in the incoming queue, 4481 * dbus_connection_dispatch() removes one message from the queue and 4482 * processes it. Processing has three steps. 4483 * 4484 * First, any method replies are passed to #DBusPendingCall or 4485 * dbus_connection_send_with_reply_and_block() in order to 4486 * complete the pending method call. 4487 * 4488 * Second, any filters registered with dbus_connection_add_filter() 4489 * are run. If any filter returns #DBUS_HANDLER_RESULT_HANDLED 4490 * then processing stops after that filter. 4491 * 4492 * Third, if the message is a method call it is forwarded to 4493 * any registered object path handlers added with 4494 * dbus_connection_register_object_path() or 4495 * dbus_connection_register_fallback(). 4496 * 4497 * A single call to dbus_connection_dispatch() will process at most 4498 * one message; it will not clear the entire message queue. 4499 * 4500 * Be careful about calling dbus_connection_dispatch() from inside a 4501 * message handler, i.e. calling dbus_connection_dispatch() 4502 * recursively. If threads have been initialized with a recursive 4503 * mutex function, then this will not deadlock; however, it can 4504 * certainly confuse your application. 4505 * 4506 * @todo some FIXME in here about handling DBUS_HANDLER_RESULT_NEED_MEMORY 4507 * 4508 * @param connection the connection 4509 * @returns dispatch status, see dbus_connection_get_dispatch_status() 4510 */ 4511 DBusDispatchStatus 4512 dbus_connection_dispatch (DBusConnection *connection) 4513 { 4514 DBusMessage *message; 4515 DBusList *link, *filter_list_copy, *message_link; 4516 DBusHandlerResult result; 4517 DBusPendingCall *pending; 4518 dbus_int32_t reply_serial; 4519 DBusDispatchStatus status; 4520 4521 _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE); 4522 4523 _dbus_verbose ("\n"); 4524 4525 CONNECTION_LOCK (connection); 4526 status = _dbus_connection_get_dispatch_status_unlocked (connection); 4527 if (status != DBUS_DISPATCH_DATA_REMAINS) 4528 { 4529 /* unlocks and calls out to user code */ 4530 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 4531 return status; 4532 } 4533 4534 /* We need to ref the connection since the callback could potentially 4535 * drop the last ref to it 4536 */ 4537 _dbus_connection_ref_unlocked (connection); 4538 4539 _dbus_connection_acquire_dispatch (connection); 4540 HAVE_LOCK_CHECK (connection); 4541 4542 message_link = _dbus_connection_pop_message_link_unlocked (connection); 4543 if (message_link == NULL) 4544 { 4545 /* another thread dispatched our stuff */ 4546 4547 _dbus_verbose ("another thread dispatched message (during acquire_dispatch above)\n"); 4548 4549 _dbus_connection_release_dispatch (connection); 4550 4551 status = _dbus_connection_get_dispatch_status_unlocked (connection); 4552 4553 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 4554 4555 dbus_connection_unref (connection); 4556 4557 return status; 4558 } 4559 4560 message = message_link->data; 4561 4562 _dbus_verbose (" dispatching message %p (%s %s %s '%s')\n", 4563 message, 4564 dbus_message_type_to_string (dbus_message_get_type (message)), 4565 dbus_message_get_interface (message) ? 4566 dbus_message_get_interface (message) : 4567 "no interface", 4568 dbus_message_get_member (message) ? 4569 dbus_message_get_member (message) : 4570 "no member", 4571 dbus_message_get_signature (message)); 4572 4573 result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 4574 4575 /* Pending call handling must be first, because if you do 4576 * dbus_connection_send_with_reply_and_block() or 4577 * dbus_pending_call_block() then no handlers/filters will be run on 4578 * the reply. We want consistent semantics in the case where we 4579 * dbus_connection_dispatch() the reply. 4580 */ 4581 4582 reply_serial = dbus_message_get_reply_serial (message); 4583 pending = _dbus_hash_table_lookup_int (connection->pending_replies, 4584 reply_serial); 4585 if (pending) 4586 { 4587 _dbus_verbose ("Dispatching a pending reply\n"); 4588 complete_pending_call_and_unlock (connection, pending, message); 4589 pending = NULL; /* it's probably unref'd */ 4590 4591 CONNECTION_LOCK (connection); 4592 _dbus_verbose ("pending call completed in dispatch\n"); 4593 result = DBUS_HANDLER_RESULT_HANDLED; 4594 goto out; 4595 } 4596 4597 result = _dbus_connection_run_builtin_filters_unlocked_no_update (connection, message); 4598 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED) 4599 goto out; 4600 4601 if (!_dbus_list_copy (&connection->filter_list, &filter_list_copy)) 4602 { 4603 _dbus_connection_release_dispatch (connection); 4604 HAVE_LOCK_CHECK (connection); 4605 4606 _dbus_connection_failed_pop (connection, message_link); 4607 4608 /* unlocks and calls user code */ 4609 _dbus_connection_update_dispatch_status_and_unlock (connection, 4610 DBUS_DISPATCH_NEED_MEMORY); 4611 4612 if (pending) 4613 dbus_pending_call_unref (pending); 4614 dbus_connection_unref (connection); 4615 4616 return DBUS_DISPATCH_NEED_MEMORY; 4617 } 4618 4619 _dbus_list_foreach (&filter_list_copy, 4620 (DBusForeachFunction)_dbus_message_filter_ref, 4621 NULL); 4622 4623 /* We're still protected from dispatch() reentrancy here 4624 * since we acquired the dispatcher 4625 */ 4626 CONNECTION_UNLOCK (connection); 4627 4628 link = _dbus_list_get_first_link (&filter_list_copy); 4629 while (link != NULL) 4630 { 4631 DBusMessageFilter *filter = link->data; 4632 DBusList *next = _dbus_list_get_next_link (&filter_list_copy, link); 4633 4634 if (filter->function == NULL) 4635 { 4636 _dbus_verbose (" filter was removed in a callback function\n"); 4637 link = next; 4638 continue; 4639 } 4640 4641 _dbus_verbose (" running filter on message %p\n", message); 4642 result = (* filter->function) (connection, message, filter->user_data); 4643 4644 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED) 4645 break; 4646 4647 link = next; 4648 } 4649 4650 _dbus_list_foreach (&filter_list_copy, 4651 (DBusForeachFunction)_dbus_message_filter_unref, 4652 NULL); 4653 _dbus_list_clear (&filter_list_copy); 4654 4655 CONNECTION_LOCK (connection); 4656 4657 if (result == DBUS_HANDLER_RESULT_NEED_MEMORY) 4658 { 4659 _dbus_verbose ("No memory\n"); 4660 goto out; 4661 } 4662 else if (result == DBUS_HANDLER_RESULT_HANDLED) 4663 { 4664 _dbus_verbose ("filter handled message in dispatch\n"); 4665 goto out; 4666 } 4667 4668 /* We're still protected from dispatch() reentrancy here 4669 * since we acquired the dispatcher 4670 */ 4671 _dbus_verbose (" running object path dispatch on message %p (%s %s %s '%s')\n", 4672 message, 4673 dbus_message_type_to_string (dbus_message_get_type (message)), 4674 dbus_message_get_interface (message) ? 4675 dbus_message_get_interface (message) : 4676 "no interface", 4677 dbus_message_get_member (message) ? 4678 dbus_message_get_member (message) : 4679 "no member", 4680 dbus_message_get_signature (message)); 4681 4682 HAVE_LOCK_CHECK (connection); 4683 result = _dbus_object_tree_dispatch_and_unlock (connection->objects, 4684 message); 4685 4686 CONNECTION_LOCK (connection); 4687 4688 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED) 4689 { 4690 _dbus_verbose ("object tree handled message in dispatch\n"); 4691 goto out; 4692 } 4693 4694 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL) 4695 { 4696 DBusMessage *reply; 4697 DBusString str; 4698 DBusPreallocatedSend *preallocated; 4699 4700 _dbus_verbose (" sending error %s\n", 4701 DBUS_ERROR_UNKNOWN_METHOD); 4702 4703 if (!_dbus_string_init (&str)) 4704 { 4705 result = DBUS_HANDLER_RESULT_NEED_MEMORY; 4706 _dbus_verbose ("no memory for error string in dispatch\n"); 4707 goto out; 4708 } 4709 4710 if (!_dbus_string_append_printf (&str, 4711 "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n", 4712 dbus_message_get_member (message), 4713 dbus_message_get_signature (message), 4714 dbus_message_get_interface (message))) 4715 { 4716 _dbus_string_free (&str); 4717 result = DBUS_HANDLER_RESULT_NEED_MEMORY; 4718 _dbus_verbose ("no memory for error string in dispatch\n"); 4719 goto out; 4720 } 4721 4722 reply = dbus_message_new_error (message, 4723 DBUS_ERROR_UNKNOWN_METHOD, 4724 _dbus_string_get_const_data (&str)); 4725 _dbus_string_free (&str); 4726 4727 if (reply == NULL) 4728 { 4729 result = DBUS_HANDLER_RESULT_NEED_MEMORY; 4730 _dbus_verbose ("no memory for error reply in dispatch\n"); 4731 goto out; 4732 } 4733 4734 preallocated = _dbus_connection_preallocate_send_unlocked (connection); 4735 4736 if (preallocated == NULL) 4737 { 4738 dbus_message_unref (reply); 4739 result = DBUS_HANDLER_RESULT_NEED_MEMORY; 4740 _dbus_verbose ("no memory for error send in dispatch\n"); 4741 goto out; 4742 } 4743 4744 _dbus_connection_send_preallocated_unlocked_no_update (connection, preallocated, 4745 reply, NULL); 4746 4747 dbus_message_unref (reply); 4748 4749 result = DBUS_HANDLER_RESULT_HANDLED; 4750 } 4751 4752 _dbus_verbose (" done dispatching %p (%s %s %s '%s') on connection %p\n", message, 4753 dbus_message_type_to_string (dbus_message_get_type (message)), 4754 dbus_message_get_interface (message) ? 4755 dbus_message_get_interface (message) : 4756 "no interface", 4757 dbus_message_get_member (message) ? 4758 dbus_message_get_member (message) : 4759 "no member", 4760 dbus_message_get_signature (message), 4761 connection); 4762 4763 out: 4764 if (result == DBUS_HANDLER_RESULT_NEED_MEMORY) 4765 { 4766 _dbus_verbose ("out of memory\n"); 4767 4768 /* Put message back, and we'll start over. 4769 * Yes this means handlers must be idempotent if they 4770 * don't return HANDLED; c'est la vie. 4771 */ 4772 _dbus_connection_putback_message_link_unlocked (connection, 4773 message_link); 4774 } 4775 else 4776 { 4777 _dbus_verbose (" ... done dispatching\n"); 4778 4779 _dbus_list_free_link (message_link); 4780 dbus_message_unref (message); /* don't want the message to count in max message limits 4781 * in computing dispatch status below 4782 */ 4783 } 4784 4785 _dbus_connection_release_dispatch (connection); 4786 HAVE_LOCK_CHECK (connection); 4787 4788 _dbus_verbose ("before final status update\n"); 4789 status = _dbus_connection_get_dispatch_status_unlocked (connection); 4790 4791 /* unlocks and calls user code */ 4792 _dbus_connection_update_dispatch_status_and_unlock (connection, status); 4793 4794 dbus_connection_unref (connection); 4795 4796 return status; 4797 } 4798 4799 /** 4800 * Sets the watch functions for the connection. These functions are 4801 * responsible for making the application's main loop aware of file 4802 * descriptors that need to be monitored for events, using select() or 4803 * poll(). When using Qt, typically the DBusAddWatchFunction would 4804 * create a QSocketNotifier. When using GLib, the DBusAddWatchFunction 4805 * could call g_io_add_watch(), or could be used as part of a more 4806 * elaborate GSource. Note that when a watch is added, it may 4807 * not be enabled. 4808 * 4809 * The DBusWatchToggledFunction notifies the application that the 4810 * watch has been enabled or disabled. Call dbus_watch_get_enabled() 4811 * to check this. A disabled watch should have no effect, and enabled 4812 * watch should be added to the main loop. This feature is used 4813 * instead of simply adding/removing the watch because 4814 * enabling/disabling can be done without memory allocation. The 4815 * toggled function may be NULL if a main loop re-queries 4816 * dbus_watch_get_enabled() every time anyway. 4817 * 4818 * The DBusWatch can be queried for the file descriptor to watch using 4819 * dbus_watch_get_unix_fd() or dbus_watch_get_socket(), and for the 4820 * events to watch for using dbus_watch_get_flags(). The flags 4821 * returned by dbus_watch_get_flags() will only contain 4822 * DBUS_WATCH_READABLE and DBUS_WATCH_WRITABLE, never 4823 * DBUS_WATCH_HANGUP or DBUS_WATCH_ERROR; all watches implicitly 4824 * include a watch for hangups, errors, and other exceptional 4825 * conditions. 4826 * 4827 * Once a file descriptor becomes readable or writable, or an exception 4828 * occurs, dbus_watch_handle() should be called to 4829 * notify the connection of the file descriptor's condition. 4830 * 4831 * dbus_watch_handle() cannot be called during the 4832 * DBusAddWatchFunction, as the connection will not be ready to handle 4833 * that watch yet. 4834 * 4835 * It is not allowed to reference a DBusWatch after it has been passed 4836 * to remove_function. 4837 * 4838 * If #FALSE is returned due to lack of memory, the failure may be due 4839 * to a #FALSE return from the new add_function. If so, the 4840 * add_function may have been called successfully one or more times, 4841 * but the remove_function will also have been called to remove any 4842 * successful adds. i.e. if #FALSE is returned the net result 4843 * should be that dbus_connection_set_watch_functions() has no effect, 4844 * but the add_function and remove_function may have been called. 4845 * 4846 * @note The thread lock on DBusConnection is held while 4847 * watch functions are invoked, so inside these functions you 4848 * may not invoke any methods on DBusConnection or it will deadlock. 4849 * See the comments in the code or http://lists.freedesktop.org/archives/dbus/2007-July/tread.html#8144 4850 * if you encounter this issue and want to attempt writing a patch. 4851 * 4852 * @param connection the connection. 4853 * @param add_function function to begin monitoring a new descriptor. 4854 * @param remove_function function to stop monitoring a descriptor. 4855 * @param toggled_function function to notify of enable/disable 4856 * @param data data to pass to add_function and remove_function. 4857 * @param free_data_function function to be called to free the data. 4858 * @returns #FALSE on failure (no memory) 4859 */ 4860 dbus_bool_t 4861 dbus_connection_set_watch_functions (DBusConnection *connection, 4862 DBusAddWatchFunction add_function, 4863 DBusRemoveWatchFunction remove_function, 4864 DBusWatchToggledFunction toggled_function, 4865 void *data, 4866 DBusFreeFunction free_data_function) 4867 { 4868 dbus_bool_t retval; 4869 4870 _dbus_return_val_if_fail (connection != NULL, FALSE); 4871 4872 CONNECTION_LOCK (connection); 4873 4874 retval = _dbus_watch_list_set_functions (connection->watches, 4875 add_function, remove_function, 4876 toggled_function, 4877 data, free_data_function); 4878 4879 CONNECTION_UNLOCK (connection); 4880 4881 return retval; 4882 } 4883 4884 /** 4885 * Sets the timeout functions for the connection. These functions are 4886 * responsible for making the application's main loop aware of timeouts. 4887 * When using Qt, typically the DBusAddTimeoutFunction would create a 4888 * QTimer. When using GLib, the DBusAddTimeoutFunction would call 4889 * g_timeout_add. 4890 * 4891 * The DBusTimeoutToggledFunction notifies the application that the 4892 * timeout has been enabled or disabled. Call 4893 * dbus_timeout_get_enabled() to check this. A disabled timeout should 4894 * have no effect, and enabled timeout should be added to the main 4895 * loop. This feature is used instead of simply adding/removing the 4896 * timeout because enabling/disabling can be done without memory 4897 * allocation. With Qt, QTimer::start() and QTimer::stop() can be used 4898 * to enable and disable. The toggled function may be NULL if a main 4899 * loop re-queries dbus_timeout_get_enabled() every time anyway. 4900 * Whenever a timeout is toggled, its interval may change. 4901 * 4902 * The DBusTimeout can be queried for the timer interval using 4903 * dbus_timeout_get_interval(). dbus_timeout_handle() should be called 4904 * repeatedly, each time the interval elapses, starting after it has 4905 * elapsed once. The timeout stops firing when it is removed with the 4906 * given remove_function. The timer interval may change whenever the 4907 * timeout is added, removed, or toggled. 4908 * 4909 * @note The thread lock on DBusConnection is held while 4910 * timeout functions are invoked, so inside these functions you 4911 * may not invoke any methods on DBusConnection or it will deadlock. 4912 * See the comments in the code or http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144 4913 * if you encounter this issue and want to attempt writing a patch. 4914 * 4915 * @param connection the connection. 4916 * @param add_function function to add a timeout. 4917 * @param remove_function function to remove a timeout. 4918 * @param toggled_function function to notify of enable/disable 4919 * @param data data to pass to add_function and remove_function. 4920 * @param free_data_function function to be called to free the data. 4921 * @returns #FALSE on failure (no memory) 4922 */ 4923 dbus_bool_t 4924 dbus_connection_set_timeout_functions (DBusConnection *connection, 4925 DBusAddTimeoutFunction add_function, 4926 DBusRemoveTimeoutFunction remove_function, 4927 DBusTimeoutToggledFunction toggled_function, 4928 void *data, 4929 DBusFreeFunction free_data_function) 4930 { 4931 dbus_bool_t retval; 4932 4933 _dbus_return_val_if_fail (connection != NULL, FALSE); 4934 4935 CONNECTION_LOCK (connection); 4936 4937 retval = _dbus_timeout_list_set_functions (connection->timeouts, 4938 add_function, remove_function, 4939 toggled_function, 4940 data, free_data_function); 4941 4942 CONNECTION_UNLOCK (connection); 4943 4944 return retval; 4945 } 4946 4947 /** 4948 * Sets the mainloop wakeup function for the connection. This function 4949 * is responsible for waking up the main loop (if its sleeping in 4950 * another thread) when some some change has happened to the 4951 * connection that the mainloop needs to reconsider (e.g. a message 4952 * has been queued for writing). When using Qt, this typically 4953 * results in a call to QEventLoop::wakeUp(). When using GLib, it 4954 * would call g_main_context_wakeup(). 4955 * 4956 * @param connection the connection. 4957 * @param wakeup_main_function function to wake up the mainloop 4958 * @param data data to pass wakeup_main_function 4959 * @param free_data_function function to be called to free the data. 4960 */ 4961 void 4962 dbus_connection_set_wakeup_main_function (DBusConnection *connection, 4963 DBusWakeupMainFunction wakeup_main_function, 4964 void *data, 4965 DBusFreeFunction free_data_function) 4966 { 4967 void *old_data; 4968 DBusFreeFunction old_free_data; 4969 4970 _dbus_return_if_fail (connection != NULL); 4971 4972 CONNECTION_LOCK (connection); 4973 old_data = connection->wakeup_main_data; 4974 old_free_data = connection->free_wakeup_main_data; 4975 4976 connection->wakeup_main_function = wakeup_main_function; 4977 connection->wakeup_main_data = data; 4978 connection->free_wakeup_main_data = free_data_function; 4979 4980 CONNECTION_UNLOCK (connection); 4981 4982 /* Callback outside the lock */ 4983 if (old_free_data) 4984 (*old_free_data) (old_data); 4985 } 4986 4987 /** 4988 * Set a function to be invoked when the dispatch status changes. 4989 * If the dispatch status is #DBUS_DISPATCH_DATA_REMAINS, then 4990 * dbus_connection_dispatch() needs to be called to process incoming 4991 * messages. However, dbus_connection_dispatch() MUST NOT BE CALLED 4992 * from inside the DBusDispatchStatusFunction. Indeed, almost 4993 * any reentrancy in this function is a bad idea. Instead, 4994 * the DBusDispatchStatusFunction should simply save an indication 4995 * that messages should be dispatched later, when the main loop 4996 * is re-entered. 4997 * 4998 * If you don't set a dispatch status function, you have to be sure to 4999 * dispatch on every iteration of your main loop, especially if 5000 * dbus_watch_handle() or dbus_timeout_handle() were called. 5001 * 5002 * @param connection the connection 5003 * @param function function to call on dispatch status changes 5004 * @param data data for function 5005 * @param free_data_function free the function data 5006 */ 5007 void 5008 dbus_connection_set_dispatch_status_function (DBusConnection *connection, 5009 DBusDispatchStatusFunction function, 5010 void *data, 5011 DBusFreeFunction free_data_function) 5012 { 5013 void *old_data; 5014 DBusFreeFunction old_free_data; 5015 5016 _dbus_return_if_fail (connection != NULL); 5017 5018 CONNECTION_LOCK (connection); 5019 old_data = connection->dispatch_status_data; 5020 old_free_data = connection->free_dispatch_status_data; 5021 5022 connection->dispatch_status_function = function; 5023 connection->dispatch_status_data = data; 5024 connection->free_dispatch_status_data = free_data_function; 5025 5026 CONNECTION_UNLOCK (connection); 5027 5028 /* Callback outside the lock */ 5029 if (old_free_data) 5030 (*old_free_data) (old_data); 5031 } 5032 5033 /** 5034 * Get the UNIX file descriptor of the connection, if any. This can 5035 * be used for SELinux access control checks with getpeercon() for 5036 * example. DO NOT read or write to the file descriptor, or try to 5037 * select() on it; use DBusWatch for main loop integration. Not all 5038 * connections will have a file descriptor. So for adding descriptors 5039 * to the main loop, use dbus_watch_get_unix_fd() and so forth. 5040 * 5041 * If the connection is socket-based, you can also use 5042 * dbus_connection_get_socket(), which will work on Windows too. 5043 * This function always fails on Windows. 5044 * 5045 * Right now the returned descriptor is always a socket, but 5046 * that is not guaranteed. 5047 * 5048 * @param connection the connection 5049 * @param fd return location for the file descriptor. 5050 * @returns #TRUE if fd is successfully obtained. 5051 */ 5052 dbus_bool_t 5053 dbus_connection_get_unix_fd (DBusConnection *connection, 5054 int *fd) 5055 { 5056 _dbus_return_val_if_fail (connection != NULL, FALSE); 5057 _dbus_return_val_if_fail (connection->transport != NULL, FALSE); 5058 5059 #ifdef DBUS_WIN 5060 /* FIXME do this on a lower level */ 5061 return FALSE; 5062 #endif 5063 5064 return dbus_connection_get_socket(connection, fd); 5065 } 5066 5067 /** 5068 * Gets the underlying Windows or UNIX socket file descriptor 5069 * of the connection, if any. DO NOT read or write to the file descriptor, or try to 5070 * select() on it; use DBusWatch for main loop integration. Not all 5071 * connections will have a socket. So for adding descriptors 5072 * to the main loop, use dbus_watch_get_socket() and so forth. 5073 * 5074 * If the connection is not socket-based, this function will return FALSE, 5075 * even if the connection does have a file descriptor of some kind. 5076 * i.e. this function always returns specifically a socket file descriptor. 5077 * 5078 * @param connection the connection 5079 * @param fd return location for the file descriptor. 5080 * @returns #TRUE if fd is successfully obtained. 5081 */ 5082 dbus_bool_t 5083 dbus_connection_get_socket(DBusConnection *connection, 5084 int *fd) 5085 { 5086 dbus_bool_t retval; 5087 5088 _dbus_return_val_if_fail (connection != NULL, FALSE); 5089 _dbus_return_val_if_fail (connection->transport != NULL, FALSE); 5090 5091 CONNECTION_LOCK (connection); 5092 5093 retval = _dbus_transport_get_socket_fd (connection->transport, 5094 fd); 5095 5096 CONNECTION_UNLOCK (connection); 5097 5098 return retval; 5099 } 5100 5101 5102 /** 5103 * Gets the UNIX user ID of the connection if known. Returns #TRUE if 5104 * the uid is filled in. Always returns #FALSE on non-UNIX platforms 5105 * for now, though in theory someone could hook Windows to NIS or 5106 * something. Always returns #FALSE prior to authenticating the 5107 * connection. 5108 * 5109 * The UID is only read by servers from clients; clients can't usually 5110 * get the UID of servers, because servers do not authenticate to 5111 * clients. The returned UID is the UID the connection authenticated 5112 * as. 5113 * 5114 * The message bus is a server and the apps connecting to the bus 5115 * are clients. 5116 * 5117 * You can ask the bus to tell you the UID of another connection though 5118 * if you like; this is done with dbus_bus_get_unix_user(). 5119 * 5120 * @param connection the connection 5121 * @param uid return location for the user ID 5122 * @returns #TRUE if uid is filled in with a valid user ID 5123 */ 5124 dbus_bool_t 5125 dbus_connection_get_unix_user (DBusConnection *connection, 5126 unsigned long *uid) 5127 { 5128 dbus_bool_t result; 5129 5130 _dbus_return_val_if_fail (connection != NULL, FALSE); 5131 _dbus_return_val_if_fail (uid != NULL, FALSE); 5132 5133 CONNECTION_LOCK (connection); 5134 5135 if (!_dbus_transport_get_is_authenticated (connection->transport)) 5136 result = FALSE; 5137 else 5138 result = _dbus_transport_get_unix_user (connection->transport, 5139 uid); 5140 5141 #ifdef DBUS_WIN 5142 _dbus_assert (!result); 5143 #endif 5144 5145 CONNECTION_UNLOCK (connection); 5146 5147 return result; 5148 } 5149 5150 /** 5151 * Gets the process ID of the connection if any. 5152 * Returns #TRUE if the pid is filled in. 5153 * Always returns #FALSE prior to authenticating the 5154 * connection. 5155 * 5156 * @param connection the connection 5157 * @param pid return location for the process ID 5158 * @returns #TRUE if uid is filled in with a valid process ID 5159 */ 5160 dbus_bool_t 5161 dbus_connection_get_unix_process_id (DBusConnection *connection, 5162 unsigned long *pid) 5163 { 5164 dbus_bool_t result; 5165 5166 _dbus_return_val_if_fail (connection != NULL, FALSE); 5167 _dbus_return_val_if_fail (pid != NULL, FALSE); 5168 5169 CONNECTION_LOCK (connection); 5170 5171 if (!_dbus_transport_get_is_authenticated (connection->transport)) 5172 result = FALSE; 5173 else 5174 result = _dbus_transport_get_unix_process_id (connection->transport, 5175 pid); 5176 5177 CONNECTION_UNLOCK (connection); 5178 5179 return result; 5180 } 5181 5182 /** 5183 * Gets the ADT audit data of the connection if any. 5184 * Returns #TRUE if the structure pointer is returned. 5185 * Always returns #FALSE prior to authenticating the 5186 * connection. 5187 * 5188 * @param connection the connection 5189 * @param data return location for audit data 5190 * @returns #TRUE if audit data is filled in with a valid ucred pointer 5191 */ 5192 dbus_bool_t 5193 dbus_connection_get_adt_audit_session_data (DBusConnection *connection, 5194 void **data, 5195 dbus_int32_t *data_size) 5196 { 5197 dbus_bool_t result; 5198 5199 _dbus_return_val_if_fail (connection != NULL, FALSE); 5200 _dbus_return_val_if_fail (data != NULL, FALSE); 5201 _dbus_return_val_if_fail (data_size != NULL, FALSE); 5202 5203 CONNECTION_LOCK (connection); 5204 5205 if (!_dbus_transport_get_is_authenticated (connection->transport)) 5206 result = FALSE; 5207 else 5208 result = _dbus_transport_get_adt_audit_session_data (connection->transport, 5209 data, 5210 data_size); 5211 CONNECTION_UNLOCK (connection); 5212 5213 return result; 5214 } 5215 5216 /** 5217 * Sets a predicate function used to determine whether a given user ID 5218 * is allowed to connect. When an incoming connection has 5219 * authenticated with a particular user ID, this function is called; 5220 * if it returns #TRUE, the connection is allowed to proceed, 5221 * otherwise the connection is disconnected. 5222 * 5223 * If the function is set to #NULL (as it is by default), then 5224 * only the same UID as the server process will be allowed to 5225 * connect. Also, root is always allowed to connect. 5226 * 5227 * On Windows, the function will be set and its free_data_function will 5228 * be invoked when the connection is freed or a new function is set. 5229 * However, the function will never be called, because there are 5230 * no UNIX user ids to pass to it, or at least none of the existing 5231 * auth protocols would allow authenticating as a UNIX user on Windows. 5232 * 5233 * @param connection the connection 5234 * @param function the predicate 5235 * @param data data to pass to the predicate 5236 * @param free_data_function function to free the data 5237 */ 5238 void 5239 dbus_connection_set_unix_user_function (DBusConnection *connection, 5240 DBusAllowUnixUserFunction function, 5241 void *data, 5242 DBusFreeFunction free_data_function) 5243 { 5244 void *old_data = NULL; 5245 DBusFreeFunction old_free_function = NULL; 5246 5247 _dbus_return_if_fail (connection != NULL); 5248 5249 CONNECTION_LOCK (connection); 5250 _dbus_transport_set_unix_user_function (connection->transport, 5251 function, data, free_data_function, 5252 &old_data, &old_free_function); 5253 CONNECTION_UNLOCK (connection); 5254 5255 if (old_free_function != NULL) 5256 (* old_free_function) (old_data); 5257 } 5258 5259 /** 5260 * Gets the Windows user SID of the connection if known. Returns 5261 * #TRUE if the ID is filled in. Always returns #FALSE on non-Windows 5262 * platforms for now, though in theory someone could hook UNIX to 5263 * Active Directory or something. Always returns #FALSE prior to 5264 * authenticating the connection. 5265 * 5266 * The user is only read by servers from clients; clients can't usually 5267 * get the user of servers, because servers do not authenticate to 5268 * clients. The returned user is the user the connection authenticated 5269 * as. 5270 * 5271 * The message bus is a server and the apps connecting to the bus 5272 * are clients. 5273 * 5274 * The returned user string has to be freed with dbus_free(). 5275 * 5276 * The return value indicates whether the user SID is available; 5277 * if it's available but we don't have the memory to copy it, 5278 * then the return value is #TRUE and #NULL is given as the SID. 5279 * 5280 * @todo We would like to be able to say "You can ask the bus to tell 5281 * you the user of another connection though if you like; this is done 5282 * with dbus_bus_get_windows_user()." But this has to be implemented 5283 * in bus/driver.c and dbus/dbus-bus.c, and is pointless anyway 5284 * since on Windows we only use the session bus for now. 5285 * 5286 * @param connection the connection 5287 * @param windows_sid_p return location for an allocated copy of the user ID, or #NULL if no memory 5288 * @returns #TRUE if user is available (returned value may be #NULL anyway if no memory) 5289 */ 5290 dbus_bool_t 5291 dbus_connection_get_windows_user (DBusConnection *connection, 5292 char **windows_sid_p) 5293 { 5294 dbus_bool_t result; 5295 5296 _dbus_return_val_if_fail (connection != NULL, FALSE); 5297 _dbus_return_val_if_fail (windows_sid_p != NULL, FALSE); 5298 5299 CONNECTION_LOCK (connection); 5300 5301 if (!_dbus_transport_get_is_authenticated (connection->transport)) 5302 result = FALSE; 5303 else 5304 result = _dbus_transport_get_windows_user (connection->transport, 5305 windows_sid_p); 5306 5307 #ifdef DBUS_UNIX 5308 _dbus_assert (!result); 5309 #endif 5310 5311 CONNECTION_UNLOCK (connection); 5312 5313 return result; 5314 } 5315 5316 /** 5317 * Sets a predicate function used to determine whether a given user ID 5318 * is allowed to connect. When an incoming connection has 5319 * authenticated with a particular user ID, this function is called; 5320 * if it returns #TRUE, the connection is allowed to proceed, 5321 * otherwise the connection is disconnected. 5322 * 5323 * If the function is set to #NULL (as it is by default), then 5324 * only the same user owning the server process will be allowed to 5325 * connect. 5326 * 5327 * On UNIX, the function will be set and its free_data_function will 5328 * be invoked when the connection is freed or a new function is set. 5329 * However, the function will never be called, because there is no 5330 * way right now to authenticate as a Windows user on UNIX. 5331 * 5332 * @param connection the connection 5333 * @param function the predicate 5334 * @param data data to pass to the predicate 5335 * @param free_data_function function to free the data 5336 */ 5337 void 5338 dbus_connection_set_windows_user_function (DBusConnection *connection, 5339 DBusAllowWindowsUserFunction function, 5340 void *data, 5341 DBusFreeFunction free_data_function) 5342 { 5343 void *old_data = NULL; 5344 DBusFreeFunction old_free_function = NULL; 5345 5346 _dbus_return_if_fail (connection != NULL); 5347 5348 CONNECTION_LOCK (connection); 5349 _dbus_transport_set_windows_user_function (connection->transport, 5350 function, data, free_data_function, 5351 &old_data, &old_free_function); 5352 CONNECTION_UNLOCK (connection); 5353 5354 if (old_free_function != NULL) 5355 (* old_free_function) (old_data); 5356 } 5357 5358 /** 5359 * This function must be called on the server side of a connection when the 5360 * connection is first seen in the #DBusNewConnectionFunction. If set to 5361 * #TRUE (the default is #FALSE), then the connection can proceed even if 5362 * the client does not authenticate as some user identity, i.e. clients 5363 * can connect anonymously. 5364 * 5365 * This setting interacts with the available authorization mechanisms 5366 * (see dbus_server_set_auth_mechanisms()). Namely, an auth mechanism 5367 * such as ANONYMOUS that supports anonymous auth must be included in 5368 * the list of available mechanisms for anonymous login to work. 5369 * 5370 * This setting also changes the default rule for connections 5371 * authorized as a user; normally, if a connection authorizes as 5372 * a user identity, it is permitted if the user identity is 5373 * root or the user identity matches the user identity of the server 5374 * process. If anonymous connections are allowed, however, 5375 * then any user identity is allowed. 5376 * 5377 * You can override the rules for connections authorized as a 5378 * user identity with dbus_connection_set_unix_user_function() 5379 * and dbus_connection_set_windows_user_function(). 5380 * 5381 * @param connection the connection 5382 * @param value whether to allow authentication as an anonymous user 5383 */ 5384 void 5385 dbus_connection_set_allow_anonymous (DBusConnection *connection, 5386 dbus_bool_t value) 5387 { 5388 _dbus_return_if_fail (connection != NULL); 5389 5390 CONNECTION_LOCK (connection); 5391 _dbus_transport_set_allow_anonymous (connection->transport, value); 5392 CONNECTION_UNLOCK (connection); 5393 } 5394 5395 /** 5396 * 5397 * Normally #DBusConnection automatically handles all messages to the 5398 * org.freedesktop.DBus.Peer interface. However, the message bus wants 5399 * to be able to route methods on that interface through the bus and 5400 * to other applications. If routing peer messages is enabled, then 5401 * messages with the org.freedesktop.DBus.Peer interface that also 5402 * have a bus destination name set will not be automatically 5403 * handled by the #DBusConnection and instead will be dispatched 5404 * normally to the application. 5405 * 5406 * If a normal application sets this flag, it can break things badly. 5407 * So don't set this unless you are the message bus. 5408 * 5409 * @param connection the connection 5410 * @param value #TRUE to pass through org.freedesktop.DBus.Peer messages with a bus name set 5411 */ 5412 void 5413 dbus_connection_set_route_peer_messages (DBusConnection *connection, 5414 dbus_bool_t value) 5415 { 5416 _dbus_return_if_fail (connection != NULL); 5417 5418 CONNECTION_LOCK (connection); 5419 connection->route_peer_messages = TRUE; 5420 CONNECTION_UNLOCK (connection); 5421 } 5422 5423 /** 5424 * Adds a message filter. Filters are handlers that are run on all 5425 * incoming messages, prior to the objects registered with 5426 * dbus_connection_register_object_path(). Filters are run in the 5427 * order that they were added. The same handler can be added as a 5428 * filter more than once, in which case it will be run more than once. 5429 * Filters added during a filter callback won't be run on the message 5430 * being processed. 5431 * 5432 * @todo we don't run filters on messages while blocking without 5433 * entering the main loop, since filters are run as part of 5434 * dbus_connection_dispatch(). This is probably a feature, as filters 5435 * could create arbitrary reentrancy. But kind of sucks if you're 5436 * trying to filter METHOD_RETURN for some reason. 5437 * 5438 * @param connection the connection 5439 * @param function function to handle messages 5440 * @param user_data user data to pass to the function 5441 * @param free_data_function function to use for freeing user data 5442 * @returns #TRUE on success, #FALSE if not enough memory. 5443 */ 5444 dbus_bool_t 5445 dbus_connection_add_filter (DBusConnection *connection, 5446 DBusHandleMessageFunction function, 5447 void *user_data, 5448 DBusFreeFunction free_data_function) 5449 { 5450 DBusMessageFilter *filter; 5451 5452 _dbus_return_val_if_fail (connection != NULL, FALSE); 5453 _dbus_return_val_if_fail (function != NULL, FALSE); 5454 5455 filter = dbus_new0 (DBusMessageFilter, 1); 5456 if (filter == NULL) 5457 return FALSE; 5458 5459 filter->refcount.value = 1; 5460 5461 CONNECTION_LOCK (connection); 5462 5463 if (!_dbus_list_append (&connection->filter_list, 5464 filter)) 5465 { 5466 _dbus_message_filter_unref (filter); 5467 CONNECTION_UNLOCK (connection); 5468 return FALSE; 5469 } 5470 5471 /* Fill in filter after all memory allocated, 5472 * so we don't run the free_user_data_function 5473 * if the add_filter() fails 5474 */ 5475 5476 filter->function = function; 5477 filter->user_data = user_data; 5478 filter->free_user_data_function = free_data_function; 5479 5480 CONNECTION_UNLOCK (connection); 5481 return TRUE; 5482 } 5483 5484 /** 5485 * Removes a previously-added message filter. It is a programming 5486 * error to call this function for a handler that has not been added 5487 * as a filter. If the given handler was added more than once, only 5488 * one instance of it will be removed (the most recently-added 5489 * instance). 5490 * 5491 * @param connection the connection 5492 * @param function the handler to remove 5493 * @param user_data user data for the handler to remove 5494 * 5495 */ 5496 void 5497 dbus_connection_remove_filter (DBusConnection *connection, 5498 DBusHandleMessageFunction function, 5499 void *user_data) 5500 { 5501 DBusList *link; 5502 DBusMessageFilter *filter; 5503 5504 _dbus_return_if_fail (connection != NULL); 5505 _dbus_return_if_fail (function != NULL); 5506 5507 CONNECTION_LOCK (connection); 5508 5509 filter = NULL; 5510 5511 link = _dbus_list_get_last_link (&connection->filter_list); 5512 while (link != NULL) 5513 { 5514 filter = link->data; 5515 5516 if (filter->function == function && 5517 filter->user_data == user_data) 5518 { 5519 _dbus_list_remove_link (&connection->filter_list, link); 5520 filter->function = NULL; 5521 5522 break; 5523 } 5524 5525 link = _dbus_list_get_prev_link (&connection->filter_list, link); 5526 filter = NULL; 5527 } 5528 5529 CONNECTION_UNLOCK (connection); 5530 5531 #ifndef DBUS_DISABLE_CHECKS 5532 if (filter == NULL) 5533 { 5534 _dbus_warn_check_failed ("Attempt to remove filter function %p user data %p, but no such filter has been added\n", 5535 function, user_data); 5536 return; 5537 } 5538 #endif 5539 5540 /* Call application code */ 5541 if (filter->free_user_data_function) 5542 (* filter->free_user_data_function) (filter->user_data); 5543 5544 filter->free_user_data_function = NULL; 5545 filter->user_data = NULL; 5546 5547 _dbus_message_filter_unref (filter); 5548 } 5549 5550 /** 5551 * Registers a handler for a given path in the object hierarchy. 5552 * The given vtable handles messages sent to exactly the given path. 5553 * 5554 * @param connection the connection 5555 * @param path a '/' delimited string of path elements 5556 * @param vtable the virtual table 5557 * @param user_data data to pass to functions in the vtable 5558 * @param error address where an error can be returned 5559 * @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or 5560 * #DBUS_ERROR_ADDRESS_IN_USE) is reported 5561 */ 5562 dbus_bool_t 5563 dbus_connection_try_register_object_path (DBusConnection *connection, 5564 const char *path, 5565 const DBusObjectPathVTable *vtable, 5566 void *user_data, 5567 DBusError *error) 5568 { 5569 char **decomposed_path; 5570 dbus_bool_t retval; 5571 5572 _dbus_return_val_if_fail (connection != NULL, FALSE); 5573 _dbus_return_val_if_fail (path != NULL, FALSE); 5574 _dbus_return_val_if_fail (path[0] == '/', FALSE); 5575 _dbus_return_val_if_fail (vtable != NULL, FALSE); 5576 5577 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5578 return FALSE; 5579 5580 CONNECTION_LOCK (connection); 5581 5582 retval = _dbus_object_tree_register (connection->objects, 5583 FALSE, 5584 (const char **) decomposed_path, vtable, 5585 user_data, error); 5586 5587 CONNECTION_UNLOCK (connection); 5588 5589 dbus_free_string_array (decomposed_path); 5590 5591 return retval; 5592 } 5593 5594 /** 5595 * Registers a handler for a given path in the object hierarchy. 5596 * The given vtable handles messages sent to exactly the given path. 5597 * 5598 * It is a bug to call this function for object paths which already 5599 * have a handler. Use dbus_connection_try_register_object_path() if this 5600 * might be the case. 5601 * 5602 * @param connection the connection 5603 * @param path a '/' delimited string of path elements 5604 * @param vtable the virtual table 5605 * @param user_data data to pass to functions in the vtable 5606 * @returns #FALSE if not enough memory 5607 */ 5608 dbus_bool_t 5609 dbus_connection_register_object_path (DBusConnection *connection, 5610 const char *path, 5611 const DBusObjectPathVTable *vtable, 5612 void *user_data) 5613 { 5614 char **decomposed_path; 5615 dbus_bool_t retval; 5616 DBusError error = DBUS_ERROR_INIT; 5617 5618 _dbus_return_val_if_fail (connection != NULL, FALSE); 5619 _dbus_return_val_if_fail (path != NULL, FALSE); 5620 _dbus_return_val_if_fail (path[0] == '/', FALSE); 5621 _dbus_return_val_if_fail (vtable != NULL, FALSE); 5622 5623 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5624 return FALSE; 5625 5626 CONNECTION_LOCK (connection); 5627 5628 retval = _dbus_object_tree_register (connection->objects, 5629 FALSE, 5630 (const char **) decomposed_path, vtable, 5631 user_data, &error); 5632 5633 CONNECTION_UNLOCK (connection); 5634 5635 dbus_free_string_array (decomposed_path); 5636 5637 if (dbus_error_has_name (&error, DBUS_ERROR_ADDRESS_IN_USE)) 5638 { 5639 _dbus_warn ("%s\n", error.message); 5640 dbus_error_free (&error); 5641 return FALSE; 5642 } 5643 5644 return retval; 5645 } 5646 5647 /** 5648 * Registers a fallback handler for a given subsection of the object 5649 * hierarchy. The given vtable handles messages at or below the given 5650 * path. You can use this to establish a default message handling 5651 * policy for a whole "subdirectory." 5652 * 5653 * @param connection the connection 5654 * @param path a '/' delimited string of path elements 5655 * @param vtable the virtual table 5656 * @param user_data data to pass to functions in the vtable 5657 * @param error address where an error can be returned 5658 * @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or 5659 * #DBUS_ERROR_ADDRESS_IN_USE) is reported 5660 */ 5661 dbus_bool_t 5662 dbus_connection_try_register_fallback (DBusConnection *connection, 5663 const char *path, 5664 const DBusObjectPathVTable *vtable, 5665 void *user_data, 5666 DBusError *error) 5667 { 5668 char **decomposed_path; 5669 dbus_bool_t retval; 5670 5671 _dbus_return_val_if_fail (connection != NULL, FALSE); 5672 _dbus_return_val_if_fail (path != NULL, FALSE); 5673 _dbus_return_val_if_fail (path[0] == '/', FALSE); 5674 _dbus_return_val_if_fail (vtable != NULL, FALSE); 5675 5676 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5677 return FALSE; 5678 5679 CONNECTION_LOCK (connection); 5680 5681 retval = _dbus_object_tree_register (connection->objects, 5682 TRUE, 5683 (const char **) decomposed_path, vtable, 5684 user_data, error); 5685 5686 CONNECTION_UNLOCK (connection); 5687 5688 dbus_free_string_array (decomposed_path); 5689 5690 return retval; 5691 } 5692 5693 /** 5694 * Registers a fallback handler for a given subsection of the object 5695 * hierarchy. The given vtable handles messages at or below the given 5696 * path. You can use this to establish a default message handling 5697 * policy for a whole "subdirectory." 5698 * 5699 * It is a bug to call this function for object paths which already 5700 * have a handler. Use dbus_connection_try_register_fallback() if this 5701 * might be the case. 5702 * 5703 * @param connection the connection 5704 * @param path a '/' delimited string of path elements 5705 * @param vtable the virtual table 5706 * @param user_data data to pass to functions in the vtable 5707 * @returns #FALSE if not enough memory 5708 */ 5709 dbus_bool_t 5710 dbus_connection_register_fallback (DBusConnection *connection, 5711 const char *path, 5712 const DBusObjectPathVTable *vtable, 5713 void *user_data) 5714 { 5715 char **decomposed_path; 5716 dbus_bool_t retval; 5717 DBusError error = DBUS_ERROR_INIT; 5718 5719 _dbus_return_val_if_fail (connection != NULL, FALSE); 5720 _dbus_return_val_if_fail (path != NULL, FALSE); 5721 _dbus_return_val_if_fail (path[0] == '/', FALSE); 5722 _dbus_return_val_if_fail (vtable != NULL, FALSE); 5723 5724 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5725 return FALSE; 5726 5727 CONNECTION_LOCK (connection); 5728 5729 retval = _dbus_object_tree_register (connection->objects, 5730 TRUE, 5731 (const char **) decomposed_path, vtable, 5732 user_data, &error); 5733 5734 CONNECTION_UNLOCK (connection); 5735 5736 dbus_free_string_array (decomposed_path); 5737 5738 if (dbus_error_has_name (&error, DBUS_ERROR_ADDRESS_IN_USE)) 5739 { 5740 _dbus_warn ("%s\n", error.message); 5741 dbus_error_free (&error); 5742 return FALSE; 5743 } 5744 5745 return retval; 5746 } 5747 5748 /** 5749 * Unregisters the handler registered with exactly the given path. 5750 * It's a bug to call this function for a path that isn't registered. 5751 * Can unregister both fallback paths and object paths. 5752 * 5753 * @param connection the connection 5754 * @param path a '/' delimited string of path elements 5755 * @returns #FALSE if not enough memory 5756 */ 5757 dbus_bool_t 5758 dbus_connection_unregister_object_path (DBusConnection *connection, 5759 const char *path) 5760 { 5761 char **decomposed_path; 5762 5763 _dbus_return_val_if_fail (connection != NULL, FALSE); 5764 _dbus_return_val_if_fail (path != NULL, FALSE); 5765 _dbus_return_val_if_fail (path[0] == '/', FALSE); 5766 5767 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5768 return FALSE; 5769 5770 CONNECTION_LOCK (connection); 5771 5772 _dbus_object_tree_unregister_and_unlock (connection->objects, (const char **) decomposed_path); 5773 5774 dbus_free_string_array (decomposed_path); 5775 5776 return TRUE; 5777 } 5778 5779 /** 5780 * Gets the user data passed to dbus_connection_register_object_path() 5781 * or dbus_connection_register_fallback(). If nothing was registered 5782 * at this path, the data is filled in with #NULL. 5783 * 5784 * @param connection the connection 5785 * @param path the path you registered with 5786 * @param data_p location to store the user data, or #NULL 5787 * @returns #FALSE if not enough memory 5788 */ 5789 dbus_bool_t 5790 dbus_connection_get_object_path_data (DBusConnection *connection, 5791 const char *path, 5792 void **data_p) 5793 { 5794 char **decomposed_path; 5795 5796 _dbus_return_val_if_fail (connection != NULL, FALSE); 5797 _dbus_return_val_if_fail (path != NULL, FALSE); 5798 _dbus_return_val_if_fail (data_p != NULL, FALSE); 5799 5800 *data_p = NULL; 5801 5802 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL)) 5803 return FALSE; 5804 5805 CONNECTION_LOCK (connection); 5806 5807 *data_p = _dbus_object_tree_get_user_data_unlocked (connection->objects, (const char**) decomposed_path); 5808 5809 CONNECTION_UNLOCK (connection); 5810 5811 dbus_free_string_array (decomposed_path); 5812 5813 return TRUE; 5814 } 5815 5816 /** 5817 * Lists the registered fallback handlers and object path handlers at 5818 * the given parent_path. The returned array should be freed with 5819 * dbus_free_string_array(). 5820 * 5821 * @param connection the connection 5822 * @param parent_path the path to list the child handlers of 5823 * @param child_entries returns #NULL-terminated array of children 5824 * @returns #FALSE if no memory to allocate the child entries 5825 */ 5826 dbus_bool_t 5827 dbus_connection_list_registered (DBusConnection *connection, 5828 const char *parent_path, 5829 char ***child_entries) 5830 { 5831 char **decomposed_path; 5832 dbus_bool_t retval; 5833 _dbus_return_val_if_fail (connection != NULL, FALSE); 5834 _dbus_return_val_if_fail (parent_path != NULL, FALSE); 5835 _dbus_return_val_if_fail (parent_path[0] == '/', FALSE); 5836 _dbus_return_val_if_fail (child_entries != NULL, FALSE); 5837 5838 if (!_dbus_decompose_path (parent_path, strlen (parent_path), &decomposed_path, NULL)) 5839 return FALSE; 5840 5841 CONNECTION_LOCK (connection); 5842 5843 retval = _dbus_object_tree_list_registered_and_unlock (connection->objects, 5844 (const char **) decomposed_path, 5845 child_entries); 5846 dbus_free_string_array (decomposed_path); 5847 5848 return retval; 5849 } 5850 5851 static DBusDataSlotAllocator slot_allocator; 5852 _DBUS_DEFINE_GLOBAL_LOCK (connection_slots); 5853 5854 /** 5855 * Allocates an integer ID to be used for storing application-specific 5856 * data on any DBusConnection. The allocated ID may then be used 5857 * with dbus_connection_set_data() and dbus_connection_get_data(). 5858 * The passed-in slot must be initialized to -1, and is filled in 5859 * with the slot ID. If the passed-in slot is not -1, it's assumed 5860 * to be already allocated, and its refcount is incremented. 5861 * 5862 * The allocated slot is global, i.e. all DBusConnection objects will 5863 * have a slot with the given integer ID reserved. 5864 * 5865 * @param slot_p address of a global variable storing the slot 5866 * @returns #FALSE on failure (no memory) 5867 */ 5868 dbus_bool_t 5869 dbus_connection_allocate_data_slot (dbus_int32_t *slot_p) 5870 { 5871 return _dbus_data_slot_allocator_alloc (&slot_allocator, 5872 &_DBUS_LOCK_NAME (connection_slots), 5873 slot_p); 5874 } 5875 5876 /** 5877 * Deallocates a global ID for connection data slots. 5878 * dbus_connection_get_data() and dbus_connection_set_data() may no 5879 * longer be used with this slot. Existing data stored on existing 5880 * DBusConnection objects will be freed when the connection is 5881 * finalized, but may not be retrieved (and may only be replaced if 5882 * someone else reallocates the slot). When the refcount on the 5883 * passed-in slot reaches 0, it is set to -1. 5884 * 5885 * @param slot_p address storing the slot to deallocate 5886 */ 5887 void 5888 dbus_connection_free_data_slot (dbus_int32_t *slot_p) 5889 { 5890 _dbus_return_if_fail (*slot_p >= 0); 5891 5892 _dbus_data_slot_allocator_free (&slot_allocator, slot_p); 5893 } 5894 5895 /** 5896 * Stores a pointer on a DBusConnection, along 5897 * with an optional function to be used for freeing 5898 * the data when the data is set again, or when 5899 * the connection is finalized. The slot number 5900 * must have been allocated with dbus_connection_allocate_data_slot(). 5901 * 5902 * @note This function does not take the 5903 * main thread lock on DBusConnection, which allows it to be 5904 * used from inside watch and timeout functions. (See the 5905 * note in docs for dbus_connection_set_watch_functions().) 5906 * A side effect of this is that you need to know there's 5907 * a reference held on the connection while invoking 5908 * dbus_connection_set_data(), or the connection could be 5909 * finalized during dbus_connection_set_data(). 5910 * 5911 * @param connection the connection 5912 * @param slot the slot number 5913 * @param data the data to store 5914 * @param free_data_func finalizer function for the data 5915 * @returns #TRUE if there was enough memory to store the data 5916 */ 5917 dbus_bool_t 5918 dbus_connection_set_data (DBusConnection *connection, 5919 dbus_int32_t slot, 5920 void *data, 5921 DBusFreeFunction free_data_func) 5922 { 5923 DBusFreeFunction old_free_func; 5924 void *old_data; 5925 dbus_bool_t retval; 5926 5927 _dbus_return_val_if_fail (connection != NULL, FALSE); 5928 _dbus_return_val_if_fail (slot >= 0, FALSE); 5929 5930 SLOTS_LOCK (connection); 5931 5932 retval = _dbus_data_slot_list_set (&slot_allocator, 5933 &connection->slot_list, 5934 slot, data, free_data_func, 5935 &old_free_func, &old_data); 5936 5937 SLOTS_UNLOCK (connection); 5938 5939 if (retval) 5940 { 5941 /* Do the actual free outside the connection lock */ 5942 if (old_free_func) 5943 (* old_free_func) (old_data); 5944 } 5945 5946 return retval; 5947 } 5948 5949 /** 5950 * Retrieves data previously set with dbus_connection_set_data(). 5951 * The slot must still be allocated (must not have been freed). 5952 * 5953 * @note This function does not take the 5954 * main thread lock on DBusConnection, which allows it to be 5955 * used from inside watch and timeout functions. (See the 5956 * note in docs for dbus_connection_set_watch_functions().) 5957 * A side effect of this is that you need to know there's 5958 * a reference held on the connection while invoking 5959 * dbus_connection_get_data(), or the connection could be 5960 * finalized during dbus_connection_get_data(). 5961 * 5962 * @param connection the connection 5963 * @param slot the slot to get data from 5964 * @returns the data, or #NULL if not found 5965 */ 5966 void* 5967 dbus_connection_get_data (DBusConnection *connection, 5968 dbus_int32_t slot) 5969 { 5970 void *res; 5971 5972 _dbus_return_val_if_fail (connection != NULL, NULL); 5973 5974 SLOTS_LOCK (connection); 5975 5976 res = _dbus_data_slot_list_get (&slot_allocator, 5977 &connection->slot_list, 5978 slot); 5979 5980 SLOTS_UNLOCK (connection); 5981 5982 return res; 5983 } 5984 5985 /** 5986 * This function sets a global flag for whether dbus_connection_new() 5987 * will set SIGPIPE behavior to SIG_IGN. 5988 * 5989 * @param will_modify_sigpipe #TRUE to allow sigpipe to be set to SIG_IGN 5990 */ 5991 void 5992 dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe) 5993 { 5994 _dbus_modify_sigpipe = will_modify_sigpipe != FALSE; 5995 } 5996 5997 /** 5998 * Specifies the maximum size message this connection is allowed to 5999 * receive. Larger messages will result in disconnecting the 6000 * connection. 6001 * 6002 * @param connection a #DBusConnection 6003 * @param size maximum message size the connection can receive, in bytes 6004 */ 6005 void 6006 dbus_connection_set_max_message_size (DBusConnection *connection, 6007 long size) 6008 { 6009 _dbus_return_if_fail (connection != NULL); 6010 6011 CONNECTION_LOCK (connection); 6012 _dbus_transport_set_max_message_size (connection->transport, 6013 size); 6014 CONNECTION_UNLOCK (connection); 6015 } 6016 6017 /** 6018 * Gets the value set by dbus_connection_set_max_message_size(). 6019 * 6020 * @param connection the connection 6021 * @returns the max size of a single message 6022 */ 6023 long 6024 dbus_connection_get_max_message_size (DBusConnection *connection) 6025 { 6026 long res; 6027 6028 _dbus_return_val_if_fail (connection != NULL, 0); 6029 6030 CONNECTION_LOCK (connection); 6031 res = _dbus_transport_get_max_message_size (connection->transport); 6032 CONNECTION_UNLOCK (connection); 6033 return res; 6034 } 6035 6036 /** 6037 * Specifies the maximum number of unix fds a message on this 6038 * connection is allowed to receive. Messages with more unix fds will 6039 * result in disconnecting the connection. 6040 * 6041 * @param connection a #DBusConnection 6042 * @param size maximum message unix fds the connection can receive 6043 */ 6044 void 6045 dbus_connection_set_max_message_unix_fds (DBusConnection *connection, 6046 long n) 6047 { 6048 _dbus_return_if_fail (connection != NULL); 6049 6050 CONNECTION_LOCK (connection); 6051 _dbus_transport_set_max_message_unix_fds (connection->transport, 6052 n); 6053 CONNECTION_UNLOCK (connection); 6054 } 6055 6056 /** 6057 * Gets the value set by dbus_connection_set_max_message_unix_fds(). 6058 * 6059 * @param connection the connection 6060 * @returns the max numer of unix fds of a single message 6061 */ 6062 long 6063 dbus_connection_get_max_message_unix_fds (DBusConnection *connection) 6064 { 6065 long res; 6066 6067 _dbus_return_val_if_fail (connection != NULL, 0); 6068 6069 CONNECTION_LOCK (connection); 6070 res = _dbus_transport_get_max_message_unix_fds (connection->transport); 6071 CONNECTION_UNLOCK (connection); 6072 return res; 6073 } 6074 6075 /** 6076 * Sets the maximum total number of bytes that can be used for all messages 6077 * received on this connection. Messages count toward the maximum until 6078 * they are finalized. When the maximum is reached, the connection will 6079 * not read more data until some messages are finalized. 6080 * 6081 * The semantics of the maximum are: if outstanding messages are 6082 * already above the maximum, additional messages will not be read. 6083 * The semantics are not: if the next message would cause us to exceed 6084 * the maximum, we don't read it. The reason is that we don't know the 6085 * size of a message until after we read it. 6086 * 6087 * Thus, the max live messages size can actually be exceeded 6088 * by up to the maximum size of a single message. 6089 * 6090 * Also, if we read say 1024 bytes off the wire in a single read(), 6091 * and that contains a half-dozen small messages, we may exceed the 6092 * size max by that amount. But this should be inconsequential. 6093 * 6094 * This does imply that we can't call read() with a buffer larger 6095 * than we're willing to exceed this limit by. 6096 * 6097 * @param connection the connection 6098 * @param size the maximum size in bytes of all outstanding messages 6099 */ 6100 void 6101 dbus_connection_set_max_received_size (DBusConnection *connection, 6102 long size) 6103 { 6104 _dbus_return_if_fail (connection != NULL); 6105 6106 CONNECTION_LOCK (connection); 6107 _dbus_transport_set_max_received_size (connection->transport, 6108 size); 6109 CONNECTION_UNLOCK (connection); 6110 } 6111 6112 /** 6113 * Gets the value set by dbus_connection_set_max_received_size(). 6114 * 6115 * @param connection the connection 6116 * @returns the max size of all live messages 6117 */ 6118 long 6119 dbus_connection_get_max_received_size (DBusConnection *connection) 6120 { 6121 long res; 6122 6123 _dbus_return_val_if_fail (connection != NULL, 0); 6124 6125 CONNECTION_LOCK (connection); 6126 res = _dbus_transport_get_max_received_size (connection->transport); 6127 CONNECTION_UNLOCK (connection); 6128 return res; 6129 } 6130 6131 /** 6132 * Sets the maximum total number of unix fds that can be used for all messages 6133 * received on this connection. Messages count toward the maximum until 6134 * they are finalized. When the maximum is reached, the connection will 6135 * not read more data until some messages are finalized. 6136 * 6137 * The semantics are analogous to those of dbus_connection_set_max_received_size(). 6138 * 6139 * @param connection the connection 6140 * @param size the maximum size in bytes of all outstanding messages 6141 */ 6142 void 6143 dbus_connection_set_max_received_unix_fds (DBusConnection *connection, 6144 long n) 6145 { 6146 _dbus_return_if_fail (connection != NULL); 6147 6148 CONNECTION_LOCK (connection); 6149 _dbus_transport_set_max_received_unix_fds (connection->transport, 6150 n); 6151 CONNECTION_UNLOCK (connection); 6152 } 6153 6154 /** 6155 * Gets the value set by dbus_connection_set_max_received_unix_fds(). 6156 * 6157 * @param connection the connection 6158 * @returns the max unix fds of all live messages 6159 */ 6160 long 6161 dbus_connection_get_max_received_unix_fds (DBusConnection *connection) 6162 { 6163 long res; 6164 6165 _dbus_return_val_if_fail (connection != NULL, 0); 6166 6167 CONNECTION_LOCK (connection); 6168 res = _dbus_transport_get_max_received_unix_fds (connection->transport); 6169 CONNECTION_UNLOCK (connection); 6170 return res; 6171 } 6172 6173 /** 6174 * Gets the approximate size in bytes of all messages in the outgoing 6175 * message queue. The size is approximate in that you shouldn't use 6176 * it to decide how many bytes to read off the network or anything 6177 * of that nature, as optimizations may choose to tell small white lies 6178 * to avoid performance overhead. 6179 * 6180 * @param connection the connection 6181 * @returns the number of bytes that have been queued up but not sent 6182 */ 6183 long 6184 dbus_connection_get_outgoing_size (DBusConnection *connection) 6185 { 6186 long res; 6187 6188 _dbus_return_val_if_fail (connection != NULL, 0); 6189 6190 CONNECTION_LOCK (connection); 6191 res = _dbus_counter_get_size_value (connection->outgoing_counter); 6192 CONNECTION_UNLOCK (connection); 6193 return res; 6194 } 6195 6196 /** 6197 * Gets the approximate number of uni fds of all messages in the 6198 * outgoing message queue. 6199 * 6200 * @param connection the connection 6201 * @returns the number of unix fds that have been queued up but not sent 6202 */ 6203 long 6204 dbus_connection_get_outgoing_unix_fds (DBusConnection *connection) 6205 { 6206 long res; 6207 6208 _dbus_return_val_if_fail (connection != NULL, 0); 6209 6210 CONNECTION_LOCK (connection); 6211 res = _dbus_counter_get_unix_fd_value (connection->outgoing_counter); 6212 CONNECTION_UNLOCK (connection); 6213 return res; 6214 } 6215 6216 /** @} */ 6217
