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));
480 case DBUS_AUTH_STATE_INVALID:
491 check_read_watch (transport);
492 check_write_watch (transport);
512 _dbus_verbose (
"Not authenticated, not writing anything\n");
518 _dbus_verbose (
"Not connected, not writing anything\n");
523 _dbus_verbose (
"do_writing(), have_messages = %d, fd = %" DBUS_SOCKET_FORMAT
"\n",
525 _dbus_socket_printable (socket_transport->
fd));
538 int header_len, body_len;
539 int total_bytes_to_write;
544 _dbus_verbose (
"%d bytes exceeds %d bytes written per iteration, returning\n",
554 _dbus_verbose (
"writing message %p\n", message);
560 header_len = _dbus_string_get_length (header);
561 body_len = _dbus_string_get_length (body);
566 _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
586 total_bytes_to_write = _dbus_string_get_length (&socket_transport->
encoded_outgoing);
589 _dbus_verbose (
"encoded message is %d bytes\n",
590 total_bytes_to_write);
598 saved_errno = _dbus_save_socket_errno ();
602 total_bytes_to_write = header_len + body_len;
605 _dbus_verbose (
"message is %d bytes\n",
606 total_bytes_to_write);
609 #ifdef HAVE_UNIX_FD_PASSING
619 _dbus_write_socket_with_unix_fds_two (socket_transport->
fd,
627 saved_errno = _dbus_save_socket_errno ();
629 if (bytes_written > 0 && n > 0)
630 _dbus_verbose(
"Wrote %i unix fds\n", n);
655 saved_errno = _dbus_save_socket_errno ();
659 if (bytes_written < 0)
688 _dbus_verbose (
" discard message of %d bytes due to ETOOMANYREFS\n",
689 total_bytes_to_write);
703 _dbus_verbose (
"Error writing to remote app: %s\n",
704 _dbus_strerror (saved_errno));
705 do_io_error (transport);
711 _dbus_verbose (
" wrote %d bytes of %d\n", bytes_written,
712 total_bytes_to_write);
714 total += bytes_written;
718 total_bytes_to_write);
750 _dbus_verbose (
"fd = %" DBUS_SOCKET_FORMAT
"\n",
751 _dbus_socket_printable (socket_transport->
fd));
764 check_read_watch (transport);
768 _dbus_verbose (
"%d bytes exceeds %d bytes read per iteration, returning\n",
785 _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
794 saved_errno = _dbus_save_socket_errno ();
810 _dbus_verbose (
"Out of memory decoding incoming data\n");
838 #ifdef HAVE_UNIX_FD_PASSING
839 if (DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport) && may_read_unix_fds)
844 if (!_dbus_message_loader_get_unix_fds(transport->
loader, &fds, &n_fds))
846 _dbus_verbose (
"Out of memory reading file descriptors\n");
856 saved_errno = _dbus_save_socket_errno ();
858 if (bytes_read >= 0 && n_fds > 0)
859 _dbus_verbose(
"Read %i unix fds\n", n_fds);
861 _dbus_message_loader_return_unix_fds(transport->
loader, fds, bytes_read < 0 ? 0 : n_fds);
867 buffer, max_to_read);
868 saved_errno = _dbus_save_socket_errno ();
881 _dbus_verbose (
"Out of memory in read()/do_reading()\n");
889 _dbus_verbose (
"Error reading from remote app: %s\n",
890 _dbus_strerror (saved_errno));
891 do_io_error (transport);
895 else if (bytes_read == 0)
897 _dbus_verbose (
"Disconnected from remote app\n");
898 do_io_error (transport);
903 _dbus_verbose (
" read %d bytes\n", bytes_read);
910 _dbus_verbose (
" out of memory when queueing messages we just read in the transport\n");
941 _dbus_watch_get_enabled (transport->
read_watch))
962 if (!(flags &
DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
964 _dbus_verbose (
"Hang up or error on watch\n");
974 _dbus_verbose (
"handling read watch %p flags = %x\n",
977 if (!do_authentication (transport,
TRUE,
FALSE, &auth_finished))
988 if (!do_reading (transport))
990 _dbus_verbose (
"no memory to read\n");
996 _dbus_verbose (
"Not reading anything since we just completed the authentication\n");
1003 _dbus_verbose (
"handling write watch, have_outgoing_messages = %d\n",
1009 if (!do_writing (transport))
1011 _dbus_verbose (
"no memory to write\n");
1016 check_write_watch (transport);
1018 #ifdef DBUS_ENABLE_VERBOSE_MODE
1022 _dbus_verbose (
"asked to handle read watch with non-read condition 0x%x\n",
1025 _dbus_verbose (
"asked to handle write watch with non-write condition 0x%x\n",
1028 _dbus_verbose (
"asked to handle watch %p on fd %" DBUS_SOCKET_FORMAT
" that we don't recognize\n",
1029 watch, _dbus_socket_printable (_dbus_watch_get_socket (watch)));
1041 _dbus_verbose (
"\n");
1043 free_watches (transport);
1046 _dbus_socket_invalidate (&socket_transport->
fd);
1074 check_read_watch (transport);
1075 check_write_watch (transport);
1090 int timeout_milliseconds)
1097 _dbus_verbose (
" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %" DBUS_SOCKET_FORMAT
"\n",
1098 flags & DBUS_ITERATION_DO_READING ?
"read" :
"",
1099 flags & DBUS_ITERATION_DO_WRITING ?
"write" :
"",
1100 timeout_milliseconds,
1103 _dbus_socket_printable (socket_transport->
fd));
1111 poll_fd.
fd = _dbus_socket_get_pollable (socket_transport->
fd);
1126 if ((flags & DBUS_ITERATION_DO_WRITING) &&
1127 !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
1131 do_writing (transport);
1140 if (flags & DBUS_ITERATION_DO_READING)
1144 if (flags & DBUS_ITERATION_DO_WRITING)
1149 DBusAuthState auth_state;
1154 auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1158 auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1166 if (flags & DBUS_ITERATION_BLOCK)
1167 poll_timeout = timeout_milliseconds;
1176 if (flags & DBUS_ITERATION_BLOCK)
1178 _dbus_verbose (
"unlock pre poll\n");
1183 poll_res =
_dbus_poll (&poll_fd, 1, poll_timeout);
1184 saved_errno = _dbus_save_socket_errno ();
1189 if (flags & DBUS_ITERATION_BLOCK)
1191 _dbus_verbose (
"lock post poll\n");
1204 do_io_error (transport);
1211 _dbus_verbose (
"in iteration, need_read=%d need_write=%d\n",
1212 need_read, need_write);
1213 do_authentication (transport, need_read, need_write,
1214 &authentication_completed);
1217 if (authentication_completed)
1220 if (need_read && (flags & DBUS_ITERATION_DO_READING))
1221 do_reading (transport);
1222 if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1223 do_writing (transport);
1228 _dbus_verbose (
"Error from _dbus_poll(): %s\n",
1229 _dbus_strerror (saved_errno));
1245 check_write_watch (transport);
1247 _dbus_verbose (
" ... leaving do_iteration()\n");
1254 check_read_watch (transport);
1264 *fd_p = socket_transport->
fd;
1271 socket_handle_watch,
1273 socket_connection_set,
1274 socket_do_iteration,
1275 socket_live_messages_changed,
1276 socket_get_socket_fd
1298 if (socket_transport ==
NULL)
1323 server_guid, address))
1326 #ifdef HAVE_UNIX_FD_PASSING
1330 socket_transport->
fd = fd;
1369 const char *noncefile,
1376 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1398 if (family !=
NULL &&
1403 if (noncefile !=
NULL &&
1408 fd = _dbus_connect_tcp_socket_with_nonce (host, port, family, noncefile, error);
1409 if (!_dbus_socket_is_valid (fd))
1411 _DBUS_ASSERT_ERROR_IS_SET (error);
1416 _dbus_verbose (
"Successfully connected to tcp socket %s:%s\n",
1421 if (transport ==
NULL)
1425 _dbus_socket_invalidate (&fd);
1444 DBusTransportOpenResult
1456 isTcp = strcmp (method,
"tcp") == 0;
1457 isNonceTcp = strcmp (method,
"nonce-tcp") == 0;
1459 if (isTcp || isNonceTcp)
1466 if ((isNonceTcp ==
TRUE) != (noncefile !=
NULL)) {
1468 return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1474 return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1478 if (*transport_p ==
NULL)
1480 _DBUS_ASSERT_ERROR_IS_SET (error);
1481 return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1485 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1486 return DBUS_TRANSPORT_OPEN_OK;
1491 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1492 return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
Implementation details of DBusTransportSocket.
dbus_bool_t _dbus_get_is_errno_etoomanyrefs(int e)
See if errno is ETOOMANYREFS.
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_bool_t _dbus_transport_get_is_connected(DBusTransport *transport)
Returns TRUE if the transport has not been disconnected.
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, unsigned int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
short revents
Events that occurred.
DBusMessageLoader * loader
Message-loading buffer.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
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.
void _dbus_auth_return_buffer(DBusAuth *auth, DBusString *buffer)
Returns a buffer with new data read into it.
DBusWatch * write_watch
Watch for writability.
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.
DBusAuthState _dbus_auth_do_work(DBusAuth *auth)
Analyzes buffered input and moves the auth conversation forward, returning the new state of the auth ...
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...
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
int message_bytes_written
Number of bytes of current outgoing message that have been written.
void _dbus_transport_disconnect(DBusTransport *transport)
Closes our end of the connection to a remote application.
DBUS_EXPORT dbus_bool_t dbus_watch_get_enabled(DBusWatch *watch)
Returns whether a watch is enabled or not.
short events
Events to poll for.
Implementation of DBusWatch.
DBUS_PRIVATE_EXPORT void _dbus_connection_lock(DBusConnection *connection)
Acquires the connection lock.
const char * dbus_address_entry_get_method(DBusAddressEntry *entry)
Returns the method string of an address entry.
int max_bytes_read_per_iteration
To avoid blocking too long.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
#define DBUS_MAXIMUM_MESSAGE_LENGTH
The maximum total message size including header and body; similar rationale to max array size.
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.
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.
void _dbus_connection_remove_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Removes a watch using the connection's DBusRemoveWatchFunction if available.
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...
As in POLLERR (can't watch for this, but can be present in current state passed to dbus_watch_handle(...
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.
DBusString encoded_outgoing
Encoded version of current outgoing message.
void _dbus_watch_unref(DBusWatch *watch)
Decrements the reference count of a DBusWatch object and finalizes the object if the count reaches ze...
DBusMessage * _dbus_connection_get_message_to_send(DBusConnection *connection)
Gets the next outgoing message.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket.
#define _DBUS_POLLERR
Error condition.
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_connection_has_messages_to_send_unlocked(DBusConnection *connection)
Checks whether there are messages in the outgoing message queue.
dbus_bool_t _dbus_connection_add_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Adds a watch using the connection's DBusAddWatchFunction if available.
DBusPollable fd
File descriptor.
unsigned int disconnected
TRUE if we are disconnected.
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.
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...
Internals of DBusAddressEntry.
DBusTransport base
Parent instance.
DBusWatch * read_watch
Watch for readability.
Object representing a transport such as a socket.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
dbus_bool_t _dbus_get_is_errno_epipe(int e)
See if errno is EPIPE.
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.
const char * dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
Returns a value from a key of an entry.
Internals of DBusMessage.
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_transport_init_base(DBusTransport *transport, const DBusTransportVTable *vtable, const DBusString *server_guid, const DBusString *address)
Initializes the base class members of DBusTransport.
DBUS_PRIVATE_EXPORT void _dbus_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer, int *max_to_read, dbus_bool_t *may_read_unix_fds)
Gets the buffer to use for reading data from the network.
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
#define _dbus_assert_not_reached(explanation)
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
long max_live_messages_unix_fds
Max total unix fds of received messages.
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.
int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
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.
void _dbus_transport_finalize_base(DBusTransport *transport)
Finalizes base class members of DBusTransport.
unsigned int receive_credentials_pending
TRUE if we need to receive credentials
DBusConnection * connection
Connection owning this transport.
dbus_bool_t _dbus_close_socket(DBusSocket fd, DBusError *error)
Closes a socket.
void _dbus_watch_set_handler(DBusWatch *watch, DBusWatchHandler handler, void *data, DBusFreeFunction free_data_function)
Sets the handler for the watch.
#define _dbus_assert(condition)
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...
DBusCounter * live_messages
Counter for size/unix fds of all live messages.
The virtual table that must be implemented to create a new kind of transport.
DBusTransportOpenResult _dbus_transport_open_socket(DBusAddressEntry *entry, DBusTransport **transport_p, DBusError *error)
Opens a TCP socket transport.
dbus_bool_t _dbus_auth_set_credentials(DBusAuth *auth, DBusCredentials *credentials)
Sets credentials received via reliable means from the operating system.
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.
DBusAuth * auth
Authentication conversation.
long max_live_messages_size
Max total size of received messages.
long _dbus_counter_get_size_value(DBusCounter *counter)
Gets the current value of the size counter.
Object representing an exception.
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_message_get_network_data(DBusMessage *message, const DBusString **header, const DBusString **body)
Gets the data to be sent over the network for this message.
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...
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
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.
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...
#define _DBUS_POLLIN
There is data to read.
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...
unsigned int send_credentials_pending
TRUE if we need to send credentials
void dbus_message_lock(DBusMessage *message)
Locks a message.
DBusString encoded_incoming
Encoded version of current incoming data.
const char * message
public error message field
DBusSocket fd
File descriptor.
DBUS_PRIVATE_EXPORT void _dbus_connection_unlock(DBusConnection *connection)
Releases the connection lock.
#define dbus_new0(type, count)
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.
int max_bytes_written_per_iteration
To avoid blocking too long.
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)
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.
As in POLLHUP (can't watch for it, but can be present in current state passed to dbus_watch_handle())...
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
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.
dbus_bool_t _dbus_get_is_errno_eintr(int e)
See if errno is EINTR.
DBusCredentials * credentials
Credentials of other end read from the socket.
#define _DBUS_POLLOUT
Writing now will not block.
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...
dbus_uint32_t dbus_bool_t
dbus_bool_t _dbus_get_is_errno_enomem(int e)
See if errno is ENOMEM.