1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-transport-socket.c Socket subclasses of DBusTransport
4 * Copyright (C) 2002, 2003, 2004, 2006 Red Hat Inc.
6 * Licensed under the Academic Free License version 2.1
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "dbus-internals.h"
25 #include "dbus-connection-internal.h"
26 #include "dbus-nonce.h"
27 #include "dbus-transport-socket.h"
28 #include "dbus-transport-protected.h"
29 #include "dbus-watch.h"
30 #include "dbus-credentials.h"
33 * @defgroup DBusTransportSocket DBusTransport implementations for sockets
34 * @ingroup DBusInternals
35 * @brief Implementation details of DBusTransport on sockets
41 * Opaque object representing a socket file descriptor transport.
43 typedef struct DBusTransportSocket DBusTransportSocket;
46 * Implementation details of DBusTransportSocket. All members are private.
48 struct DBusTransportSocket
50 DBusTransport base; /**< Parent instance */
51 int fd; /**< File descriptor. */
52 DBusWatch *read_watch; /**< Watch for readability. */
53 DBusWatch *write_watch; /**< Watch for writability. */
55 int max_bytes_read_per_iteration; /**< To avoid blocking too long. */
56 int max_bytes_written_per_iteration; /**< To avoid blocking too long. */
58 int message_bytes_written; /**< Number of bytes of current
59 * outgoing message that have
62 DBusString encoded_outgoing; /**< Encoded version of current
65 DBusString encoded_incoming; /**< Encoded version of current
71 free_watches (DBusTransport *transport)
73 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
75 _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME);
77 if (socket_transport->read_watch)
79 if (transport->connection)
80 _dbus_connection_remove_watch_unlocked (transport->connection,
81 socket_transport->read_watch);
82 _dbus_watch_invalidate (socket_transport->read_watch);
83 _dbus_watch_unref (socket_transport->read_watch);
84 socket_transport->read_watch = NULL;
87 if (socket_transport->write_watch)
89 if (transport->connection)
90 _dbus_connection_remove_watch_unlocked (transport->connection,
91 socket_transport->write_watch);
92 _dbus_watch_invalidate (socket_transport->write_watch);
93 _dbus_watch_unref (socket_transport->write_watch);
94 socket_transport->write_watch = NULL;
97 _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);
101 socket_finalize (DBusTransport *transport)
103 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
105 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
107 free_watches (transport);
109 _dbus_string_free (&socket_transport->encoded_outgoing);
110 _dbus_string_free (&socket_transport->encoded_incoming);
112 _dbus_transport_finalize_base (transport);
114 _dbus_assert (socket_transport->read_watch == NULL);
115 _dbus_assert (socket_transport->write_watch == NULL);
117 dbus_free (transport);
121 check_write_watch (DBusTransport *transport)
123 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
126 if (transport->connection == NULL)
129 if (transport->disconnected)
131 _dbus_assert (socket_transport->write_watch == NULL);
135 _dbus_transport_ref (transport);
137 if (_dbus_transport_get_is_authenticated (transport))
138 needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);
141 if (transport->send_credentials_pending)
145 DBusAuthState auth_state;
147 auth_state = _dbus_auth_do_work (transport->auth);
149 /* If we need memory we install the write watch just in case,
150 * if there's no need for it, it will get de-installed
151 * next time we try reading.
153 if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||
154 auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
161 _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",
162 needed, transport->connection, socket_transport->write_watch,
163 socket_transport->fd,
164 _dbus_connection_has_messages_to_send_unlocked (transport->connection));
166 _dbus_connection_toggle_watch_unlocked (transport->connection,
167 socket_transport->write_watch,
170 _dbus_transport_unref (transport);
174 check_read_watch (DBusTransport *transport)
176 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
177 dbus_bool_t need_read_watch;
179 _dbus_verbose ("%s: fd = %d\n",
180 _DBUS_FUNCTION_NAME, socket_transport->fd);
182 if (transport->connection == NULL)
185 if (transport->disconnected)
187 _dbus_assert (socket_transport->read_watch == NULL);
191 _dbus_transport_ref (transport);
193 if (_dbus_transport_get_is_authenticated (transport))
195 (_dbus_counter_get_size_value (transport->live_messages) < transport->max_live_messages_size) &&
196 (_dbus_counter_get_unix_fd_value (transport->live_messages) < transport->max_live_messages_unix_fds);
199 if (transport->receive_credentials_pending)
200 need_read_watch = TRUE;
203 /* The reason to disable need_read_watch when not WAITING_FOR_INPUT
204 * is to avoid spinning on the file descriptor when we're waiting
205 * to write or for some other part of the auth process
207 DBusAuthState auth_state;
209 auth_state = _dbus_auth_do_work (transport->auth);
211 /* If we need memory we install the read watch just in case,
212 * if there's no need for it, it will get de-installed
213 * next time we try reading. If we're authenticated we
214 * install it since we normally have it installed while
217 if (auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT ||
218 auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY ||
219 auth_state == DBUS_AUTH_STATE_AUTHENTICATED)
220 need_read_watch = TRUE;
222 need_read_watch = FALSE;
226 _dbus_verbose (" setting read watch enabled = %d\n", need_read_watch);
227 _dbus_connection_toggle_watch_unlocked (transport->connection,
228 socket_transport->read_watch,
231 _dbus_transport_unref (transport);
235 do_io_error (DBusTransport *transport)
237 _dbus_transport_ref (transport);
238 _dbus_transport_disconnect (transport);
239 _dbus_transport_unref (transport);
242 /* return value is whether we successfully read any new data. */
244 read_data_into_auth (DBusTransport *transport,
247 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
253 _dbus_auth_get_buffer (transport->auth, &buffer);
255 bytes_read = _dbus_read_socket (socket_transport->fd,
256 buffer, socket_transport->max_bytes_read_per_iteration);
258 _dbus_auth_return_buffer (transport->auth, buffer,
259 bytes_read > 0 ? bytes_read : 0);
263 _dbus_verbose (" read %d bytes in auth phase\n", bytes_read);
267 else if (bytes_read < 0)
269 /* EINTR already handled for us */
271 if (_dbus_get_is_errno_enomem ())
275 else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
276 ; /* do nothing, just return FALSE below */
279 _dbus_verbose ("Error reading from remote app: %s\n",
280 _dbus_strerror_from_errno ());
281 do_io_error (transport);
288 _dbus_assert (bytes_read == 0);
290 _dbus_verbose ("Disconnected from remote app\n");
291 do_io_error (transport);
297 /* Return value is whether we successfully wrote any bytes */
299 write_data_from_auth (DBusTransport *transport)
301 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
303 const DBusString *buffer;
305 if (!_dbus_auth_get_bytes_to_send (transport->auth,
309 bytes_written = _dbus_write_socket (socket_transport->fd,
311 0, _dbus_string_get_length (buffer));
313 if (bytes_written > 0)
315 _dbus_auth_bytes_sent (transport->auth, bytes_written);
318 else if (bytes_written < 0)
320 /* EINTR already handled for us */
322 if (_dbus_get_is_errno_eagain_or_ewouldblock ())
326 _dbus_verbose ("Error writing to remote app: %s\n",
327 _dbus_strerror_from_errno ());
328 do_io_error (transport);
337 exchange_credentials (DBusTransport *transport,
338 dbus_bool_t do_reading,
339 dbus_bool_t do_writing)
341 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
342 DBusError error = DBUS_ERROR_INIT;
344 _dbus_verbose ("exchange_credentials: do_reading = %d, do_writing = %d\n",
345 do_reading, do_writing);
347 if (do_writing && transport->send_credentials_pending)
349 if (_dbus_send_credentials_socket (socket_transport->fd,
352 transport->send_credentials_pending = FALSE;
356 _dbus_verbose ("Failed to write credentials: %s\n", error.message);
357 dbus_error_free (&error);
358 do_io_error (transport);
362 if (do_reading && transport->receive_credentials_pending)
364 /* FIXME this can fail due to IO error _or_ OOM, broken
365 * (somewhat tricky to fix since the OOM error can be set after
366 * we already read the credentials byte, so basically we need to
367 * separate reading the byte and storing it in the
368 * transport->credentials). Does not really matter for now
369 * because storing in credentials never actually fails on unix.
371 if (_dbus_read_credentials_socket (socket_transport->fd,
372 transport->credentials,
375 transport->receive_credentials_pending = FALSE;
379 _dbus_verbose ("Failed to read credentials %s\n", error.message);
380 dbus_error_free (&error);
381 do_io_error (transport);
385 if (!(transport->send_credentials_pending ||
386 transport->receive_credentials_pending))
388 if (!_dbus_auth_set_credentials (transport->auth,
389 transport->credentials))
397 do_authentication (DBusTransport *transport,
398 dbus_bool_t do_reading,
399 dbus_bool_t do_writing,
400 dbus_bool_t *auth_completed)
403 dbus_bool_t orig_auth_state;
407 orig_auth_state = _dbus_transport_get_is_authenticated (transport);
409 /* This is essential to avoid the check_write_watch() at the end,
410 * we don't want to add a write watch in do_iteration before
411 * we try writing and get EAGAIN
416 *auth_completed = FALSE;
420 _dbus_transport_ref (transport);
422 while (!_dbus_transport_get_is_authenticated (transport) &&
423 _dbus_transport_get_is_connected (transport))
425 if (!exchange_credentials (transport, do_reading, do_writing))
432 if (transport->send_credentials_pending ||
433 transport->receive_credentials_pending)
435 _dbus_verbose ("send_credentials_pending = %d receive_credentials_pending = %d\n",
436 transport->send_credentials_pending,
437 transport->receive_credentials_pending);
441 #define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")
442 switch (_dbus_auth_do_work (transport->auth))
444 case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
445 _dbus_verbose (" %s auth state: waiting for input\n",
446 TRANSPORT_SIDE (transport));
447 if (!do_reading || !read_data_into_auth (transport, &oom))
451 case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
452 _dbus_verbose (" %s auth state: waiting for memory\n",
453 TRANSPORT_SIDE (transport));
458 case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
459 _dbus_verbose (" %s auth state: bytes to send\n",
460 TRANSPORT_SIDE (transport));
461 if (!do_writing || !write_data_from_auth (transport))
465 case DBUS_AUTH_STATE_NEED_DISCONNECT:
466 _dbus_verbose (" %s auth state: need to disconnect\n",
467 TRANSPORT_SIDE (transport));
468 do_io_error (transport);
471 case DBUS_AUTH_STATE_AUTHENTICATED:
472 _dbus_verbose (" %s auth state: authenticated\n",
473 TRANSPORT_SIDE (transport));
480 *auth_completed = (orig_auth_state != _dbus_transport_get_is_authenticated (transport));
482 check_read_watch (transport);
483 check_write_watch (transport);
484 _dbus_transport_unref (transport);
492 /* returns false on oom */
494 do_writing (DBusTransport *transport)
497 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
500 /* No messages without authentication! */
501 if (!_dbus_transport_get_is_authenticated (transport))
503 _dbus_verbose ("Not authenticated, not writing anything\n");
507 if (transport->disconnected)
509 _dbus_verbose ("Not connected, not writing anything\n");
514 _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",
515 _dbus_connection_has_messages_to_send_unlocked (transport->connection),
516 socket_transport->fd);
522 while (!transport->disconnected &&
523 _dbus_connection_has_messages_to_send_unlocked (transport->connection))
526 DBusMessage *message;
527 const DBusString *header;
528 const DBusString *body;
529 int header_len, body_len;
530 int total_bytes_to_write;
532 if (total > socket_transport->max_bytes_written_per_iteration)
534 _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",
535 total, socket_transport->max_bytes_written_per_iteration);
539 message = _dbus_connection_get_message_to_send (transport->connection);
540 _dbus_assert (message != NULL);
541 dbus_message_lock (message);
544 _dbus_verbose ("writing message %p\n", message);
547 _dbus_message_get_network_data (message,
550 header_len = _dbus_string_get_length (header);
551 body_len = _dbus_string_get_length (body);
553 if (_dbus_auth_needs_encoding (transport->auth))
555 /* Does fd passing even make sense with encoded data? */
556 _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
558 if (_dbus_string_get_length (&socket_transport->encoded_outgoing) == 0)
560 if (!_dbus_auth_encode_data (transport->auth,
561 header, &socket_transport->encoded_outgoing))
567 if (!_dbus_auth_encode_data (transport->auth,
568 body, &socket_transport->encoded_outgoing))
570 _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
576 total_bytes_to_write = _dbus_string_get_length (&socket_transport->encoded_outgoing);
579 _dbus_verbose ("encoded message is %d bytes\n",
580 total_bytes_to_write);
584 _dbus_write_socket (socket_transport->fd,
585 &socket_transport->encoded_outgoing,
586 socket_transport->message_bytes_written,
587 total_bytes_to_write - socket_transport->message_bytes_written);
591 total_bytes_to_write = header_len + body_len;
594 _dbus_verbose ("message is %d bytes\n",
595 total_bytes_to_write);
598 #ifdef HAVE_UNIX_FD_PASSING
599 if (socket_transport->message_bytes_written <= 0 && DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
601 /* Send the fds along with the first byte of the message */
605 _dbus_message_get_unix_fds(message, &unix_fds, &n);
608 _dbus_write_socket_with_unix_fds_two (socket_transport->fd,
610 socket_transport->message_bytes_written,
611 header_len - socket_transport->message_bytes_written,
617 if (bytes_written > 0 && n > 0)
618 _dbus_verbose("Wrote %i unix fds\n", n);
623 if (socket_transport->message_bytes_written < header_len)
626 _dbus_write_socket_two (socket_transport->fd,
628 socket_transport->message_bytes_written,
629 header_len - socket_transport->message_bytes_written,
636 _dbus_write_socket (socket_transport->fd,
638 (socket_transport->message_bytes_written - header_len),
640 (socket_transport->message_bytes_written - header_len));
645 if (bytes_written < 0)
647 /* EINTR already handled for us */
649 /* For some discussion of why we also ignore EPIPE here, see
650 * http://lists.freedesktop.org/archives/dbus/2008-March/009526.html
653 if (_dbus_get_is_errno_eagain_or_ewouldblock () || _dbus_get_is_errno_epipe ())
657 _dbus_verbose ("Error writing to remote app: %s\n",
658 _dbus_strerror_from_errno ());
659 do_io_error (transport);
665 _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
666 total_bytes_to_write);
668 total += bytes_written;
669 socket_transport->message_bytes_written += bytes_written;
671 _dbus_assert (socket_transport->message_bytes_written <=
672 total_bytes_to_write);
674 if (socket_transport->message_bytes_written == total_bytes_to_write)
676 socket_transport->message_bytes_written = 0;
677 _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
678 _dbus_string_compact (&socket_transport->encoded_outgoing, 2048);
680 _dbus_connection_message_sent (transport->connection,
693 /* returns false on out-of-memory */
695 do_reading (DBusTransport *transport)
697 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
703 _dbus_verbose ("%s: fd = %d\n", _DBUS_FUNCTION_NAME,
704 socket_transport->fd);
706 /* No messages without authentication! */
707 if (!_dbus_transport_get_is_authenticated (transport))
716 /* See if we've exceeded max messages and need to disable reading */
717 check_read_watch (transport);
719 if (total > socket_transport->max_bytes_read_per_iteration)
721 _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
722 total, socket_transport->max_bytes_read_per_iteration);
726 _dbus_assert (socket_transport->read_watch != NULL ||
727 transport->disconnected);
729 if (transport->disconnected)
732 if (!dbus_watch_get_enabled (socket_transport->read_watch))
735 if (_dbus_auth_needs_decoding (transport->auth))
737 /* Does fd passing even make sense with encoded data? */
738 _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
740 if (_dbus_string_get_length (&socket_transport->encoded_incoming) > 0)
741 bytes_read = _dbus_string_get_length (&socket_transport->encoded_incoming);
743 bytes_read = _dbus_read_socket (socket_transport->fd,
744 &socket_transport->encoded_incoming,
745 socket_transport->max_bytes_read_per_iteration);
747 _dbus_assert (_dbus_string_get_length (&socket_transport->encoded_incoming) ==
754 _dbus_message_loader_get_buffer (transport->loader,
757 orig_len = _dbus_string_get_length (buffer);
759 if (!_dbus_auth_decode_data (transport->auth,
760 &socket_transport->encoded_incoming,
763 _dbus_verbose ("Out of memory decoding incoming data\n");
764 _dbus_message_loader_return_buffer (transport->loader,
766 _dbus_string_get_length (buffer) - orig_len);
772 _dbus_message_loader_return_buffer (transport->loader,
774 _dbus_string_get_length (buffer) - orig_len);
776 _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
777 _dbus_string_compact (&socket_transport->encoded_incoming, 2048);
782 _dbus_message_loader_get_buffer (transport->loader,
785 #ifdef HAVE_UNIX_FD_PASSING
786 if (DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
790 if (!_dbus_message_loader_get_unix_fds(transport->loader, &fds, &n_fds))
792 _dbus_verbose ("Out of memory reading file descriptors\n");
793 _dbus_message_loader_return_buffer (transport->loader, buffer, 0);
798 bytes_read = _dbus_read_socket_with_unix_fds(socket_transport->fd,
800 socket_transport->max_bytes_read_per_iteration,
803 if (bytes_read >= 0 && n_fds > 0)
804 _dbus_verbose("Read %i unix fds\n", n_fds);
806 _dbus_message_loader_return_unix_fds(transport->loader, fds, bytes_read < 0 ? 0 : n_fds);
811 bytes_read = _dbus_read_socket (socket_transport->fd,
812 buffer, socket_transport->max_bytes_read_per_iteration);
815 _dbus_message_loader_return_buffer (transport->loader,
817 bytes_read < 0 ? 0 : bytes_read);
822 /* EINTR already handled for us */
824 if (_dbus_get_is_errno_enomem ())
826 _dbus_verbose ("Out of memory in read()/do_reading()\n");
830 else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
834 _dbus_verbose ("Error reading from remote app: %s\n",
835 _dbus_strerror_from_errno ());
836 do_io_error (transport);
840 else if (bytes_read == 0)
842 _dbus_verbose ("Disconnected from remote app\n");
843 do_io_error (transport);
848 _dbus_verbose (" read %d bytes\n", bytes_read);
852 if (!_dbus_transport_queue_messages (transport))
855 _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
859 /* Try reading more data until we get EAGAIN and return, or
860 * exceed max bytes per iteration. If in blocking mode of
861 * course we'll block instead of returning.
874 unix_error_with_read_to_come (DBusTransport *itransport,
878 DBusTransportSocket *transport = (DBusTransportSocket *) itransport;
880 if (!(flags & DBUS_WATCH_HANGUP || flags & DBUS_WATCH_ERROR))
883 /* If we have a read watch enabled ...
884 we -might have data incoming ... => handle the HANGUP there */
885 if (watch != transport->read_watch &&
886 _dbus_watch_get_enabled (transport->read_watch))
893 socket_handle_watch (DBusTransport *transport,
897 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
899 _dbus_assert (watch == socket_transport->read_watch ||
900 watch == socket_transport->write_watch);
901 _dbus_assert (watch != NULL);
903 /* If we hit an error here on a write watch, don't disconnect the transport yet because data can
904 * still be in the buffer and do_reading may need several iteration to read
905 * it all (because of its max_bytes_read_per_iteration limit).
907 if (!(flags & DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
909 _dbus_verbose ("Hang up or error on watch\n");
910 _dbus_transport_disconnect (transport);
914 if (watch == socket_transport->read_watch &&
915 (flags & DBUS_WATCH_READABLE))
917 dbus_bool_t auth_finished;
919 _dbus_verbose ("handling read watch %p flags = %x\n",
922 if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
925 /* We don't want to do a read immediately following
926 * a successful authentication. This is so we
927 * have a chance to propagate the authentication
928 * state further up. Specifically, we need to
929 * process any pending data from the auth object.
933 if (!do_reading (transport))
935 _dbus_verbose ("no memory to read\n");
941 _dbus_verbose ("Not reading anything since we just completed the authentication\n");
944 else if (watch == socket_transport->write_watch &&
945 (flags & DBUS_WATCH_WRITABLE))
948 _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
949 _dbus_connection_has_messages_to_send_unlocked (transport->connection));
951 if (!do_authentication (transport, FALSE, TRUE, NULL))
954 if (!do_writing (transport))
956 _dbus_verbose ("no memory to write\n");
960 /* See if we still need the write watch */
961 check_write_watch (transport);
963 #ifdef DBUS_ENABLE_VERBOSE_MODE
966 if (watch == socket_transport->read_watch)
967 _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
969 else if (watch == socket_transport->write_watch)
970 _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
973 _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
974 watch, dbus_watch_get_socket (watch));
976 #endif /* DBUS_ENABLE_VERBOSE_MODE */
982 socket_disconnect (DBusTransport *transport)
984 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
986 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
988 free_watches (transport);
990 _dbus_close_socket (socket_transport->fd, NULL);
991 socket_transport->fd = -1;
995 socket_connection_set (DBusTransport *transport)
997 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
999 _dbus_watch_set_handler (socket_transport->write_watch,
1000 _dbus_connection_handle_watch,
1001 transport->connection, NULL);
1003 _dbus_watch_set_handler (socket_transport->read_watch,
1004 _dbus_connection_handle_watch,
1005 transport->connection, NULL);
1007 if (!_dbus_connection_add_watch_unlocked (transport->connection,
1008 socket_transport->write_watch))
1011 if (!_dbus_connection_add_watch_unlocked (transport->connection,
1012 socket_transport->read_watch))
1014 _dbus_connection_remove_watch_unlocked (transport->connection,
1015 socket_transport->write_watch);
1019 check_read_watch (transport);
1020 check_write_watch (transport);
1026 * @todo We need to have a way to wake up the select sleep if
1027 * a new iteration request comes in with a flag (read/write) that
1028 * we're not currently serving. Otherwise a call that just reads
1029 * could block a write call forever (if there are no incoming
1033 socket_do_iteration (DBusTransport *transport,
1035 int timeout_milliseconds)
1037 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1042 _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
1043 flags & DBUS_ITERATION_DO_READING ? "read" : "",
1044 flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
1045 timeout_milliseconds,
1046 socket_transport->read_watch,
1047 socket_transport->write_watch,
1048 socket_transport->fd);
1050 /* the passed in DO_READING/DO_WRITING flags indicate whether to
1051 * read/write messages, but regardless of those we may need to block
1052 * for reading/writing to do auth. But if we do reading for auth,
1053 * we don't want to read any messages yet if not given DO_READING.
1056 poll_fd.fd = socket_transport->fd;
1059 if (_dbus_transport_get_is_authenticated (transport))
1061 /* This is kind of a hack; if we have stuff to write, then try
1062 * to avoid the poll. This is probably about a 5% speedup on an
1063 * echo client/server.
1065 * If both reading and writing were requested, we want to avoid this
1066 * since it could have funky effects:
1067 * - both ends spinning waiting for the other one to read
1068 * data so they can finish writing
1069 * - prioritizing all writing ahead of reading
1071 if ((flags & DBUS_ITERATION_DO_WRITING) &&
1072 !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
1073 !transport->disconnected &&
1074 _dbus_connection_has_messages_to_send_unlocked (transport->connection))
1076 do_writing (transport);
1078 if (transport->disconnected ||
1079 !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
1083 /* If we get here, we decided to do the poll() after all */
1084 _dbus_assert (socket_transport->read_watch);
1085 if (flags & DBUS_ITERATION_DO_READING)
1086 poll_fd.events |= _DBUS_POLLIN;
1088 _dbus_assert (socket_transport->write_watch);
1089 if (flags & DBUS_ITERATION_DO_WRITING)
1090 poll_fd.events |= _DBUS_POLLOUT;
1094 DBusAuthState auth_state;
1096 auth_state = _dbus_auth_do_work (transport->auth);
1098 if (transport->receive_credentials_pending ||
1099 auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1100 poll_fd.events |= _DBUS_POLLIN;
1102 if (transport->send_credentials_pending ||
1103 auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1104 poll_fd.events |= _DBUS_POLLOUT;
1109 if (flags & DBUS_ITERATION_BLOCK)
1110 poll_timeout = timeout_milliseconds;
1114 /* For blocking selects we drop the connection lock here
1115 * to avoid blocking out connection access during a potentially
1116 * indefinite blocking call. The io path is still protected
1117 * by the io_path_cond condvar, so we won't reenter this.
1119 if (flags & DBUS_ITERATION_BLOCK)
1121 _dbus_verbose ("unlock %s pre poll\n", _DBUS_FUNCTION_NAME);
1122 _dbus_connection_unlock (transport->connection);
1126 poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1128 if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1131 if (flags & DBUS_ITERATION_BLOCK)
1133 _dbus_verbose ("lock %s post poll\n", _DBUS_FUNCTION_NAME);
1134 _dbus_connection_lock (transport->connection);
1140 poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1141 * valgrind flags it as an error. though it probably
1142 * is guaranteed on linux at least.
1145 if (poll_fd.revents & _DBUS_POLLERR)
1146 do_io_error (transport);
1149 dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1150 dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1151 dbus_bool_t authentication_completed;
1153 _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1154 need_read, need_write);
1155 do_authentication (transport, need_read, need_write,
1156 &authentication_completed);
1158 /* See comment in socket_handle_watch. */
1159 if (authentication_completed)
1162 if (need_read && (flags & DBUS_ITERATION_DO_READING))
1163 do_reading (transport);
1164 if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1165 do_writing (transport);
1170 _dbus_verbose ("Error from _dbus_poll(): %s\n",
1171 _dbus_strerror_from_errno ());
1177 /* We need to install the write watch only if we did not
1178 * successfully write everything. Note we need to be careful that we
1179 * don't call check_write_watch *before* do_writing, since it's
1180 * inefficient to add the write watch, and we can avoid it most of
1181 * the time since we can write immediately.
1183 * However, we MUST always call check_write_watch(); DBusConnection code
1184 * relies on the fact that running an iteration will notice that
1185 * messages are pending.
1187 check_write_watch (transport);
1189 _dbus_verbose (" ... leaving do_iteration()\n");
1193 socket_live_messages_changed (DBusTransport *transport)
1195 /* See if we should look for incoming messages again */
1196 check_read_watch (transport);
1201 socket_get_socket_fd (DBusTransport *transport,
1204 DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1206 *fd_p = socket_transport->fd;
1211 static const DBusTransportVTable socket_vtable = {
1213 socket_handle_watch,
1215 socket_connection_set,
1216 socket_do_iteration,
1217 socket_live_messages_changed,
1218 socket_get_socket_fd
1222 * Creates a new transport for the given socket file descriptor. The file
1223 * descriptor must be nonblocking (use _dbus_set_fd_nonblocking() to
1224 * make it so). This function is shared by various transports that
1225 * boil down to a full duplex file descriptor.
1227 * @param fd the file descriptor.
1228 * @param server_guid non-#NULL if this transport is on the server side of a connection
1229 * @param address the transport's address
1230 * @returns the new transport, or #NULL if no memory.
1233 _dbus_transport_new_for_socket (int fd,
1234 const DBusString *server_guid,
1235 const DBusString *address)
1237 DBusTransportSocket *socket_transport;
1239 socket_transport = dbus_new0 (DBusTransportSocket, 1);
1240 if (socket_transport == NULL)
1243 if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1246 if (!_dbus_string_init (&socket_transport->encoded_incoming))
1249 socket_transport->write_watch = _dbus_watch_new (fd,
1250 DBUS_WATCH_WRITABLE,
1253 if (socket_transport->write_watch == NULL)
1256 socket_transport->read_watch = _dbus_watch_new (fd,
1257 DBUS_WATCH_READABLE,
1260 if (socket_transport->read_watch == NULL)
1263 if (!_dbus_transport_init_base (&socket_transport->base,
1265 server_guid, address))
1268 #ifdef HAVE_UNIX_FD_PASSING
1269 _dbus_auth_set_unix_fd_possible(socket_transport->base.auth, _dbus_socket_can_pass_unix_fd(fd));
1272 socket_transport->fd = fd;
1273 socket_transport->message_bytes_written = 0;
1275 /* These values should probably be tunable or something. */
1276 socket_transport->max_bytes_read_per_iteration = 2048;
1277 socket_transport->max_bytes_written_per_iteration = 2048;
1279 return (DBusTransport*) socket_transport;
1282 _dbus_watch_unref (socket_transport->read_watch);
1284 _dbus_watch_unref (socket_transport->write_watch);
1286 _dbus_string_free (&socket_transport->encoded_incoming);
1288 _dbus_string_free (&socket_transport->encoded_outgoing);
1290 dbus_free (socket_transport);
1295 * Creates a new transport for the given hostname and port.
1296 * If host is NULL, it will default to localhost
1298 * @param host the host to connect to
1299 * @param port the port to connect to
1300 * @param family the address family to connect to
1301 * @param path to nonce file
1302 * @param error location to store reason for failure.
1303 * @returns a new transport, or #NULL on failure.
1306 _dbus_transport_new_for_tcp_socket (const char *host,
1309 const char *noncefile,
1313 DBusTransport *transport;
1316 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1318 if (!_dbus_string_init (&address))
1320 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1327 if (!_dbus_string_append (&address, noncefile ? "nonce-tcp:" : "tcp:"))
1330 if (!_dbus_string_append (&address, "host=") ||
1331 !_dbus_string_append (&address, host))
1334 if (!_dbus_string_append (&address, ",port=") ||
1335 !_dbus_string_append (&address, port))
1338 if (family != NULL &&
1339 (!_dbus_string_append (&address, "family=") ||
1340 !_dbus_string_append (&address, family)))
1343 if (noncefile != NULL &&
1344 (!_dbus_string_append (&address, "noncefile=") ||
1345 !_dbus_string_append (&address, noncefile)))
1348 fd = _dbus_connect_tcp_socket_with_nonce (host, port, family, noncefile, error);
1351 _DBUS_ASSERT_ERROR_IS_SET (error);
1352 _dbus_string_free (&address);
1356 _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1359 transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1360 if (transport == NULL)
1362 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1363 _dbus_close_socket (fd, NULL);
1364 _dbus_string_free (&address);
1368 _dbus_string_free (&address);
1373 _dbus_string_free (&address);
1374 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1379 * Opens a TCP socket transport.
1381 * @param entry the address entry to try opening as a tcp transport.
1382 * @param transport_p return location for the opened transport
1383 * @param error error to be set
1384 * @returns result of the attempt
1386 DBusTransportOpenResult
1387 _dbus_transport_open_socket(DBusAddressEntry *entry,
1388 DBusTransport **transport_p,
1393 dbus_bool_t isNonceTcp;
1395 method = dbus_address_entry_get_method (entry);
1396 _dbus_assert (method != NULL);
1398 isTcp = strcmp (method, "tcp") == 0;
1399 isNonceTcp = strcmp (method, "nonce-tcp") == 0;
1401 if (isTcp || isNonceTcp)
1403 const char *host = dbus_address_entry_get_value (entry, "host");
1404 const char *port = dbus_address_entry_get_value (entry, "port");
1405 const char *family = dbus_address_entry_get_value (entry, "family");
1406 const char *noncefile = dbus_address_entry_get_value (entry, "noncefile");
1408 if ((isNonceTcp == TRUE) != (noncefile != NULL)) {
1409 _dbus_set_bad_address (error, method, "noncefile", NULL);
1410 return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1415 _dbus_set_bad_address (error, method, "port", NULL);
1416 return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1419 *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, noncefile, error);
1420 if (*transport_p == NULL)
1422 _DBUS_ASSERT_ERROR_IS_SET (error);
1423 return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1427 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1428 return DBUS_TRANSPORT_OPEN_OK;
1433 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1434 return DBUS_TRANSPORT_OPEN_NOT_HANDLED;