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-signature.h"    42 #include "dbus-pending-call.h"    43 #include "dbus-object-tree.h"    44 #include "dbus-threads-internal.h"    46 #include "dbus-marshal-basic.h"    48 #ifdef DBUS_DISABLE_CHECKS    49 #define TOOK_LOCK_CHECK(connection)    50 #define RELEASING_LOCK_CHECK(connection)    51 #define HAVE_LOCK_CHECK(connection)    53 #define TOOK_LOCK_CHECK(connection) do {                \    54     _dbus_assert (!(connection)->have_connection_lock); \    55     (connection)->have_connection_lock = TRUE;          \    57 #define RELEASING_LOCK_CHECK(connection) do {            \    58     _dbus_assert ((connection)->have_connection_lock);   \    59     (connection)->have_connection_lock = FALSE;          \    61 #define HAVE_LOCK_CHECK(connection)        _dbus_assert ((connection)->have_connection_lock)    67 #define CONNECTION_LOCK(connection)   do {                                      \    68     if (TRACE_LOCKS) { _dbus_verbose ("LOCK\n"); }   \    69     _dbus_rmutex_lock ((connection)->mutex);                                    \    70     TOOK_LOCK_CHECK (connection);                                               \    73 #define CONNECTION_UNLOCK(connection) _dbus_connection_unlock (connection)    75 #define SLOTS_LOCK(connection) do {                     \    76     _dbus_rmutex_lock ((connection)->slot_mutex);       \    79 #define SLOTS_UNLOCK(connection) do {                   \    80     _dbus_rmutex_unlock ((connection)->slot_mutex);     \    83 #define DISPATCH_STATUS_NAME(s)                                            \    84                      ((s) == DBUS_DISPATCH_COMPLETE ? "complete" :         \    85                       (s) == DBUS_DISPATCH_DATA_REMAINS ? "data remains" : \    86                       (s) == DBUS_DISPATCH_NEED_MEMORY ? "need memory" :   \   212 #ifdef DBUS_ENABLE_VERBOSE_MODE   213   static int enabled = -1;
   215   _dbus_trace_ref (
"DBusConnection", connection, old_refcount, new_refcount,
   216       why, 
"DBUS_CONNECTION_TRACE", &enabled);
   247 #if HAVE_DECL_MSG_NOSIGNAL   329 #ifndef DBUS_DISABLE_CHECKS   333 #if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)   339 static void               _dbus_connection_update_dispatch_status_and_unlock (
DBusConnection     *connection,
   341 static void               _dbus_connection_last_unref                        (
DBusConnection     *connection);
   342 static void               _dbus_connection_acquire_dispatch                  (
DBusConnection     *connection);
   343 static void               _dbus_connection_release_dispatch                  (
DBusConnection     *connection);
   345 static void               _dbus_connection_close_possibly_shared_and_unlock  (
DBusConnection     *connection);
   348                                                                               dbus_uint32_t       client_serial);
   353 #ifdef DBUS_DISABLE_ASSERT   356   dbus_int32_t old_value;
   368   dbus_int32_t old_value;
   406       _dbus_verbose (
"UNLOCK\n");
   414   RELEASING_LOCK_CHECK (connection);
   442 #ifdef DBUS_ENABLE_EMBEDDED_TESTS   484   dbus_uint32_t reply_serial;
   491   message = link->
data;
   495   if (reply_serial != 0)
   513   _dbus_connection_wakeup_mainloop (connection);
   515   _dbus_verbose (
"Message %p (%s %s %s %s '%s' reply to %u) added to incoming queue %p, %d incoming\n",
   532   _dbus_message_trace_ref (message, -1, -1,
   533       "_dbus_conection_queue_received_message_link");
   548   HAVE_LOCK_CHECK (connection);
   554   _dbus_connection_wakeup_mainloop (connection);
   556   _dbus_message_trace_ref (link->
data, -1, -1,
   557       "_dbus_connection_queue_synthesized_message_link");
   559   _dbus_verbose (
"Synthesized message %p added to incoming queue %p, %d incoming\n",
   574   HAVE_LOCK_CHECK (connection);
   592   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
   611   HAVE_LOCK_CHECK (connection);
   630   HAVE_LOCK_CHECK (connection);
   647   _dbus_verbose (
"Message %p (%s %s %s %s '%s') removed from outgoing queue %p, %d left to send\n",
   690   HAVE_LOCK_CHECK (connection);
   713         retval = (* add_function) (connection->
watches, watch);
   714       else if (remove_function)
   717           (* remove_function) (connection->
watches, watch);
   722           (* toggle_function) (connection->
watches, watch, enabled);
   746   return protected_change_watch (connection, watch,
   764   protected_change_watch (connection, watch,
   787   protected_change_watch (connection, watch,
   814   HAVE_LOCK_CHECK (connection);
   837         retval = (* add_function) (connection->
timeouts, timeout);
   838       else if (remove_function)
   841           (* remove_function) (connection->
timeouts, timeout);
   846           (* toggle_function) (connection->
timeouts, timeout, enabled);
   870   return protected_change_timeout (connection, timeout,
   888   protected_change_timeout (connection, timeout,
   909   protected_change_timeout (connection, timeout,
   916 _dbus_connection_attach_pending_call_unlocked (
DBusConnection  *connection,
   919   dbus_uint32_t reply_serial;
   922   HAVE_LOCK_CHECK (connection);
   942           HAVE_LOCK_CHECK (connection);
   954           HAVE_LOCK_CHECK (connection);
   961   HAVE_LOCK_CHECK (connection);
   967 free_pending_call_on_hash_removal (
void *data)
   979   HAVE_LOCK_CHECK (connection);
  1001 _dbus_connection_detach_pending_call_unlocked (
DBusConnection  *connection,
  1012 _dbus_connection_detach_pending_call_and_unlock (
DBusConnection  *connection,
  1048   _dbus_connection_detach_pending_call_and_unlock (connection, pending);
  1062                                   int             timeout_milliseconds)
  1066   HAVE_LOCK_CHECK (connection);
  1074   _dbus_verbose (
"locking io_path_mutex\n");
  1077   _dbus_verbose (
"start connection->io_path_acquired = %d timeout = %d\n",
  1080   we_acquired = 
FALSE;
  1084       if (timeout_milliseconds != -1)
  1086           _dbus_verbose (
"waiting %d for IO path to be acquirable\n",
  1087                          timeout_milliseconds);
  1091                                            timeout_milliseconds))
  1107               _dbus_verbose (
"waiting for IO path to be acquirable\n");
  1120   _dbus_verbose (
"end connection->io_path_acquired = %d we_acquired = %d\n",
  1123   _dbus_verbose (
"unlocking io_path_mutex\n");
  1128   HAVE_LOCK_CHECK (connection);
  1145   HAVE_LOCK_CHECK (connection);
  1147   _dbus_verbose (
"locking io_path_mutex\n");
  1152   _dbus_verbose (
"start connection->io_path_acquired = %d\n",
  1158   _dbus_verbose (
"unlocking io_path_mutex\n");
  1201                                         int             timeout_milliseconds)
  1203   _dbus_verbose (
"start\n");
  1205   HAVE_LOCK_CHECK (connection);
  1208     flags &= ~DBUS_ITERATION_DO_WRITING;
  1210   if (_dbus_connection_acquire_io_path (connection,
  1211                                         (flags & DBUS_ITERATION_BLOCK) ? timeout_milliseconds : 0))
  1213       HAVE_LOCK_CHECK (connection);
  1217           _dbus_verbose (
"pending call completed while acquiring I/O path");
  1219       else if ( (pending != 
NULL) &&
  1220                 _dbus_connection_peek_for_reply_unlocked (connection,
  1223           _dbus_verbose (
"pending call completed while acquiring I/O path (reply found in queue)");
  1228                                         flags, timeout_milliseconds);
  1231       _dbus_connection_release_io_path (connection);
  1234   HAVE_LOCK_CHECK (connection);
  1236   _dbus_verbose (
"end\n");
  1262   pending_replies = 
NULL;
  1263   timeout_list = 
NULL;
  1264   disconnect_link = 
NULL;
  1265   disconnect_message = 
NULL;
  1266   outgoing_counter = 
NULL;
  1270   if (watch_list == 
NULL)
  1274   if (timeout_list == 
NULL)
  1281   if (pending_replies == 
NULL)
  1285   if (connection == 
NULL)
  1316   if (disconnect_message == 
NULL)
  1320   if (disconnect_link == 
NULL)
  1324   if (outgoing_counter == 
NULL)
  1328   if (objects == 
NULL)
  1331   if (_dbus_modify_sigpipe)
  1337   connection->
watches = watch_list;
  1338   connection->
timeouts = timeout_list;
  1343   connection->
objects = objects;
  1350 #if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)  1373   _dbus_connection_trace_ref (connection, 0, 1, 
"new_for_transport");
  1377   if (disconnect_message != 
NULL)
  1380   if (disconnect_link != 
NULL)
  1383   if (connection != 
NULL)
  1393   if (pending_replies)
  1402   if (outgoing_counter)
  1421   dbus_int32_t old_refcount;
  1426   HAVE_LOCK_CHECK (connection);
  1429   _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
  1444   dbus_int32_t old_refcount;
  1446   HAVE_LOCK_CHECK (connection);
  1452   _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
  1455   if (old_refcount == 1)
  1456     _dbus_connection_last_unref (connection);
  1459 static dbus_uint32_t
  1460 _dbus_connection_get_next_client_serial (
DBusConnection *connection)
  1462   dbus_uint32_t serial;
  1487                                unsigned int                 condition,
  1496   _dbus_verbose (
"start\n");
  1500   if (!_dbus_connection_acquire_io_path (connection, 1))
  1507   HAVE_LOCK_CHECK (connection);
  1511   _dbus_connection_release_io_path (connection);
  1513   HAVE_LOCK_CHECK (connection);
  1515   _dbus_verbose (
"middle\n");
  1517   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  1520   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  1522   _dbus_verbose (
"end\n");
  1548 shared_connections_shutdown (
void *data)
  1571       close_connection_on_shutdown (connection);
  1582   shared_connections = 
NULL;
  1584   if (shared_connections_no_guid != 
NULL)
  1588       while (connection != 
NULL)
  1591           close_connection_on_shutdown (connection);
  1598   shared_connections_no_guid = 
NULL;
  1607   _dbus_verbose (
"checking for existing connection\n");
  1618   if (shared_connections == 
NULL)
  1620       _dbus_verbose (
"creating shared_connections hash table\n");
  1625       if (shared_connections == 
NULL)
  1634           shared_connections = 
NULL;
  1639       _dbus_verbose (
"  successfully created shared_connections\n");
  1674               if (_dbus_connection_get_is_connected_unlocked (connection))
  1677                   *result = connection;
  1678                   _dbus_verbose (
"looked up existing connection to server guid %s\n",
  1683                   _dbus_verbose (
"looked up existing connection to server guid %s but it was disconnected so ignoring it\n",
  1700   char *guid_in_connection;
  1702   HAVE_LOCK_CHECK (connection);
  1733   if (guid_key == 
NULL)
  1737   if (guid_in_connection == 
NULL)
  1753                                        guid_key, connection))
  1763   _dbus_verbose (
"stored connection to %s to be shared\n",
  1776   HAVE_LOCK_CHECK (connection);
  1790       _dbus_verbose (
"dropping connection to %s out of the shared table\n",
  1820   if (transport == 
NULL)
  1822       _DBUS_ASSERT_ERROR_IS_SET (error);
  1830   if (connection == 
NULL)
  1832       _DBUS_SET_OOM (error);
  1836 #ifndef DBUS_DISABLE_CHECKS  1855 _dbus_connection_open_internal (
const char     *address,
  1865   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1867   _dbus_verbose (
"opening %s connection to: %s\n",
  1868                  shared ? 
"shared" : 
"private", address);
  1873   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1877   for (i = 0; i < len; i++)
  1881           if (!connection_lookup_shared (entries[i], &connection))
  1882             _DBUS_SET_OOM (&tmp_error);
  1885       if (connection == 
NULL)
  1887           connection = connection_try_from_address_entry (entries[i],
  1890           if (connection != 
NULL && shared)
  1901               if (!connection_record_shared_unlocked (connection, guid))
  1903                   _DBUS_SET_OOM (&tmp_error);
  1904                   _dbus_connection_close_possibly_shared_and_unlock (connection);
  1916       _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
  1924   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1925   _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
  1927   if (connection == 
NULL)
  1929       _DBUS_ASSERT_ERROR_IS_SET (&first_error);
  1954   _dbus_connection_close_possibly_shared_and_unlock (connection);
  1958 _dbus_connection_preallocate_send_unlocked (
DBusConnection *connection)
  1962   HAVE_LOCK_CHECK (connection);
  1967   if (preallocated == 
NULL)
  1982   return preallocated;
  1994 _dbus_connection_send_preallocated_unlocked_no_update (
DBusConnection       *connection,
  1997                                                        dbus_uint32_t        *client_serial)
  1999   dbus_uint32_t serial;
  2011   preallocated = 
NULL;
  2017   _dbus_verbose (
"Message %p (%s %s %s %s '%s') for %s added to outgoing queue %p, %d pending to send\n",
  2038       serial = _dbus_connection_get_next_client_serial (connection);
  2041         *client_serial = serial;
  2049   _dbus_verbose (
"Message %p serial is %u\n",
  2059                                           DBUS_ITERATION_DO_WRITING,
  2064     _dbus_connection_wakeup_mainloop (connection);
  2068 _dbus_connection_send_preallocated_and_unlock (
DBusConnection       *connection,
  2071                                                dbus_uint32_t        *client_serial)
  2075   HAVE_LOCK_CHECK (connection);
  2077   _dbus_connection_send_preallocated_unlocked_no_update (connection,
  2079                                                          message, client_serial);
  2081   _dbus_verbose (
"middle\n");
  2082   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  2085   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  2100                                   dbus_uint32_t  *client_serial)
  2107   preallocated = _dbus_connection_preallocate_send_unlocked (connection);
  2108   if (preallocated == 
NULL)
  2114   _dbus_connection_send_preallocated_and_unlock (connection,
  2157     _dbus_connection_close_possibly_shared_and_unlock (connection);
  2173 _dbus_memory_pause_based_on_timeout (
int timeout_milliseconds)
  2175   if (timeout_milliseconds == -1)
  2177   else if (timeout_milliseconds < 100)
  2179   else if (timeout_milliseconds <= 1000)
  2186 generate_local_error_message (dbus_uint32_t serial, 
  2212   if (error_msg != 
NULL)
  2235 _dbus_connection_peek_for_reply_unlocked (
DBusConnection *connection,
  2236                                           dbus_uint32_t   client_serial)
  2239   HAVE_LOCK_CHECK (connection);
  2243   while (link != 
NULL)
  2249           _dbus_verbose (
"%s reply to %d found in queue\n", _DBUS_FUNCTION_NAME, client_serial);
  2263                           dbus_uint32_t   client_serial)
  2267   HAVE_LOCK_CHECK (connection);
  2271   while (link != 
NULL)
  2288 connection_timeout_and_complete_all_pending_calls_unlocked (
DBusConnection *connection)
  2318   HAVE_LOCK_CHECK (connection);
  2328   _dbus_connection_detach_pending_call_and_unlock (connection, pending);
  2336 check_for_reply_and_update_dispatch_unlocked (
DBusConnection  *connection,
  2342   reply = check_for_reply_unlocked (connection, 
  2346       _dbus_verbose (
"checked for reply\n");
  2348       _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): got reply\n");
  2350       complete_pending_call_and_unlock (connection, pending, reply);
  2354       status = _dbus_connection_get_dispatch_status_unlocked (connection);
  2355       _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  2381   long start_tv_sec, start_tv_usec;
  2382   long tv_sec, tv_usec;
  2385   dbus_uint32_t client_serial;
  2387   int timeout_milliseconds, elapsed_milliseconds;
  2399   _dbus_connection_flush_unlocked (connection);
  2413       _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): will block %d milliseconds for reply serial %u from %ld sec %ld usec\n",
  2414                      timeout_milliseconds,
  2416                      start_tv_sec, start_tv_usec);
  2420       timeout_milliseconds = -1;
  2422       _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): will block for reply serial %u\n", client_serial);
  2427   if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
  2434                                           DBUS_ITERATION_DO_READING |
  2435                                           DBUS_ITERATION_BLOCK,
  2436                                           timeout_milliseconds);
  2440   _dbus_verbose (
"top of recheck\n");
  2442   HAVE_LOCK_CHECK (connection);
  2446   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  2453       _dbus_verbose (
"Pending call completed by dispatch\n");
  2454       _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  2461       if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
  2466   elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 +
  2467           (tv_usec - start_tv_usec) / 1000;
  2469   if (!_dbus_connection_get_is_connected_unlocked (connection))
  2473       error_msg = generate_local_error_message (client_serial,
  2475                                                 "Connection was disconnected before a reply was received"); 
  2478       complete_pending_call_and_unlock (connection, pending, error_msg);
  2479       if (error_msg != 
NULL)
  2485     _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): disconnected\n");
  2486   else if (timeout == 
NULL)
  2494           _dbus_verbose (
"dbus_connection_send_with_reply_and_block() waiting for more memory\n");
  2496           _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
  2503                                                   DBUS_ITERATION_DO_READING |
  2504                                                   DBUS_ITERATION_BLOCK,
  2505                                                   timeout_milliseconds - elapsed_milliseconds);
  2508       goto recheck_status;
  2510   else if (tv_sec < start_tv_sec)
  2511     _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): clock set backward\n");
  2512   else if (elapsed_milliseconds < timeout_milliseconds)
  2514       _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): %d milliseconds remain\n", timeout_milliseconds - elapsed_milliseconds);
  2522           _dbus_verbose (
"dbus_connection_send_with_reply_and_block() waiting for more memory\n");
  2524           _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
  2531                                                   DBUS_ITERATION_DO_READING |
  2532                                                   DBUS_ITERATION_BLOCK,
  2533                                                   timeout_milliseconds - elapsed_milliseconds);
  2536       goto recheck_status;
  2539   _dbus_verbose (
"dbus_connection_send_with_reply_and_block(): Waited %d milliseconds and got no reply\n",
  2540                  elapsed_milliseconds);
  2545   complete_pending_call_and_unlock (connection, pending, 
NULL);
  2549   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  2550   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  2574                                            DBusPendingFdsChangeFunction callback,
  2623   _dbus_return_val_if_fail (address != 
NULL, 
NULL);
  2624   _dbus_return_val_if_error_is_set (error, 
NULL);
  2626   connection = _dbus_connection_open_internal (address,
  2666   _dbus_return_val_if_fail (address != 
NULL, 
NULL);
  2667   _dbus_return_val_if_error_is_set (error, 
NULL);
  2669   connection = _dbus_connection_open_internal (address,
  2685   dbus_int32_t old_refcount;
  2687   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  2690   _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
  2697 free_outgoing_message (
void *element,
  2716   _dbus_verbose (
"Finalizing connection %p\n", connection);
  2743   while (link != 
NULL)
  2749       _dbus_message_filter_unref (filter); 
  2766                       free_outgoing_message,
  2821   dbus_int32_t old_refcount;
  2823   _dbus_return_if_fail (connection != 
NULL);
  2828   _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
  2831   if (old_refcount == 1)
  2833 #ifndef DBUS_DISABLE_CHECKS  2836           _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",
  2838                                    "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection.\n" : 
  2839                                     "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.\n");
  2843       _dbus_connection_last_unref (connection);
  2857 _dbus_connection_close_possibly_shared_and_unlock (
DBusConnection *connection)
  2861   HAVE_LOCK_CHECK (connection);
  2863   _dbus_verbose (
"Disconnecting %p\n", connection);
  2882   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  2885   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  2936   _dbus_return_if_fail (connection != 
NULL);
  2941 #ifndef DBUS_DISABLE_CHECKS  2946       _dbus_warn_check_failed (
"Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.\n");
  2951   _dbus_connection_close_possibly_shared_and_unlock (connection);
  2955 _dbus_connection_get_is_connected_unlocked (
DBusConnection *connection)
  2957   HAVE_LOCK_CHECK (connection);
  2979   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  2982   res = _dbus_connection_get_is_connected_unlocked (connection);
  3001   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3035   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3080   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  3110   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3118 #ifdef HAVE_UNIX_FD_PASSING  3150   _dbus_return_if_fail (connection != 
NULL);
  3171   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  3176     _dbus_connection_preallocate_send_unlocked (connection);
  3180   return preallocated;
  3196   _dbus_return_if_fail (connection != 
NULL);
  3197   _dbus_return_if_fail (preallocated != 
NULL);  
  3198   _dbus_return_if_fail (connection == preallocated->
connection);
  3222                                    dbus_uint32_t        *client_serial)
  3224   _dbus_return_if_fail (connection != 
NULL);
  3225   _dbus_return_if_fail (preallocated != 
NULL);
  3226   _dbus_return_if_fail (message != 
NULL);
  3227   _dbus_return_if_fail (preallocated->
connection == connection);
  3236 #ifdef HAVE_UNIX_FD_PASSING  3239       message->n_unix_fds > 0)
  3250   _dbus_connection_send_preallocated_and_unlock (connection,
  3252                                                  message, client_serial);
  3256 _dbus_connection_send_unlocked_no_update (
DBusConnection *connection,
  3258                                           dbus_uint32_t  *client_serial)
  3265   preallocated = _dbus_connection_preallocate_send_unlocked (connection);
  3266   if (preallocated == 
NULL)
  3269   _dbus_connection_send_preallocated_unlocked_no_update (connection,
  3306                       dbus_uint32_t  *serial)
  3308   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3309   _dbus_return_val_if_fail (message != 
NULL, 
FALSE);
  3313 #ifdef HAVE_UNIX_FD_PASSING  3316       message->n_unix_fds > 0)
  3333 reply_handler_timeout (
void *data)
  3348   _dbus_verbose (
"middle\n");
  3349   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  3352   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  3404                                  int                 timeout_milliseconds)
  3407   dbus_int32_t serial = -1;
  3410   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3411   _dbus_return_val_if_fail (message != 
NULL, 
FALSE);
  3412   _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, 
FALSE);
  3415     *pending_return = 
NULL;
  3419 #ifdef HAVE_UNIX_FD_PASSING  3422       message->n_unix_fds > 0)
  3434    if (!_dbus_connection_get_is_connected_unlocked (connection))
  3442                                              timeout_milliseconds,
  3443                                              reply_handler_timeout);
  3445   if (pending == 
NULL)
  3455       serial = _dbus_connection_get_next_client_serial (connection);
  3466   if (!_dbus_connection_attach_pending_call_unlocked (connection,
  3470   if (!_dbus_connection_send_unlocked_no_update (connection, message, 
NULL))
  3472       _dbus_connection_detach_pending_call_and_unlock (connection,
  3474       goto error_unlocked;
  3478     *pending_return = pending; 
  3481       _dbus_connection_detach_pending_call_unlocked (connection, pending);
  3487   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  3490   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  3492   if (pending_return == 
NULL)
  3539                                            int                 timeout_milliseconds,
  3545   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  3546   _dbus_return_val_if_fail (message != 
NULL, 
NULL);
  3547   _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, 
NULL);
  3548   _dbus_return_val_if_error_is_set (error, 
NULL);
  3550 #ifdef HAVE_UNIX_FD_PASSING  3554       message->n_unix_fds > 0)
  3565                                         &pending, timeout_milliseconds))
  3567       _DBUS_SET_OOM (error);
  3571   if (pending == 
NULL)
  3614   HAVE_LOCK_CHECK (connection);
  3617          _dbus_connection_get_is_connected_unlocked (connection))
  3619       _dbus_verbose (
"doing iteration in\n");
  3620       HAVE_LOCK_CHECK (connection);
  3623                                               DBUS_ITERATION_DO_READING |
  3624                                               DBUS_ITERATION_DO_WRITING |
  3625                                               DBUS_ITERATION_BLOCK,
  3629   HAVE_LOCK_CHECK (connection);
  3630   _dbus_verbose (
"middle\n");
  3631   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  3633   HAVE_LOCK_CHECK (connection);
  3652   _dbus_return_if_fail (connection != 
NULL);
  3656   status = _dbus_connection_flush_unlocked (connection);
  3658   HAVE_LOCK_CHECK (connection);
  3660   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  3662   _dbus_verbose (
"end\n");
  3676 _dbus_connection_read_write_dispatch (
DBusConnection *connection,
  3677                                      int             timeout_milliseconds, 
  3692       _dbus_verbose (
"doing dispatch\n");
  3698       _dbus_verbose (
"pausing for memory\n");
  3699       _dbus_memory_pause_based_on_timeout (timeout_milliseconds);
  3705       if (_dbus_connection_get_is_connected_unlocked (connection))
  3707           _dbus_verbose (
"doing iteration\n");
  3710                                                   DBUS_ITERATION_DO_READING |
  3711                                                   DBUS_ITERATION_DO_WRITING |
  3712                                                   DBUS_ITERATION_BLOCK,
  3713                                                   timeout_milliseconds);
  3717   HAVE_LOCK_CHECK (connection);
  3723     progress_possible = connection->
n_incoming != 0 ||
  3726     progress_possible = _dbus_connection_get_is_connected_unlocked (connection);
  3732   return progress_possible; 
  3772                                      int             timeout_milliseconds)
  3774   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3775   _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, 
FALSE);
  3776    return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, 
TRUE);
  3804                             int             timeout_milliseconds) 
  3806   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  3807   _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, 
FALSE);
  3808    return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, 
FALSE);
  3817 check_disconnected_message_arrived_unlocked (
DBusConnection *connection,
  3820   HAVE_LOCK_CHECK (connection);
  3857   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  3859   _dbus_verbose (
"start\n");
  3870   _dbus_connection_acquire_dispatch (connection);
  3879   check_disconnected_message_arrived_unlocked (connection, message);
  3882   if (message == 
NULL)
  3883     _dbus_connection_release_dispatch (connection);
  3887   _dbus_message_trace_ref (message, -1, -1, 
"dbus_connection_borrow_message");
  3908   _dbus_return_if_fail (connection != 
NULL);
  3909   _dbus_return_if_fail (message != 
NULL);
  3919   _dbus_connection_release_dispatch (connection); 
  3921   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  3922   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  3924   _dbus_message_trace_ref (message, -1, -1, 
"dbus_connection_return_message");
  3943   _dbus_return_if_fail (connection != 
NULL);
  3944   _dbus_return_if_fail (message != 
NULL);
  3958   _dbus_verbose (
"Incoming message %p stolen from queue, %d incoming\n",
  3963   _dbus_connection_release_dispatch (connection);
  3965   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  3966   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  3967   _dbus_message_trace_ref (message, -1, -1,
  3968       "dbus_connection_steal_borrowed_message");
  3975 _dbus_connection_pop_message_link_unlocked (
DBusConnection *connection)
  3977   HAVE_LOCK_CHECK (connection);
  3988       _dbus_verbose (
"Message %p (%s %s %s %s sig:'%s' serial:%u) removed from incoming queue %p, %d incoming\n",
  4004       _dbus_message_trace_ref (link->
data, -1, -1,
  4005           "_dbus_connection_pop_message_link_unlocked");
  4007       check_disconnected_message_arrived_unlocked (connection, link->
data);
  4019 _dbus_connection_pop_message_unlocked (
DBusConnection *connection)
  4023   HAVE_LOCK_CHECK (connection);
  4025   link = _dbus_connection_pop_message_link_unlocked (connection);
  4031       message = link->
data;
  4042 _dbus_connection_putback_message_link_unlocked (
DBusConnection *connection,
  4045   HAVE_LOCK_CHECK (connection);
  4057   _dbus_verbose (
"Message %p (%s %s %s '%s') put back into queue %p, %d incoming\n",
  4069   _dbus_message_trace_ref (message_link->
data, -1, -1,
  4070       "_dbus_connection_putback_message_link_unlocked");
  4098   _dbus_verbose (
"start\n");
  4108   _dbus_connection_acquire_dispatch (connection);
  4109   HAVE_LOCK_CHECK (connection);
  4111   message = _dbus_connection_pop_message_unlocked (connection);
  4113   _dbus_verbose (
"Returning popped message %p\n", message);    
  4115   _dbus_connection_release_dispatch (connection);
  4117   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  4118   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  4133   HAVE_LOCK_CHECK (connection);
  4138   _dbus_verbose (
"locking dispatch_mutex\n");
  4143       _dbus_verbose (
"waiting for dispatch to be acquirable\n");
  4152   _dbus_verbose (
"unlocking dispatch_mutex\n");
  4169   HAVE_LOCK_CHECK (connection);
  4171   _dbus_verbose (
"locking dispatch_mutex\n");
  4179   _dbus_verbose (
"unlocking dispatch_mutex\n");
  4196   HAVE_LOCK_CHECK (connection);
  4214       _dbus_verbose (
"Dropping %d outgoing messages since we're disconnected\n",
  4226 notify_disconnected_and_dispatch_complete_unlocked (
DBusConnection *connection)
  4228   HAVE_LOCK_CHECK (connection);
  4232       _dbus_verbose (
"Sending disconnect message\n");
  4237       connection_timeout_and_complete_all_pending_calls_unlocked (connection);
  4253 _dbus_connection_get_dispatch_status_unlocked (
DBusConnection *connection)
  4255   HAVE_LOCK_CHECK (connection);
  4269       _dbus_verbose (
"dispatch status = %s is_connected = %d\n",
  4270                      DISPATCH_STATUS_NAME (status), is_connected);
  4280           notify_disconnected_unlocked (connection);
  4288             status = notify_disconnected_and_dispatch_complete_unlocked (connection);
  4301 _dbus_connection_update_dispatch_status_and_unlock (
DBusConnection    *connection,
  4308   HAVE_LOCK_CHECK (connection);
  4328       connection_forget_shared_unlocked (connection);
  4334           _dbus_verbose (
"Exiting on Disconnected signal\n");
  4343   if (changed && 
function)
  4345       _dbus_verbose (
"Notifying of change to dispatch status of %p now %d (%s)\n",
  4346                      connection, new_status,
  4347                      DISPATCH_STATUS_NAME (new_status));
  4348       (* function) (connection, new_status, data);      
  4386   _dbus_verbose (
"start\n");
  4390   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  4401 _dbus_connection_peer_filter_unlocked_no_update (
DBusConnection *connection,
  4434       sent = _dbus_connection_send_unlocked_no_update (connection, ret, 
NULL);
  4448           const char *v_STRING;
  4458           v_STRING = _dbus_string_get_const_data (&uuid);
  4463               sent = _dbus_connection_send_unlocked_no_update (connection, ret, 
NULL);
  4479           sent = _dbus_connection_send_unlocked_no_update (connection, ret,
  4493                                     "Unknown method invoked on org.freedesktop.DBus.Peer interface");
  4497       sent = _dbus_connection_send_unlocked_no_update (connection, ret, 
NULL);
  4508       expire_link->
data = ret;
  4525 _dbus_connection_run_builtin_filters_unlocked_no_update (
DBusConnection *connection,
  4531   return _dbus_connection_peer_filter_unlocked_no_update (connection, message);
  4580   DBusList *link, *filter_list_copy, *message_link;
  4583   dbus_int32_t reply_serial;
  4589   _dbus_verbose (
"\n");
  4592   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  4596       _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  4605   _dbus_connection_acquire_dispatch (connection);
  4606   HAVE_LOCK_CHECK (connection);
  4608   message_link = _dbus_connection_pop_message_link_unlocked (connection);
  4609   if (message_link == 
NULL)
  4613       _dbus_verbose (
"another thread dispatched message (during acquire_dispatch above)\n");
  4615       _dbus_connection_release_dispatch (connection);
  4617       status = _dbus_connection_get_dispatch_status_unlocked (connection);
  4619       _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  4626   message = message_link->
data;
  4628   _dbus_verbose (
" dispatching message %p (%s %s %s '%s')\n",
  4653       _dbus_verbose (
"Dispatching a pending reply\n");
  4654       complete_pending_call_and_unlock (connection, pending, message);
  4658       _dbus_verbose (
"pending call completed in dispatch\n");
  4663   result = _dbus_connection_run_builtin_filters_unlocked_no_update (connection, message);
  4669       _dbus_connection_release_dispatch (connection);
  4670       HAVE_LOCK_CHECK (connection);
  4672       _dbus_connection_failed_pop (connection, message_link);
  4675       _dbus_connection_update_dispatch_status_and_unlock (connection,
  4692   while (link != 
NULL)
  4699           _dbus_verbose (
"  filter was removed in a callback function\n");
  4704       _dbus_verbose (
"  running filter on message %p\n", message);
  4722       _dbus_verbose (
"No memory\n");
  4727       _dbus_verbose (
"filter handled message in dispatch\n");
  4734   _dbus_verbose (
"  running object path dispatch on message %p (%s %s %s '%s')\n",
  4745   HAVE_LOCK_CHECK (connection);
  4754       _dbus_verbose (
"object tree handled message in dispatch\n");
  4765       _dbus_verbose (
"  sending error %s\n",
  4771           _dbus_verbose (
"no memory for error string in dispatch\n");
  4776                                        "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
  4783           _dbus_verbose (
"no memory for error string in dispatch\n");
  4789                                       _dbus_string_get_const_data (&str));
  4795           _dbus_verbose (
"no memory for error reply in dispatch\n");
  4801       if (expire_link == 
NULL)
  4805           _dbus_verbose (
"no memory for error send in dispatch\n");
  4809       preallocated = _dbus_connection_preallocate_send_unlocked (connection);
  4811       if (preallocated == 
NULL)
  4818           _dbus_verbose (
"no memory for error send in dispatch\n");
  4822       _dbus_connection_send_preallocated_unlocked_no_update (connection, preallocated,
  4830   _dbus_verbose (
"  done dispatching %p (%s %s %s '%s') on connection %p\n", message,
  4844       _dbus_verbose (
"out of memory\n");
  4850       _dbus_connection_putback_message_link_unlocked (connection,
  4853       message_link = 
NULL;
  4858       _dbus_verbose (
" ... done dispatching\n");
  4861   _dbus_connection_release_dispatch (connection);
  4862   HAVE_LOCK_CHECK (connection);
  4864   if (message != 
NULL)
  4878   if (message_link != 
NULL)
  4881   _dbus_verbose (
"before final status update\n");
  4882   status = _dbus_connection_get_dispatch_status_unlocked (connection);
  4885   _dbus_connection_update_dispatch_status_and_unlock (connection, status);
  4963   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  4968                                            add_function, remove_function,
  4970                                            data, free_data_function);
  5026   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5031                                              add_function, remove_function,
  5033                                              data, free_data_function);
  5063   _dbus_return_if_fail (connection != 
NULL);
  5077     (*old_free_data) (old_data);
  5109   _dbus_return_if_fail (connection != 
NULL);
  5123     (*old_free_data) (old_data);
  5149   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5182   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5191       *fd = _dbus_socket_get_int (s);
  5228   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5229   _dbus_return_val_if_fail (uid != 
NULL, 
FALSE);
  5264   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5265   _dbus_return_val_if_fail (pid != 
NULL, 
FALSE);
  5294                                             dbus_int32_t   *data_size)
  5298   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5299   _dbus_return_val_if_fail (data != 
NULL, 
FALSE);
  5300   _dbus_return_val_if_fail (data_size != 
NULL, 
FALSE);
  5343   void *old_data = 
NULL;
  5346   _dbus_return_if_fail (connection != 
NULL);
  5350                                           function, data, free_data_function,
  5351                                           &old_data, &old_free_function);
  5354   if (old_free_function != 
NULL)
  5355     (* old_free_function) (old_data);
  5360 _dbus_connection_get_linux_security_label (
DBusConnection  *connection,
  5373     result = _dbus_transport_get_linux_security_label (connection->
transport,
  5417                                   char                      **windows_sid_p)
  5421   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5422   _dbus_return_val_if_fail (windows_sid_p != 
NULL, 
FALSE);
  5468   void *old_data = 
NULL;
  5471   _dbus_return_if_fail (connection != 
NULL);
  5475                                              function, data, free_data_function,
  5476                                              &old_data, &old_free_function);
  5479   if (old_free_function != 
NULL)
  5480     (* old_free_function) (old_data);
  5513   _dbus_return_if_fail (connection != 
NULL);
  5541   _dbus_return_if_fail (connection != 
NULL);
  5577   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5578   _dbus_return_val_if_fail (
function != 
NULL, 
FALSE);
  5591       _dbus_message_filter_unref (filter);
  5629   _dbus_return_if_fail (connection != 
NULL);
  5630   _dbus_return_if_fail (
function != 
NULL);
  5637   while (link != 
NULL)
  5639       filter = link->
data;
  5641       if (filter->
function == 
function &&
  5656 #ifndef DBUS_DISABLE_CHECKS  5659       _dbus_warn_check_failed (
"Attempt to remove filter function %p user data %p, but no such filter has been added\n",
  5660                                function, user_data);
  5672   _dbus_message_filter_unref (filter);
  5691 _dbus_connection_register_object_path (
DBusConnection              *connection,
  5698   char **decomposed_path;
  5708                                        (
const char **) decomposed_path, vtable,
  5737   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5738   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5739   _dbus_return_val_if_fail (path[0] == 
'/', 
FALSE);
  5740   _dbus_return_val_if_fail (vtable != 
NULL, 
FALSE);
  5742   return _dbus_connection_register_object_path (connection, 
FALSE, path, vtable, user_data, error);
  5769   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5770   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5771   _dbus_return_val_if_fail (path[0] == 
'/', 
FALSE);
  5772   _dbus_return_val_if_fail (vtable != 
NULL, 
FALSE);
  5774   retval = _dbus_connection_register_object_path (connection, 
FALSE, path, vtable, user_data, &error);
  5807   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5808   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5809   _dbus_return_val_if_fail (path[0] == 
'/', 
FALSE);
  5810   _dbus_return_val_if_fail (vtable != 
NULL, 
FALSE);
  5812   return _dbus_connection_register_object_path (connection, 
TRUE, path, vtable, user_data, error);
  5841   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5842   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5843   _dbus_return_val_if_fail (path[0] == 
'/', 
FALSE);
  5844   _dbus_return_val_if_fail (vtable != 
NULL, 
FALSE);
  5846   retval = _dbus_connection_register_object_path (connection, 
TRUE, path, vtable, user_data, &error);
  5871   char **decomposed_path;
  5873   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5874   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5875   _dbus_return_val_if_fail (path[0] == 
'/', 
FALSE);
  5904   char **decomposed_path;
  5906   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5907   _dbus_return_val_if_fail (path != 
NULL, 
FALSE);
  5908   _dbus_return_val_if_fail (data_p != 
NULL, 
FALSE);
  5938                                  const char                  *parent_path,
  5939                                  char                      ***child_entries)
  5941   char **decomposed_path;
  5943   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  5944   _dbus_return_val_if_fail (parent_path != 
NULL, 
FALSE);
  5945   _dbus_return_val_if_fail (parent_path[0] == 
'/', 
FALSE);
  5946   _dbus_return_val_if_fail (child_entries != 
NULL, 
FALSE);
  5954                                                          (
const char **) decomposed_path,
  5999   _dbus_return_if_fail (*slot_p >= 0);
  6036   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
  6037   _dbus_return_val_if_fail (slot >= 0, 
FALSE);
  6039   SLOTS_LOCK (connection);
  6043                                      slot, data, free_data_func,
  6044                                      &old_free_func, &old_data);
  6046   SLOTS_UNLOCK (connection);
  6052         (* old_free_func) (old_data);
  6081   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
  6082   _dbus_return_val_if_fail (slot >= 0, 
NULL);
  6084   SLOTS_LOCK (connection);
  6090   SLOTS_UNLOCK (connection);
  6104   _dbus_modify_sigpipe = will_modify_sigpipe != 
FALSE;
  6119   _dbus_return_if_fail (connection != 
NULL);
  6138   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6158   _dbus_return_if_fail (connection != 
NULL);
  6177   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6214   _dbus_return_if_fail (connection != 
NULL);
  6233   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6256   _dbus_return_if_fail (connection != 
NULL);
  6275   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6298   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6306 #ifdef DBUS_ENABLE_STATS  6309                             dbus_uint32_t  *in_messages,
  6310                             dbus_uint32_t  *in_bytes,
  6311                             dbus_uint32_t  *in_fds,
  6312                             dbus_uint32_t  *in_peak_bytes,
  6313                             dbus_uint32_t  *in_peak_fds,
  6314                             dbus_uint32_t  *out_messages,
  6315                             dbus_uint32_t  *out_bytes,
  6316                             dbus_uint32_t  *out_fds,
  6317                             dbus_uint32_t  *out_peak_bytes,
  6318                             dbus_uint32_t  *out_peak_fds)
  6322   if (in_messages != 
NULL)
  6325   _dbus_transport_get_stats (connection->
transport,
  6326                              in_bytes, in_fds, in_peak_bytes, in_peak_fds);
  6328   if (out_messages != 
NULL)
  6331   if (out_bytes != 
NULL)
  6334   if (out_fds != 
NULL)
  6337   if (out_peak_bytes != 
NULL)
  6338     *out_peak_bytes = _dbus_counter_get_peak_size_value (connection->
outgoing_counter);
  6340   if (out_peak_fds != 
NULL)
  6341     *out_peak_fds = _dbus_counter_get_peak_unix_fd_value (connection->
outgoing_counter);
  6359   _dbus_return_val_if_fail (connection != 
NULL, 0);
  6367 #ifdef DBUS_ENABLE_EMBEDDED_TESTS dbus_bool_t dbus_error_has_name(const DBusError *error, const char *name)
Checks whether the error is set and has the given name. 
DBusHandlerResult _dbus_object_tree_dispatch_and_unlock(DBusObjectTree *tree, DBusMessage *message, dbus_bool_t *found_object)
Tries to dispatch a message by directing it to handler for the object path listed in the message head...
An atomic integer safe to increment or decrement from multiple threads. 
void _dbus_pending_call_complete(DBusPendingCall *pending)
Calls notifier function for the pending call and sets the call to completed. 
void dbus_connection_set_change_sigpipe(dbus_bool_t will_modify_sigpipe)
This function sets a global flag for whether dbus_connection_new() will set SIGPIPE behavior to SIG_I...
DBusMessage * dbus_message_ref(DBusMessage *message)
Increments the reference count of a DBusMessage. 
DBusList * filter_list
List of filters. 
void _dbus_transport_set_max_received_unix_fds(DBusTransport *transport, long n)
See dbus_connection_set_max_received_unix_fds(). 
Internals of DBusTimeout. 
void * user_data
User data for the function. 
void dbus_message_lock(DBusMessage *message)
Locks a message. 
void * _dbus_list_get_last(DBusList **list)
Gets the last data in the list. 
void _dbus_connection_toggle_watch_unlocked(DBusConnection *connection, DBusWatch *watch, dbus_bool_t enabled)
Toggles a watch and notifies app via connection's DBusWatchToggledFunction if available. 
const char * _dbus_transport_get_server_id(DBusTransport *transport)
Gets the id of the server we are connected to (see dbus_server_get_id()). 
dbus_bool_t _dbus_list_prepend(DBusList **list, void *data)
Prepends a value to the list. 
DBusDispatchStatus
Indicates the status of incoming data on a DBusConnection. 
const char * message
public error message field 
const char * _dbus_transport_get_address(DBusTransport *transport)
Gets the address of a transport. 
DBusFreeFunction free_wakeup_main_data
free wakeup_main_data 
Implementation of DBusWatch. 
#define NULL
A null pointer, defined appropriately for C or C++. 
dbus_bool_t dbus_message_is_method_call(DBusMessage *message, const char *iface, const char *method)
Checks whether the message is a method call with the given interface and member fields. 
void(* DBusFreeFunction)(void *memory)
The type of a function which frees a block of memory. 
dbus_bool_t _dbus_connection_add_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout)
Adds a timeout using the connection's DBusAddTimeoutFunction if available. 
DBusList * queue_link
Preallocated link in the queue. 
unsigned int have_connection_lock
Used to check locking. 
void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
Sets a flag indicating that the message does not want a reply; if this flag is set, the other end of the connection may (but is not required to) optimize by not sending method return or error replies. 
dbus_bool_t _dbus_timeout_list_set_functions(DBusTimeoutList *timeout_list, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the timeout functions. 
void _dbus_connection_queue_synthesized_message_link(DBusConnection *connection, DBusList *link)
Adds a link + message to the incoming message queue. 
DBusConnection * _dbus_pending_call_get_connection_unlocked(DBusPendingCall *pending)
Gets the connection associated with this pending call. 
void _dbus_object_tree_free_all_unlocked(DBusObjectTree *tree)
Free all the handlers in the tree. 
More memory is needed to continue. 
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0(). 
dbus_bool_t _dbus_hash_table_insert_int(DBusHashTable *table, int key, void *value)
Creates a hash entry with the given key and value. 
dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
Returns the serial of a message or 0 if none has been specified. 
void _dbus_condvar_wait(DBusCondVar *cond, DBusCMutex *mutex)
Atomically unlocks the mutex and waits for the conditions variable to be signalled. 
void dbus_connection_set_windows_user_function(DBusConnection *connection, DBusAllowWindowsUserFunction function, void *data, DBusFreeFunction free_data_function)
Sets a predicate function used to determine whether a given user ID is allowed to connect...
dbus_bool_t _dbus_condvar_wait_timeout(DBusCondVar *cond, DBusCMutex *mutex, int timeout_milliseconds)
Atomically unlocks the mutex and waits for the conditions variable to be signalled, or for a timeout. 
DBusList * _dbus_list_get_last_link(DBusList **list)
Gets the last link in the list. 
dbus_bool_t dbus_connection_get_windows_user(DBusConnection *connection, char **windows_sid_p)
Gets the Windows user SID of the connection if known. 
void _dbus_connection_lock(DBusConnection *connection)
Acquires the connection lock. 
dbus_bool_t _dbus_transport_get_socket_fd(DBusTransport *transport, DBusSocket *fd_p)
Get the socket file descriptor, if any. 
DBusMessage * dbus_pending_call_steal_reply(DBusPendingCall *pending)
Gets the reply, or returns NULL if none has been received yet. 
#define dbus_new(type, count)
Safe macro for using dbus_malloc(). 
DBusList * disconnect_message_link
Preallocated list node for queueing the disconnection message. 
void(* DBusWatchToggledFunction)(DBusWatch *watch, void *data)
Called when dbus_watch_get_enabled() may return a different value than it did before. 
void dbus_connection_set_max_message_size(DBusConnection *connection, long size)
Specifies the maximum size message this connection is allowed to receive. 
dbus_bool_t dbus_connection_try_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a fallback handler for a given subsection of the object hierarchy. 
void _dbus_list_remove_link(DBusList **list, DBusList *link)
Removes a link from the list. 
void _dbus_timeout_list_free(DBusTimeoutList *timeout_list)
Frees a DBusTimeoutList. 
long dbus_connection_get_outgoing_size(DBusConnection *connection)
Gets the approximate size in bytes of all messages in the outgoing message queue. ...
DBusConnection * dbus_connection_ref(DBusConnection *connection)
Increments the reference count of a DBusConnection. 
dbus_bool_t dbus_connection_can_send_type(DBusConnection *connection, int type)
Tests whether a certain type can be send via the connection. 
DBusMessage * message_borrowed
Filled in if the first incoming message has been borrowed; dispatch_acquired will be set by the borro...
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string. 
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on. 
DBusTimeoutList * _dbus_timeout_list_new(void)
Creates a new timeout list. 
#define _dbus_assert(condition)
Aborts with an error message if the condition is false. 
dbus_bool_t dbus_connection_read_write(DBusConnection *connection, int timeout_milliseconds)
This function is intended for use with applications that don't want to write a main loop and deal wit...
unsigned int shareable
TRUE if libdbus owns a reference to the connection and can return it from dbus_connection_open() more...
void _dbus_list_append_link(DBusList **list, DBusList *link)
Appends a link to the list. 
Internals of DBusCounter. 
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack. 
void * data
Data stored at this element. 
DBusFreeFunction free_dispatch_status_data
free dispatch_status_data 
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type. 
DBusFreeFunction free_user_data_function
Function to free the user data. 
DBusList * incoming_messages
Queue of messages we have received, end of the list received most recently. 
void _dbus_warn_check_failed(const char *format,...)
Prints a "critical" warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
dbus_bool_t _dbus_transport_get_unix_process_id(DBusTransport *transport, unsigned long *pid)
See dbus_connection_get_unix_process_id(). 
const char * dbus_message_get_signature(DBusMessage *message)
Gets the type signature of the message, i.e. 
void _dbus_watch_list_toggle_watch(DBusWatchList *watch_list, DBusWatch *watch, dbus_bool_t enabled)
Sets a watch to the given enabled state, invoking the application's DBusWatchToggledFunction if appro...
dbus_bool_t _dbus_transport_queue_messages(DBusTransport *transport)
Processes data we've read while handling a watch, potentially converting some of it to messages and q...
Message has not had any effect - see if other handlers want it. 
void _dbus_transport_set_unix_user_function(DBusTransport *transport, DBusAllowUnixUserFunction function, void *data, DBusFreeFunction free_data_function, void **old_data, DBusFreeFunction *old_free_data_function)
See dbus_connection_set_unix_user_function(). 
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message. 
void dbus_connection_set_dispatch_status_function(DBusConnection *connection, DBusDispatchStatusFunction function, void *data, DBusFreeFunction free_data_function)
Set a function to be invoked when the dispatch status changes. 
dbus_bool_t dbus_connection_set_data(DBusConnection *connection, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
Stores a pointer on a DBusConnection, along with an optional function to be used for freeing the data...
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
void _dbus_watch_list_free(DBusWatchList *watch_list)
Frees a DBusWatchList. 
void dbus_connection_set_route_peer_messages(DBusConnection *connection, dbus_bool_t value)
Normally DBusConnection automatically handles all messages to the org.freedesktop.DBus.Peer interface. 
void _dbus_object_tree_unregister_and_unlock(DBusObjectTree *tree, const char **path)
Unregisters an object subtree that was registered with the same path. 
#define DBUS_INTERFACE_PEER
The interface supported by most dbus peers. 
void _dbus_hash_table_unref(DBusHashTable *table)
Decrements the reference count for a hash table, freeing the hash table if the count reaches zero...
void _dbus_connection_close_if_only_one_ref(DBusConnection *connection)
Used internally to handle the semantics of dbus_server_set_new_connection_function(). 
#define DBUS_INTERFACE_LOCAL
This is a special interface whose methods can only be invoked by the local implementation (messages f...
void dbus_connection_return_message(DBusConnection *connection, DBusMessage *message)
Used to return a message after peeking at it using dbus_connection_borrow_message(). 
DBusAtomic refcount
Reference count. 
DBusCounter * _dbus_counter_ref(DBusCounter *counter)
Increments refcount of the counter. 
void dbus_address_entries_free(DBusAddressEntry **entries)
Frees a NULL-terminated array of address entries. 
dbus_bool_t _dbus_transport_get_windows_user(DBusTransport *transport, char **windows_sid_p)
See dbus_connection_get_windows_user(). 
Implementation details of DBusPendingCall - all fields are private. 
void _dbus_rmutex_new_at_location(DBusRMutex **location_p)
Creates a new mutex or creates a no-op mutex if threads are not initialized. 
dbus_bool_t dbus_connection_set_timeout_functions(DBusConnection *connection, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the timeout functions for the connection. 
Implementation details of DBusConnection. 
dbus_bool_t dbus_message_has_interface(DBusMessage *message, const char *iface)
Checks if the message has an interface. 
void dbus_connection_remove_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data)
Removes a previously-added message filter. 
struct DBusMutex DBusMutex
An opaque mutex type provided by the DBusThreadFunctions implementation installed by dbus_threads_ini...
#define _dbus_list_get_prev_link(list, link)
Gets the previous link in the list, or NULL if there are no more links. 
DBusWatchList * _dbus_watch_list_new(void)
Creates a new watch list. 
DBusCounter * outgoing_counter
Counts size of outgoing messages. 
dbus_bool_t(* DBusWatchAddFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held. 
#define DBUS_MESSAGE_TYPE_ERROR
Message type of an error reply message, see dbus_message_get_type() 
DBusList * _dbus_list_alloc_link(void *data)
Allocates a linked list node. 
dbus_bool_t dbus_connection_get_unix_user(DBusConnection *connection, unsigned long *uid)
Gets the UNIX user ID of the connection if known. 
dbus_bool_t dbus_connection_list_registered(DBusConnection *connection, const char *parent_path, char ***child_entries)
Lists the registered fallback handlers and object path handlers at the given parent_path. 
const char * dbus_message_get_path(DBusMessage *message)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string. 
DBusMessage * dbus_message_new_signal(const char *path, const char *iface, const char *name)
Constructs a new message representing a signal emission. 
long _dbus_transport_get_max_message_size(DBusTransport *transport)
See dbus_connection_get_max_message_size(). 
dbus_bool_t _dbus_hash_iter_next(DBusHashIter *iter)
Move the hash iterator forward one step, to the next hash entry. 
dbus_bool_t _dbus_list_remove(DBusList **list, void *data)
Removes a value from the list. 
void dbus_connection_set_max_received_size(DBusConnection *connection, long size)
Sets the maximum total number of bytes that can be used for all messages received on this connection...
DBusDispatchStatusFunction dispatch_status_function
Function on dispatch status changes. 
DBusHandlerResult
Results that a message handler can return. 
DBusMessage * _dbus_connection_get_message_to_send(DBusConnection *connection)
Gets the next outgoing message. 
DBusList * _dbus_list_pop_first_link(DBusList **list)
Removes the first link in the list and returns it. 
DBusMessageIter struct; contains no public fields. 
void dbus_connection_steal_borrowed_message(DBusConnection *connection, DBusMessage *message)
Used to keep a message after peeking at it using dbus_connection_borrow_message(). 
void * _dbus_list_get_first(DBusList **list)
Gets the first data in the list. 
dbus_bool_t _dbus_pending_call_get_completed_unlocked(DBusPendingCall *pending)
Checks whether the pending call has received a reply yet, or not. 
#define _dbus_list_get_next_link(list, link)
Gets the next link in the list, or NULL if there are no more links. 
void dbus_connection_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for connection data slots. 
#define DBUS_ERROR_UNKNOWN_METHOD
Method name you invoked isn't known by the object you invoked it on. 
const char * dbus_message_get_destination(DBusMessage *message)
Gets the destination of a message or NULL if there is none set. 
Internal struct representing a message filter function. 
void _dbus_message_add_counter_link(DBusMessage *message, DBusList *link)
Adds a counter to be incremented immediately with the size/unix fds of this message, and decremented by the size/unix fds of this message when this message if finalized. 
#define DBUS_PATH_LOCAL
The object path used in local/in-process-generated messages. 
void(* DBusRemoveTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus no longer needs a timeout to be monitored by the main loop. 
dbus_bool_t _dbus_list_copy(DBusList **list, DBusList **dest)
Copies a list. 
void _dbus_connection_block_pending_call(DBusPendingCall *pending)
Blocks until a pending call times out or gets a reply. 
DBusWatchList * watches
Stores active watches. 
DBusRMutex * mutex
Lock on the entire DBusConnection. 
dbus_bool_t _dbus_transport_get_is_connected(DBusTransport *transport)
Returns TRUE if the transport has not been disconnected. 
dbus_bool_t _dbus_watch_list_set_functions(DBusWatchList *watch_list, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the watch functions. 
dbus_bool_t _dbus_hash_table_remove_int(DBusHashTable *table, int key)
Removes the hash entry for the given key. 
int _dbus_connection_get_pending_fds_count(DBusConnection *connection)
Return how many file descriptors are pending in the loader. 
dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *error_name)
Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR). 
There is more data to potentially convert to messages. 
DBusMessage * dbus_connection_send_with_reply_and_block(DBusConnection *connection, DBusMessage *message, int timeout_milliseconds, DBusError *error)
Sends a message and blocks a certain time period while waiting for a reply. 
DBusConnection * dbus_connection_open_private(const char *address, DBusError *error)
Opens a new, dedicated connection to a remote address. 
DBusAtomic refcount
Reference count. 
const char * dbus_message_get_member(DBusMessage *message)
Gets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
DBusPreallocatedSend * dbus_connection_preallocate_send(DBusConnection *connection)
Preallocates resources needed to send a message, allowing the message to be sent without the possibil...
Virtual table that must be implemented to handle a portion of the object path hierarchy. 
Internals of DBusMessage. 
dbus_bool_t _dbus_pending_call_set_timeout_error_unlocked(DBusPendingCall *pending, DBusMessage *message, dbus_uint32_t serial)
Sets the reply message associated with the pending call to a timeout error. 
dbus_bool_t dbus_pending_call_get_completed(DBusPendingCall *pending)
Checks whether the pending call has received a reply yet, or not. 
const char * dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
Returns a value from a key of an entry. 
long _dbus_transport_get_max_received_unix_fds(DBusTransport *transport)
See dbus_connection_set_max_received_unix_fds(). 
DBUS_PRIVATE_EXPORT void _dbus_rmutex_unlock(DBusRMutex *mutex)
Unlocks a mutex. 
#define DBUS_ERROR_OBJECT_PATH_IN_USE
There's already an object with the requested object path. 
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0(). 
int _dbus_hash_table_get_n_entries(DBusHashTable *table)
Gets the number of hash entries in a hash table. 
dbus_bool_t _dbus_timeout_list_add_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout)
Adds a new timeout to the timeout list, invoking the application DBusAddTimeoutFunction if appropriat...
void _dbus_transport_set_windows_user_function(DBusTransport *transport, DBusAllowWindowsUserFunction function, void *data, DBusFreeFunction free_data_function, void **old_data, DBusFreeFunction *old_free_data_function)
See dbus_connection_set_windows_user_function(). 
void _dbus_connection_remove_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Removes a watch using the connection's DBusRemoveWatchFunction if available. 
dbus_bool_t _dbus_transport_get_adt_audit_session_data(DBusTransport *transport, void **data, int *data_size)
See dbus_connection_get_adt_audit_session_data(). 
dbus_bool_t _dbus_pending_call_is_timeout_added_unlocked(DBusPendingCall *pending)
Checks to see if a timeout has been added. 
void * _dbus_hash_iter_get_value(DBusHashIter *iter)
Gets the value of the current entry. 
void * dispatch_status_data
Application data for dispatch_status_function. 
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE. 
dbus_bool_t _dbus_connection_has_messages_to_send_unlocked(DBusConnection *connection)
Checks whether there are messages in the outgoing message queue. 
void dbus_connection_set_exit_on_disconnect(DBusConnection *connection, dbus_bool_t exit_on_disconnect)
Set whether _exit() should be called when the connection receives a disconnect signal. 
dbus_bool_t dbus_message_is_signal(DBusMessage *message, const char *iface, const char *signal_name)
Checks whether the message is a signal with the given interface and member fields. 
DBusTransport * transport
Object that sends/receives messages over network. 
DBusDispatchStatus dbus_connection_dispatch(DBusConnection *connection)
Processes any incoming data. 
dbus_bool_t dbus_connection_send(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *serial)
Adds a message to the outgoing message queue. 
dbus_bool_t _dbus_transport_peek_is_authenticated(DBusTransport *transport)
Returns TRUE if we have been authenticated. 
DBusDispatchStatus dbus_connection_get_dispatch_status(DBusConnection *connection)
Gets the current state of the incoming message queue. 
All currently available data has been processed. 
dbus_bool_t(* DBusAddTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus needs a new timeout to be monitored by the main loop. 
void * dbus_connection_get_data(DBusConnection *connection, dbus_int32_t slot)
Retrieves data previously set with dbus_connection_set_data(). 
DBusTimeoutList * timeouts
Stores active timeouts. 
dbus_bool_t _dbus_object_tree_list_registered_and_unlock(DBusObjectTree *tree, const char **parent_path, char ***child_entries)
Lists the registered fallback handlers and object path handlers at the given parent_path. 
dbus_bool_t(* DBusTimeoutAddFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held. 
long dbus_connection_get_max_message_size(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_message_size(). 
DBusHashTable * pending_replies
Hash of message serials to DBusPendingCall. 
Internals of DBusObjectTree. 
void _dbus_warn(const char *format,...)
Prints a warning message to stderr. 
void _dbus_counter_unref(DBusCounter *counter)
Decrements refcount of the counter and possibly finalizes the counter. 
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer. 
void _dbus_message_remove_counter(DBusMessage *message, DBusCounter *counter)
Removes a counter tracking the size/unix fds of this message, and decrements the counter by the size/...
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list. 
dbus_bool_t _dbus_decompose_path(const char *data, int len, char ***path, int *path_len)
Decompose an object path. 
dbus_bool_t _dbus_hash_table_insert_string(DBusHashTable *table, char *key, void *value)
Creates a hash entry with the given key and value. 
dbus_bool_t dbus_connection_get_unix_process_id(DBusConnection *connection, unsigned long *pid)
Gets the process ID of the connection if any. 
dbus_bool_t dbus_connection_get_is_authenticated(DBusConnection *connection)
Gets whether the connection was authenticated. 
void dbus_connection_close(DBusConnection *connection)
Closes a private connection, so no further data can be sent or received. 
dbus_bool_t dbus_connection_allocate_data_slot(dbus_int32_t *slot_p)
Allocates an integer ID to be used for storing application-specific data on any DBusConnection. 
dbus_bool_t(* DBusAllowUnixUserFunction)(DBusConnection *connection, unsigned long uid, void *data)
Called during authentication to check whether the given UNIX user ID is allowed to connect...
dbus_bool_t _dbus_data_slot_list_set(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot, void *data, DBusFreeFunction free_data_func, DBusFreeFunction *old_free_func, void **old_data)
Stores a pointer in the data slot list, along with an optional function to be used for freeing the da...
dbus_bool_t io_path_acquired
Someone has transport io path (can use the transport to read/write messages) 
void _dbus_list_foreach(DBusList **list, DBusForeachFunction function, void *data)
Calls the given function for each element in the list. 
void(* DBusWakeupMainFunction)(void *data)
Called when the main loop's thread should be notified that there's now work to do. 
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString. 
Internals of DBusAddressEntry. 
DBusList * outgoing_messages
Queue of messages we need to send, send the end of the list first. 
dbus_bool_t dbus_connection_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
Registers a handler for a given path in the object hierarchy. 
void dbus_connection_set_max_message_unix_fds(DBusConnection *connection, long n)
Specifies the maximum number of unix fds a message on this connection is allowed to receive...
DBusObjectTree * objects
Object path handlers registered with this connection. 
long dbus_connection_get_outgoing_unix_fds(DBusConnection *connection)
Gets the approximate number of uni fds of all messages in the outgoing message queue. 
void(* DBusWatchRemoveFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held. 
dbus_uint32_t client_serial
Client serial. 
long dbus_connection_get_max_received_size(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_received_size(). 
DBusCMutex * io_path_mutex
Protects io_path_acquired. 
#define DBUS_MESSAGE_TYPE_METHOD_CALL
Message type of a method call message, see dbus_message_get_type() 
DBusConnection * dbus_connection_open(const char *address, DBusError *error)
Gets a connection to a remote address. 
void _dbus_connection_unref_unlocked(DBusConnection *connection)
Decrements the reference count of a DBusConnection. 
dbus_bool_t _dbus_connection_handle_watch(DBusWatch *watch, unsigned int condition, void *data)
A callback for use with dbus_watch_new() to create a DBusWatch. 
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called, so we can reinit things after it's been called. 
dbus_bool_t dbus_connection_send_with_reply(DBusConnection *connection, DBusMessage *message, DBusPendingCall **pending_return, int timeout_milliseconds)
Queues a message to send, as with dbus_connection_send(), but also returns a DBusPendingCall used to ...
Object representing an exception. 
void _dbus_hash_iter_remove_entry(DBusHashIter *iter)
Removes the current entry from the hash table. 
void _dbus_bus_notify_shared_connection_disconnected_unlocked(DBusConnection *connection)
Internal function that checks to see if this is a shared connection owned by the bus and if it is unr...
void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday(). 
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN); 
dbus_bool_t _dbus_transport_get_is_anonymous(DBusTransport *transport)
See dbus_connection_get_is_anonymous(). 
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it. 
dbus_bool_t dbus_connection_get_object_path_data(DBusConnection *connection, const char *path, void **data_p)
Gets the user data passed to dbus_connection_register_object_path() or dbus_connection_register_fallb...
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list. 
#define DBUS_ERROR_UNKNOWN_OBJECT
Object you invoked a method on isn't known. 
dbus_bool_t dbus_connection_get_is_anonymous(DBusConnection *connection)
Gets whether the connection is not authenticated as a specific user. 
#define DBUS_MESSAGE_TYPE_SIGNAL
Message type of a signal message, see dbus_message_get_type() 
dbus_bool_t _dbus_connection_add_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Adds a watch using the connection's DBusAddWatchFunction if available. 
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError. 
dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
Returns the serial that the message is a reply to or 0 if none. 
long dbus_connection_get_max_message_unix_fds(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_message_unix_fds(). 
DBusWakeupMainFunction wakeup_main_function
Function to wake up the mainloop. 
dbus_bool_t _dbus_connection_send_and_unlock(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *client_serial)
Like dbus_connection_send(), but assumes the connection is already locked on function entry...
void _dbus_cmutex_unlock(DBusCMutex *mutex)
Unlocks a mutex. 
dbus_bool_t(* DBusAllowWindowsUserFunction)(DBusConnection *connection, const char *user_sid, void *data)
Called during authentication to check whether the given Windows user ID is allowed to connect...
DBusDataSlotList slot_list
Data stored by allocated integer ID. 
DBusPendingCall * dbus_pending_call_ref(DBusPendingCall *pending)
Increments the reference count on a pending call. 
void _dbus_connection_message_sent_unlocked(DBusConnection *connection, DBusMessage *message)
Notifies the connection that a message has been sent, so the message can be removed from the outgoing...
void _dbus_timeout_list_toggle_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout, dbus_bool_t enabled)
Sets a timeout to the given enabled state, invoking the application's DBusTimeoutToggledFunction if a...
dbus_uint32_t _dbus_pending_call_get_reply_serial_unlocked(DBusPendingCall *pending)
Gets the reply's serial number. 
DBusTransport * _dbus_transport_open(DBusAddressEntry *entry, DBusError *error)
Try to open a new transport for the given address entry. 
DBusConnection * _dbus_connection_new_for_transport(DBusTransport *transport)
Creates a new connection for the given transport. 
#define _DBUS_UNLOCK(name)
Unlocks a global lock. 
unsigned int disconnected_message_arrived
We popped or are dispatching the disconnected message. 
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(). 
void dbus_connection_set_allow_anonymous(DBusConnection *connection, dbus_bool_t value)
This function must be called on the server side of a connection when the connection is first seen in ...
unsigned int disconnected_message_processed
We did our default handling of the disconnected message, such as closing the connection. 
dbus_bool_t _dbus_transport_get_unix_user(DBusTransport *transport, unsigned long *uid)
See dbus_connection_get_unix_user(). 
void * _dbus_data_slot_list_get(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot)
Retrieves data previously set with _dbus_data_slot_list_set_data(). 
#define CONNECTION_UNLOCK(connection)
shorter and more visible way to write _dbus_connection_unlock() 
void(* DBusTimeoutToggledFunction)(DBusTimeout *timeout, void *data)
Called when dbus_timeout_get_enabled() may return a different value than it did before. 
unsigned int route_peer_messages
If TRUE, if org.freedesktop.DBus.Peer messages have a bus name, don't handle them automatically...
#define TRUE
Expands to "1". 
void _dbus_connection_set_pending_fds_function(DBusConnection *connection, DBusPendingFdsChangeFunction callback, void *data)
Register a function to be called whenever the number of pending file descriptors in the loader change...
void _dbus_data_slot_list_init(DBusDataSlotList *list)
Initializes a slot list. 
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called. 
Data structure that stores the actual user data set at a given slot. 
DBusCondVar * io_path_cond
Notify when io_path_acquired is available. 
void(* DBusTimeoutToggleFunction)(DBusTimeoutList *list, DBusTimeout *timeout, dbus_bool_t enabled)
Function to be called in protected_change_timeout() with refcount held. 
void _dbus_condvar_new_at_location(DBusCondVar **location_p)
This does the same thing as _dbus_condvar_new. 
DBusDispatchStatus last_dispatch_status
The last dispatch status we reported to the application. 
unsigned int exit_on_disconnect
If TRUE, exit after handling disconnect signal. 
dbus_bool_t _dbus_transport_set_connection(DBusTransport *transport, DBusConnection *connection)
Sets the connection using this transport. 
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more. 
dbus_bool_t _dbus_watch_list_add_watch(DBusWatchList *watch_list, DBusWatch *watch)
Adds a new watch to the watch list, invoking the application DBusAddWatchFunction if appropriate...
void _dbus_list_free_link(DBusList *link)
Frees a linked list node allocated with _dbus_list_alloc_link. 
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest. 
const char * name
public error name field 
void * _dbus_object_tree_get_user_data_unlocked(DBusObjectTree *tree, const char **path)
Looks up the data passed to _dbus_object_tree_register() for a handler at the given path...
dbus_bool_t _dbus_object_tree_register(DBusObjectTree *tree, dbus_bool_t fallback, const char **path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a new subtree in the global object tree. 
dbus_bool_t dbus_set_error_from_message(DBusError *error, DBusMessage *message)
Sets a DBusError based on the contents of the given message. 
dbus_bool_t(* DBusAddWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus needs a new watch to be monitored by the main loop. 
void _dbus_condvar_wake_one(DBusCondVar *cond)
If there are threads waiting on the condition variable, wake up exactly one. 
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor. 
void(* DBusWatchToggleFunction)(DBusWatchList *list, DBusWatch *watch, dbus_bool_t enabled)
Function to be called in protected_change_watch() with refcount held. 
void dbus_pending_call_unref(DBusPendingCall *pending)
Decrements the reference count on a pending call, freeing it if the count reaches 0...
Object representing a transport such as a socket. 
void(* DBusRemoveWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus no longer needs a watch to be monitored by the main loop. 
DBusWatchList implementation details. 
const char * dbus_message_get_interface(DBusMessage *message)
Gets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted...
int n_incoming
Length of incoming queue. 
void dbus_connection_set_wakeup_main_function(DBusConnection *connection, DBusWakeupMainFunction wakeup_main_function, void *data, DBusFreeFunction free_data_function)
Sets the mainloop wakeup function for the connection. 
DBusMessage * dbus_connection_pop_message(DBusConnection *connection)
Returns the first-received message from the incoming message queue, removing it from the queue...
An allocator that tracks a set of slot IDs. 
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code. 
dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
Sets the reply serial of a message (the serial of the message this is a reply to). 
void _dbus_exit(int code)
Exit the process, returning the given value. 
void _dbus_pending_call_queue_timeout_error_unlocked(DBusPendingCall *pending, DBusConnection *connection)
If the pending call hasn't been timed out, add its timeout error reply to the connection's incoming m...
Internals of DBusPreallocatedSend. 
void dbus_connection_set_unix_user_function(DBusConnection *connection, DBusAllowUnixUserFunction function, void *data, DBusFreeFunction free_data_function)
Sets a predicate function used to determine whether a given user ID is allowed to connect...
void(* DBusDispatchStatusFunction)(DBusConnection *connection, DBusDispatchStatus new_status, void *data)
Called when the return value of dbus_connection_get_dispatch_status() may have changed. 
dbus_bool_t _dbus_transport_handle_watch(DBusTransport *transport, DBusWatch *watch, unsigned int condition)
Handles a watch by reading data, writing data, or disconnecting the transport, as appropriate for the...
DBusList * counter_link
Preallocated link in the resource counter. 
DBusObjectTree * _dbus_object_tree_new(DBusConnection *connection)
Creates a new object tree, representing a mapping from paths to handler vtables. 
void _dbus_watch_list_remove_watch(DBusWatchList *watch_list, DBusWatch *watch)
Removes a watch from the watch list, invoking the application's DBusRemoveWatchFunction if appropriat...
void dbus_pending_call_block(DBusPendingCall *pending)
Block until the pending call is completed. 
dbus_bool_t _dbus_hash_table_remove_string(DBusHashTable *table, const char *key)
Removes the hash entry for the given key. 
void _dbus_timeout_list_remove_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout)
Removes a timeout from the timeout list, invoking the application's DBusRemoveTimeoutFunction if appr...
int n_outgoing
Length of outgoing queue. 
DBusCMutex * dispatch_mutex
Protects dispatch_acquired. 
DBUS_PRIVATE_EXPORT DBusPendingCall * _dbus_pending_call_new_unlocked(DBusConnection *connection, int timeout_milliseconds, DBusTimeoutHandler timeout_handler)
Creates a new pending reply object. 
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer. 
void _dbus_pending_call_set_reply_unlocked(DBusPendingCall *pending, DBusMessage *message)
Sets the reply of a pending call with the given message, or if the message is NULL, by timing out the pending call. 
void(* DBusTimeoutRemoveFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held. 
dbus_bool_t dbus_connection_set_watch_functions(DBusConnection *connection, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the watch functions for the connection. 
void _dbus_hash_iter_init(DBusHashTable *table, DBusHashIter *iter)
Initializes a hash table iterator. 
void _dbus_list_unlink(DBusList **list, DBusList *link)
Removes the given link from the list, but doesn't free it. 
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings. 
DBusHandlerResult(* DBusHandleMessageFunction)(DBusConnection *connection, DBusMessage *message, void *user_data)
Called when a message needs to be handled. 
DBusTransport * _dbus_transport_ref(DBusTransport *transport)
Increments the reference count for the transport. 
dbus_bool_t _dbus_transport_try_to_authenticate(DBusTransport *transport)
Returns TRUE if we have been authenticated. 
DBusCondVar * dispatch_cond
Notify when dispatch_acquired is available. 
void _dbus_connection_remove_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout)
Removes a timeout using the connection's DBusRemoveTimeoutFunction if available. 
dbus_bool_t dbus_connection_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
Registers a fallback handler for a given subsection of the object hierarchy. 
void _dbus_rmutex_free_at_location(DBusRMutex **location_p)
Frees a DBusRMutex; does nothing if passed a NULL pointer. 
void _dbus_transport_do_iteration(DBusTransport *transport, unsigned int flags, int timeout_milliseconds)
Performs a single poll()/select() on the transport's file descriptors and then reads/writes data as a...
long _dbus_transport_get_max_received_size(DBusTransport *transport)
See dbus_connection_get_max_received_size(). 
dbus_bool_t dbus_connection_get_adt_audit_session_data(DBusConnection *connection, void **data, dbus_int32_t *data_size)
Gets the ADT audit data of the connection if any. 
long _dbus_transport_get_max_message_unix_fds(DBusTransport *transport)
See dbus_connection_get_max_message_unix_fds(). 
void * _dbus_hash_table_lookup_string(DBusHashTable *table, const char *key)
Looks up the value for a given string in a hash table of type DBUS_HASH_STRING. 
void * _dbus_hash_table_lookup_int(DBusHashTable *table, int key)
Looks up the value for a given integer in a hash table of type DBUS_HASH_INT. 
void _dbus_transport_set_pending_fds_function(DBusTransport *transport, void(*callback)(void *), void *data)
Register a function to be called whenever the number of pending file descriptors in the loader change...
#define DBUS_ERROR_DISCONNECTED
The connection is disconnected and you're trying to use it. 
DBusCounter * _dbus_counter_new(void)
Creates a new DBusCounter. 
void _dbus_cmutex_lock(DBusCMutex *mutex)
Locks a mutex. 
void _dbus_connection_queue_received_message_link(DBusConnection *connection, DBusList *link)
Adds a message-containing list link to the incoming message queue, taking ownership of the link and t...
void _dbus_transport_set_allow_anonymous(DBusTransport *transport, dbus_bool_t value)
See dbus_connection_set_allow_anonymous() 
void _dbus_connection_close_possibly_shared(DBusConnection *connection)
Closes a shared OR private connection, while dbus_connection_close() can only be used on private conn...
DBusHandleMessageFunction function
Function to call to filter. 
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation. 
void _dbus_connection_remove_pending_call(DBusConnection *connection, DBusPendingCall *pending)
Removes a pending call from the connection, such that the pending reply will be ignored. 
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message. 
void _dbus_transport_set_max_received_size(DBusTransport *transport, long size)
See dbus_connection_set_max_received_size(). 
void(* DBusForeachFunction)(void *element, void *data)
Used to iterate over each item in a collection, such as a DBusList. 
DBusList * expired_messages
Messages that will be released when we next unlock. 
DBusList * _dbus_list_get_first_link(DBusList **list)
Gets the first link in the list. 
#define FALSE
Expands to "0". 
int dbus_message_get_type(DBusMessage *message)
Gets the type of a message. 
char * dbus_connection_get_server_id(DBusConnection *connection)
Gets the ID of the server address we are authenticated to, if this connection is on the client side...
dbus_bool_t dbus_connection_get_unix_fd(DBusConnection *connection, int *fd)
Get the UNIX file descriptor of the connection, if any. 
int _dbus_transport_get_pending_fds_count(DBusTransport *transport)
Return how many file descriptors are pending in the loader. 
void _dbus_list_prepend_link(DBusList **list, DBusList *link)
Prepends a link to the list. 
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_register_shutdown_func(DBusShutdownFunction function, void *data)
Register a cleanup function to be called exactly once the next time dbus_shutdown() is called...
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary. 
dbus_bool_t dbus_parse_address(const char *address, DBusAddressEntry ***entry, int *array_len, DBusError *error)
Parses an address string of the form: 
#define _DBUS_LOCK_NAME(name)
Expands to name of a global lock variable. 
dbus_bool_t _dbus_transport_can_pass_unix_fd(DBusTransport *transport)
Returns TRUE if the transport supports sending unix fds. 
void _dbus_cmutex_free_at_location(DBusCMutex **location_p)
Frees a DBusCMutex; does nothing if passed a NULL pointer. 
char * server_guid
GUID of server if we are in shared_connections, NULL if server GUID is unknown or connection is priva...
dbus_bool_t dbus_connection_get_is_connected(DBusConnection *connection)
Gets whether the connection is currently open. 
void dbus_connection_send_preallocated(DBusConnection *connection, DBusPreallocatedSend *preallocated, DBusMessage *message, dbus_uint32_t *client_serial)
Sends a message using preallocated resources. 
void dbus_connection_unref(DBusConnection *connection)
Decrements the reference count of a DBusConnection, and finalizes it if the count reaches zero...
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer. 
Internals of DBusHashTable. 
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds. 
void _dbus_object_tree_unref(DBusObjectTree *tree)
Decrement the reference count. 
dbus_bool_t _dbus_data_slot_allocator_alloc(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Allocates an integer ID to be used for storing data in a DBusDataSlotList. 
DBUS_PRIVATE_EXPORT DBusPendingCall * _dbus_pending_call_ref_unlocked(DBusPendingCall *pending)
Increments the reference count on a pending call, while the lock on its connection is already held...
DBusMessage * dbus_connection_borrow_message(DBusConnection *connection)
Returns the first-received message from the incoming message queue, leaving it in the queue...
DBusConnection * _dbus_connection_ref_unlocked(DBusConnection *connection)
Increments the reference count of a DBusConnection. 
Message has had its effect - no need to run more handlers. 
void _dbus_connection_do_iteration_unlocked(DBusConnection *connection, DBusPendingCall *pending, unsigned int flags, int timeout_milliseconds)
Queues incoming messages and sends outgoing messages for this connection, optionally blocking in the ...
char * _dbus_strdup(const char *str)
Duplicates a string. 
#define CONNECTION_LOCK(connection)
Internals of DBusPendingCall. 
dbus_bool_t dispatch_acquired
Someone has dispatch path (can drain incoming queue) 
void _dbus_transport_disconnect(DBusTransport *transport)
Closes our end of the connection to a remote application. 
DBusTimeout * _dbus_pending_call_get_timeout_unlocked(DBusPendingCall *pending)
Retrives the timeout. 
void _dbus_data_slot_allocator_free(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Deallocates an ID previously allocated with _dbus_data_slot_allocator_alloc(). 
dbus_bool_t dbus_connection_add_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data, DBusFreeFunction free_data_function)
Adds a message filter. 
dbus_bool_t dbus_connection_unregister_object_path(DBusConnection *connection, const char *path)
Unregisters the handler registered with exactly the given path. 
long dbus_connection_get_max_received_unix_fds(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_received_unix_fds(). 
dbus_bool_t dbus_connection_try_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a handler for a given path in the object hierarchy. 
void _dbus_connection_unlock(DBusConnection *connection)
Releases the connection lock. 
const char * dbus_message_type_to_string(int type)
Utility function to convert a D-Bus message type into a machine-readable string (not translated)...
void _dbus_transport_set_max_message_size(DBusTransport *transport, long size)
See dbus_connection_set_max_message_size(). 
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
void * wakeup_main_data
Application data for wakeup_main_function. 
Need more memory in order to return DBUS_HANDLER_RESULT_HANDLED or DBUS_HANDLER_RESULT_NOT_YET_HANDLE...
void dbus_connection_flush(DBusConnection *connection)
Blocks until the outgoing message queue is empty. 
void _dbus_condvar_free_at_location(DBusCondVar **location_p)
Frees a condition variable; does nothing if passed a NULL pointer. 
dbus_bool_t dbus_connection_has_messages_to_send(DBusConnection *connection)
Checks whether there are messages in the outgoing message queue. 
void _dbus_cmutex_new_at_location(DBusCMutex **location_p)
Creates a new mutex or creates a no-op mutex if threads are not initialized. 
DBUS_PRIVATE_EXPORT void _dbus_pending_call_unref_and_unlock(DBusPendingCall *pending)
Decrements the reference count on a pending call, freeing it if the count reaches 0...
DBusDispatchStatus _dbus_transport_get_dispatch_status(DBusTransport *transport)
Reports our current dispatch status (whether there's buffered data to be queued as messages...
void _dbus_pending_call_set_timeout_added_unlocked(DBusPendingCall *pending, dbus_bool_t is_added)
Sets wether the timeout has been added. 
DBusConnection * connection
Connection we'd send the message to. 
DBusConnection * _dbus_pending_call_get_connection_and_lock(DBusPendingCall *pending)
Gets the connection associated with this pending call. 
void _dbus_connection_toggle_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout, dbus_bool_t enabled)
Toggles a timeout and notifies app via connection's DBusTimeoutToggledFunction if available...
dbus_bool_t dbus_type_is_valid(int typecode)
Return TRUE if the argument is a valid typecode. 
void _dbus_transport_set_max_message_unix_fds(DBusTransport *transport, long n)
See dbus_connection_set_max_message_unix_fds(). 
void dbus_connection_set_max_received_unix_fds(DBusConnection *connection, long n)
Sets the maximum total number of unix fds that can be used for all messages received on this connecti...
DBusHashTable * _dbus_hash_table_new(DBusHashType type, DBusFreeFunction key_free_function, DBusFreeFunction value_free_function)
Constructs a new hash table. 
dbus_bool_t dbus_connection_get_socket(DBusConnection *connection, int *fd)
Gets the underlying Windows or UNIX socket file descriptor of the connection, if any. 
void dbus_connection_free_preallocated_send(DBusConnection *connection, DBusPreallocatedSend *preallocated)
Frees preallocated message-sending resources from dbus_connection_preallocate_send(). 
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message. 
DBusTimeoutList implementation details. 
DBusMessage * dbus_message_new_method_return(DBusMessage *method_call)
Constructs a message that is a reply to a method call. 
DBusRMutex * slot_mutex
Lock on slot_list so overall connection lock need not be taken. 
void _dbus_transport_unref(DBusTransport *transport)
Decrements the reference count for the transport. 
long _dbus_counter_get_unix_fd_value(DBusCounter *counter)
Gets the current value of the unix fd counter. 
void _dbus_data_slot_list_free(DBusDataSlotList *list)
Frees the data slot list and all data slots contained in it, calling application-provided free functi...
void _dbus_list_clear(DBusList **list)
Frees all links in the list and sets the list head to NULL. 
DBUS_EXPORT int dbus_timeout_get_interval(DBusTimeout *timeout)
Gets the timeout interval. 
dbus_bool_t dbus_connection_read_write_dispatch(DBusConnection *connection, int timeout_milliseconds)
This function is intended for use with applications that don't want to write a main loop and deal wit...
long _dbus_counter_get_size_value(DBusCounter *counter)
Gets the current value of the size counter. 
DBusMessage * dbus_message_new_error(DBusMessage *reply_to, const char *error_name, const char *error_message)
Creates a new message that is an error reply to another message.