25 #include "dbus-internals.h"    26 #include "dbus-connection-internal.h"    27 #include "dbus-nonce.h"    28 #include "dbus-transport-socket.h"    29 #include "dbus-transport-protected.h"    30 #include "dbus-watch.h"    31 #include "dbus-credentials.h"    76   _dbus_verbose (
"start\n");
    98   _dbus_verbose (
"end\n");
   106   _dbus_verbose (
"\n");
   108   free_watches (transport);
   146           DBusAuthState auth_state;
   154           if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||
   155               auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
   162   _dbus_verbose (
"check_write_watch(): needed = %d on connection %p watch %p fd = %" DBUS_SOCKET_FORMAT 
" outgoing messages exist %d\n",
   164                  _dbus_socket_printable (socket_transport->
fd),
   180   _dbus_verbose (
"fd = %" DBUS_SOCKET_FORMAT 
"\n",
   181                  _dbus_socket_printable (socket_transport->
fd));
   201         need_read_watch = 
TRUE;
   208           DBusAuthState auth_state;
   218           if (auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT ||
   219               auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY ||
   220               auth_state == DBUS_AUTH_STATE_AUTHENTICATED)
   221             need_read_watch = 
TRUE;
   223             need_read_watch = 
FALSE;
   227   _dbus_verbose (
"  setting read watch enabled = %d\n", need_read_watch);
   259   saved_errno = _dbus_save_socket_errno ();
   265       _dbus_verbose (
" read %d bytes in auth phase\n", bytes_read);
   269   else if (bytes_read < 0)
   281           _dbus_verbose (
"Error reading from remote app: %s\n",
   282                          _dbus_strerror (saved_errno));
   283           do_io_error (transport);
   292       _dbus_verbose (
"Disconnected from remote app\n");
   293       do_io_error (transport);
   314                                       0, _dbus_string_get_length (buffer));
   315   saved_errno = _dbus_save_socket_errno ();
   317   if (bytes_written > 0)
   322   else if (bytes_written < 0)
   330           _dbus_verbose (
"Error writing to remote app: %s\n",
   331                          _dbus_strerror (saved_errno));
   332           do_io_error (transport);
   348   _dbus_verbose (
"exchange_credentials: do_reading = %d, do_writing = %d\n",
   349                   do_reading, do_writing);
   360           _dbus_verbose (
"Failed to write credentials: %s\n", error.
message);
   362           do_io_error (transport);
   383           _dbus_verbose (
"Failed to read credentials %s\n", error.
message);
   385           do_io_error (transport);
   420         *auth_completed = 
FALSE;
   429       if (!exchange_credentials (transport, do_reading, do_writing))
   439           _dbus_verbose (
"send_credentials_pending = %d receive_credentials_pending = %d\n",
   445 #define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")   448         case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
   449           _dbus_verbose (
" %s auth state: waiting for input\n",
   450                          TRANSPORT_SIDE (transport));
   451           if (!do_reading || !read_data_into_auth (transport, &oom))
   455         case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
   456           _dbus_verbose (
" %s auth state: waiting for memory\n",
   457                          TRANSPORT_SIDE (transport));
   462         case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
   463           _dbus_verbose (
" %s auth state: bytes to send\n",
   464                          TRANSPORT_SIDE (transport));
   465           if (!do_writing || !write_data_from_auth (transport))
   469         case DBUS_AUTH_STATE_NEED_DISCONNECT:
   470           _dbus_verbose (
" %s auth state: need to disconnect\n",
   471                          TRANSPORT_SIDE (transport));
   472           do_io_error (transport);
   475         case DBUS_AUTH_STATE_AUTHENTICATED:
   476           _dbus_verbose (
" %s auth state: authenticated\n",
   477                          TRANSPORT_SIDE (transport));
   486   check_read_watch (transport);
   487   check_write_watch (transport);
   507       _dbus_verbose (
"Not authenticated, not writing anything\n");
   513       _dbus_verbose (
"Not connected, not writing anything\n");
   518   _dbus_verbose (
"do_writing(), have_messages = %d, fd = %" DBUS_SOCKET_FORMAT 
"\n",
   520                  _dbus_socket_printable (socket_transport->
fd));
   533       int header_len, body_len;
   534       int total_bytes_to_write;
   539           _dbus_verbose (
"%d bytes exceeds %d bytes written per iteration, returning\n",
   549       _dbus_verbose (
"writing message %p\n", message);
   555       header_len = _dbus_string_get_length (header);
   556       body_len = _dbus_string_get_length (body);
   561           _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
   581           total_bytes_to_write = _dbus_string_get_length (&socket_transport->
encoded_outgoing);
   584           _dbus_verbose (
"encoded message is %d bytes\n",
   585                          total_bytes_to_write);
   593           saved_errno = _dbus_save_socket_errno ();
   597           total_bytes_to_write = header_len + body_len;
   600           _dbus_verbose (
"message is %d bytes\n",
   601                          total_bytes_to_write);
   604 #ifdef HAVE_UNIX_FD_PASSING   614                 _dbus_write_socket_with_unix_fds_two (socket_transport->
fd,
   622               saved_errno = _dbus_save_socket_errno ();
   624               if (bytes_written > 0 && n > 0)
   625                 _dbus_verbose(
"Wrote %i unix fds\n", n);
   650               saved_errno = _dbus_save_socket_errno ();
   654       if (bytes_written < 0)
   683               _dbus_verbose (
" discard message of %d bytes due to ETOOMANYREFS\n",
   684                              total_bytes_to_write);
   698               _dbus_verbose (
"Error writing to remote app: %s\n",
   699                              _dbus_strerror (saved_errno));
   700               do_io_error (transport);
   706           _dbus_verbose (
" wrote %d bytes of %d\n", bytes_written,
   707                          total_bytes_to_write);
   709           total += bytes_written;
   713                         total_bytes_to_write);
   745   _dbus_verbose (
"fd = %" DBUS_SOCKET_FORMAT 
"\n",
   746                  _dbus_socket_printable (socket_transport->
fd));
   759   check_read_watch (transport);
   763       _dbus_verbose (
"%d bytes exceeds %d bytes read per iteration, returning\n",
   780       _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
   789       saved_errno = _dbus_save_socket_errno ();
   803               _dbus_verbose (
"Out of memory decoding incoming data\n");
   823 #ifdef HAVE_UNIX_FD_PASSING   824       if (DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
   830               _dbus_verbose (
"Out of memory reading file descriptors\n");
   840           saved_errno = _dbus_save_socket_errno ();
   842           if (bytes_read >= 0 && n_fds > 0)
   843             _dbus_verbose(
"Read %i unix fds\n", n_fds);
   852           saved_errno = _dbus_save_socket_errno ();
   865           _dbus_verbose (
"Out of memory in read()/do_reading()\n");
   873           _dbus_verbose (
"Error reading from remote app: %s\n",
   874                          _dbus_strerror (saved_errno));
   875           do_io_error (transport);
   879   else if (bytes_read == 0)
   881       _dbus_verbose (
"Disconnected from remote app\n");
   882       do_io_error (transport);
   887       _dbus_verbose (
" read %d bytes\n", bytes_read);
   894           _dbus_verbose (
" out of memory when queueing messages we just read in the transport\n");
   925       _dbus_watch_get_enabled (transport->
read_watch))
   946   if (!(flags & 
DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
   948       _dbus_verbose (
"Hang up or error on watch\n");
   954       (flags & DBUS_WATCH_READABLE))
   958       _dbus_verbose (
"handling read watch %p flags = %x\n",
   961       if (!do_authentication (transport, 
TRUE, 
FALSE, &auth_finished))
   972           if (!do_reading (transport))
   974               _dbus_verbose (
"no memory to read\n");
   980           _dbus_verbose (
"Not reading anything since we just completed the authentication\n");
   987       _dbus_verbose (
"handling write watch, have_outgoing_messages = %d\n",
   993       if (!do_writing (transport))
   995           _dbus_verbose (
"no memory to write\n");
  1000       check_write_watch (transport);
  1002 #ifdef DBUS_ENABLE_VERBOSE_MODE  1006         _dbus_verbose (
"asked to handle read watch with non-read condition 0x%x\n",
  1009         _dbus_verbose (
"asked to handle write watch with non-write condition 0x%x\n",
  1012         _dbus_verbose (
"asked to handle watch %p on fd %" DBUS_SOCKET_FORMAT 
" that we don't recognize\n",
  1025   _dbus_verbose (
"\n");
  1027   free_watches (transport);
  1030   _dbus_socket_invalidate (&socket_transport->
fd);
  1058   check_read_watch (transport);
  1059   check_write_watch (transport);
  1074                    int            timeout_milliseconds)
  1081   _dbus_verbose (
" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %" DBUS_SOCKET_FORMAT 
"\n",
  1082                  flags & DBUS_ITERATION_DO_READING ? 
"read" : 
"",
  1083                  flags & DBUS_ITERATION_DO_WRITING ? 
"write" : 
"",
  1084                  timeout_milliseconds,
  1087                  _dbus_socket_printable (socket_transport->
fd));
  1095   poll_fd.
fd = _dbus_socket_get_pollable (socket_transport->
fd);
  1110       if ((flags & DBUS_ITERATION_DO_WRITING) &&
  1111           !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
  1115           do_writing (transport);
  1124       if (flags & DBUS_ITERATION_DO_READING)
  1128       if (flags & DBUS_ITERATION_DO_WRITING)
  1133       DBusAuthState auth_state;
  1138           auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
  1142           auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
  1150       if (flags & DBUS_ITERATION_BLOCK)
  1151         poll_timeout = timeout_milliseconds;
  1160       if (flags & DBUS_ITERATION_BLOCK)
  1162           _dbus_verbose (
"unlock pre poll\n");
  1167       poll_res = 
_dbus_poll (&poll_fd, 1, poll_timeout);
  1168       saved_errno = _dbus_save_socket_errno ();
  1173       if (flags & DBUS_ITERATION_BLOCK)
  1175           _dbus_verbose (
"lock post poll\n");
  1188             do_io_error (transport);
  1195               _dbus_verbose (
"in iteration, need_read=%d need_write=%d\n",
  1196                              need_read, need_write);
  1197               do_authentication (transport, need_read, need_write,
  1198                                  &authentication_completed);
  1201               if (authentication_completed)
  1204               if (need_read && (flags & DBUS_ITERATION_DO_READING))
  1205                 do_reading (transport);
  1206               if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
  1207                 do_writing (transport);
  1212           _dbus_verbose (
"Error from _dbus_poll(): %s\n",
  1213                          _dbus_strerror (saved_errno));
  1229   check_write_watch (transport);
  1231   _dbus_verbose (
" ... leaving do_iteration()\n");
  1238   check_read_watch (transport);
  1248   *fd_p = socket_transport->
fd;
  1255   socket_handle_watch,
  1257   socket_connection_set,
  1258   socket_do_iteration,
  1259   socket_live_messages_changed,
  1260   socket_get_socket_fd
  1282   if (socket_transport == 
NULL)
  1307                                   server_guid, address))
  1310 #ifdef HAVE_UNIX_FD_PASSING  1314   socket_transport->
fd = 
fd;
  1353                                     const char     *noncefile,
  1360   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1382   if (family != 
NULL &&
  1387   if (noncefile != 
NULL &&
  1392   fd = _dbus_connect_tcp_socket_with_nonce (host, port, family, noncefile, error);
  1393   if (!_dbus_socket_is_valid (fd))
  1395       _DBUS_ASSERT_ERROR_IS_SET (error);
  1400   _dbus_verbose (
"Successfully connected to tcp socket %s:%s\n",
  1405   if (transport == 
NULL)
  1409       _dbus_socket_invalidate (&fd);
  1428 DBusTransportOpenResult
  1440   isTcp = strcmp (method, 
"tcp") == 0;
  1441   isNonceTcp = strcmp (method, 
"nonce-tcp") == 0;
  1443   if (isTcp || isNonceTcp)
  1450       if ((isNonceTcp == 
TRUE) != (noncefile != 
NULL)) {
  1452           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
  1458           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
  1462       if (*transport_p == 
NULL)
  1464           _DBUS_ASSERT_ERROR_IS_SET (error);
  1465           return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
  1469           _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1470           return DBUS_TRANSPORT_OPEN_OK;
  1475       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  1476       return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
 Implementation details of DBusTransportSocket. 
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString. 
void dbus_message_lock(DBusMessage *message)
Locks a message. 
DBusTransport base
Parent instance. 
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. 
long max_live_messages_unix_fds
Max total unix fds of received messages. 
const char * message
public error message field 
DBusWatch * _dbus_watch_new(DBusPollable fd, unsigned int flags, dbus_bool_t enabled, DBusWatchHandler handler, void *data, DBusFreeFunction free_data_function)
Creates a new DBusWatch. 
Implementation of DBusWatch. 
DBusTransport * _dbus_transport_new_for_tcp_socket(const char *host, const char *port, const char *family, const char *noncefile, DBusError *error)
Creates a new transport for the given hostname and port. 
#define NULL
A null pointer, defined appropriately for C or C++. 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_return_buffer(DBusMessageLoader *loader, DBusString *buffer)
Returns a buffer obtained from _dbus_message_loader_get_buffer(), indicating to the loader how many b...
DBusAuth * auth
Authentication conversation. 
unsigned int disconnected
TRUE if we are disconnected. 
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0(). 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_return_unix_fds(DBusMessageLoader *loader, int *fds, unsigned n_fds)
Returns a buffer obtained from _dbus_message_loader_get_unix_fds(). 
dbus_bool_t _dbus_auth_needs_decoding(DBusAuth *auth)
Called post-authentication, indicates whether we need to decode the message stream with _dbus_auth_de...
long max_live_messages_size
Max total size of received messages. 
DBUS_PRIVATE_EXPORT void _dbus_connection_lock(DBusConnection *connection)
Acquires the connection lock. 
dbus_bool_t _dbus_auth_encode_data(DBusAuth *auth, const DBusString *plaintext, DBusString *encoded)
Called post-authentication, encodes a block of bytes for sending to the peer. 
DBUS_EXPORT dbus_bool_t dbus_watch_get_enabled(DBusWatch *watch)
Returns whether a watch is enabled or not. 
#define _dbus_assert(condition)
Aborts with an error message if the condition is false. 
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack. 
const char * dbus_address_entry_get_method(DBusAddressEntry *entry)
Returns the method string of an address entry. 
DBusTransportOpenResult _dbus_transport_open_socket(DBusAddressEntry *entry, DBusTransport **transport_p, DBusError *error)
Opens a TCP socket transport. 
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...
void _dbus_auth_return_buffer(DBusAuth *auth, DBusString *buffer)
Returns a buffer with new data read into it. 
DBusAuthState _dbus_auth_do_work(DBusAuth *auth)
Analyzes buffered input and moves the auth conversation forward, returning the new state of the auth ...
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...
int max_bytes_written_per_iteration
To avoid blocking too long. 
DBusConnection * connection
Connection owning this transport. 
#define _DBUS_POLLIN
There is data to read. 
unsigned int send_credentials_pending
TRUE if we need to send credentials 
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows. 
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string. 
DBusMessage * _dbus_connection_get_message_to_send(DBusConnection *connection)
Gets the next outgoing message. 
short events
Events to poll for. 
DBusString encoded_incoming
Encoded version of current incoming data. 
dbus_bool_t _dbus_send_credentials_socket(DBusSocket server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data. 
dbus_bool_t _dbus_close_socket(DBusSocket fd, DBusError *error)
Closes a socket. 
dbus_bool_t _dbus_get_is_errno_etoomanyrefs(int e)
See if errno is ETOOMANYREFS. 
dbus_bool_t _dbus_transport_get_is_connected(DBusTransport *transport)
Returns TRUE if the transport has not been disconnected. 
dbus_bool_t _dbus_transport_init_base(DBusTransport *transport, const DBusTransportVTable *vtable, const DBusString *server_guid, const DBusString *address)
Initializes the base class members of DBusTransport. 
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket. 
void _dbus_auth_get_buffer(DBusAuth *auth, DBusString **buffer)
Get a buffer to be used for reading bytes from the peer we're conversing with. 
Internals of DBusMessage. 
dbus_bool_t _dbus_auth_decode_data(DBusAuth *auth, const DBusString *encoded, DBusString *plaintext)
Called post-authentication, decodes a block of bytes received from the peer. 
const char * dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
Returns a value from a key of an entry. 
DBusSocket fd
File descriptor. 
DBusTransport * _dbus_transport_new_for_socket(DBusSocket fd, const DBusString *server_guid, const DBusString *address)
Creates a new transport for the given socket file descriptor. 
dbus_bool_t _dbus_get_is_errno_epipe(int e)
See if errno is EPIPE. 
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0(). 
void _dbus_auth_bytes_sent(DBusAuth *auth, int bytes_sent)
Notifies the auth conversation object that the given number of bytes of the outgoing buffer have been...
void _dbus_connection_remove_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Removes a watch using the connection's DBusRemoveWatchFunction if available. 
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory. 
unsigned int receive_credentials_pending
TRUE if we need to receive credentials 
DBusCounter * live_messages
Counter for size/unix fds of all live messages. 
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(int e)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted) ...
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. 
DBUS_EXPORT int dbus_watch_get_socket(DBusWatch *watch)
Returns a socket to be watched, on UNIX this will return -1 if our transport is not socket-based so d...
#define _DBUS_POLLOUT
Writing now will not block. 
int _dbus_write_socket_two(DBusSocket fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write_two() but only works on sockets and is thus available on Windows. 
Internals of DBusAddressEntry. 
dbus_bool_t _dbus_read_credentials_socket(DBusSocket client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
DBusWatch * write_watch
Watch for writability. 
void _dbus_watch_invalidate(DBusWatch *watch)
Clears the file descriptor from a now-invalid watch object so that no one tries to use it...
void _dbus_set_bad_address(DBusError *error, const char *address_problem_type, const char *address_problem_field, const char *address_problem_other)
Sets DBUS_ERROR_BAD_ADDRESS. 
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. 
dbus_bool_t _dbus_get_is_errno_eintr(int e)
See if errno is EINTR. 
Object representing an exception. 
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. 
The virtual table that must be implemented to create a new kind of transport. 
int message_bytes_written
Number of bytes of current outgoing message that have been written. 
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...
As in POLLERR (can't watch for this, but can be present in current state passed to dbus_watch_handle(...
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(). 
#define TRUE
Expands to "1". 
DBusPollable fd
File descriptor. 
DBusMessageLoader * loader
Message-loading buffer. 
As in POLLHUP (can't watch for it, but can be present in current state passed to dbus_watch_handle())...
void _dbus_message_get_network_data(DBusMessage *message, const DBusString **header, const DBusString **body)
Gets the data to be sent over the network for this message. 
Object representing a transport such as a socket. 
dbus_bool_t _dbus_auth_set_credentials(DBusAuth *auth, DBusCredentials *credentials)
Sets credentials received via reliable means from the operating system. 
void _dbus_auth_set_unix_fd_possible(DBusAuth *auth, dbus_bool_t b)
Sets whether unix fd passing is potentially on the transport and hence shall be negotiated. 
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_message_loader_get_unix_fds(DBusMessageLoader *loader, int **fds, unsigned *max_n_fds)
Gets the buffer to use for reading unix fds from the network. 
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. 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer)
Gets the buffer to use for reading data from the network. 
dbus_bool_t _dbus_auth_get_bytes_to_send(DBusAuth *auth, const DBusString **str)
Gets bytes that need to be sent to the peer we're conversing with. 
void _dbus_watch_unref(DBusWatch *watch)
Decrements the reference count of a DBusWatch object and finalizes the object if the count reaches ze...
DBusWatch * read_watch
Watch for readability. 
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation. 
#define FALSE
Expands to "0". 
DBusCredentials * credentials
Credentials of other end read from the socket. 
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string. 
int max_bytes_read_per_iteration
To avoid blocking too long. 
int _dbus_write_socket(DBusSocket fd, const DBusString *buffer, int start, int len)
Like _dbus_write(), but only supports sockets and is thus available on Windows. 
dbus_bool_t _dbus_auth_needs_encoding(DBusAuth *auth)
Called post-authentication, indicates whether we need to encode the message stream with _dbus_auth_en...
DBUS_PRIVATE_EXPORT void _dbus_message_get_unix_fds(DBusMessage *message, const int **fds, unsigned *n_fds)
Gets the unix fds to be sent over the network for this message. 
void _dbus_watch_set_handler(DBusWatch *watch, DBusWatchHandler handler, void *data, DBusFreeFunction free_data_function)
Sets the handler for the watch. 
void _dbus_transport_disconnect(DBusTransport *transport)
Closes our end of the connection to a remote application. 
dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket. 
void _dbus_transport_finalize_base(DBusTransport *transport)
Finalizes base class members of DBusTransport. 
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll(). 
DBUS_PRIVATE_EXPORT void _dbus_connection_unlock(DBusConnection *connection)
Releases the connection lock. 
short revents
Events that occurred. 
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. 
dbus_bool_t _dbus_get_is_errno_enomem(int e)
See if errno is ENOMEM. 
#define _DBUS_POLLERR
Error condition. 
DBusString encoded_outgoing
Encoded version of current outgoing message. 
long _dbus_counter_get_size_value(DBusCounter *counter)
Gets the current value of the size counter.