D-Bus  1.8.16
dbus-transport-socket.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-transport-socket.c Socket subclasses of DBusTransport
3  *
4  * Copyright (C) 2002, 2003, 2004, 2006 Red Hat Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23 
24 #include <config.h>
25 #include "dbus-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"
32 
45 
50 {
52  int fd;
69 };
70 
71 static void
72 free_watches (DBusTransport *transport)
73 {
74  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
75 
76  _dbus_verbose ("start\n");
77 
78  if (socket_transport->read_watch)
79  {
80  if (transport->connection)
82  socket_transport->read_watch);
83  _dbus_watch_invalidate (socket_transport->read_watch);
84  _dbus_watch_unref (socket_transport->read_watch);
85  socket_transport->read_watch = NULL;
86  }
87 
88  if (socket_transport->write_watch)
89  {
90  if (transport->connection)
92  socket_transport->write_watch);
93  _dbus_watch_invalidate (socket_transport->write_watch);
94  _dbus_watch_unref (socket_transport->write_watch);
95  socket_transport->write_watch = NULL;
96  }
97 
98  _dbus_verbose ("end\n");
99 }
100 
101 static void
102 socket_finalize (DBusTransport *transport)
103 {
104  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
105 
106  _dbus_verbose ("\n");
107 
108  free_watches (transport);
109 
110  _dbus_string_free (&socket_transport->encoded_outgoing);
111  _dbus_string_free (&socket_transport->encoded_incoming);
112 
113  _dbus_transport_finalize_base (transport);
114 
115  _dbus_assert (socket_transport->read_watch == NULL);
116  _dbus_assert (socket_transport->write_watch == NULL);
117 
118  dbus_free (transport);
119 }
120 
121 static void
122 check_write_watch (DBusTransport *transport)
123 {
124  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
125  dbus_bool_t needed;
126 
127  if (transport->connection == NULL)
128  return;
129 
130  if (transport->disconnected)
131  {
132  _dbus_assert (socket_transport->write_watch == NULL);
133  return;
134  }
135 
136  _dbus_transport_ref (transport);
137 
138  if (_dbus_transport_try_to_authenticate (transport))
140  else
141  {
142  if (transport->send_credentials_pending)
143  needed = TRUE;
144  else
145  {
146  DBusAuthState auth_state;
147 
148  auth_state = _dbus_auth_do_work (transport->auth);
149 
150  /* If we need memory we install the write watch just in case,
151  * if there's no need for it, it will get de-installed
152  * next time we try reading.
153  */
154  if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||
155  auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
156  needed = TRUE;
157  else
158  needed = FALSE;
159  }
160  }
161 
162  _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",
163  needed, transport->connection, socket_transport->write_watch,
164  socket_transport->fd,
166 
168  socket_transport->write_watch,
169  needed);
170 
171  _dbus_transport_unref (transport);
172 }
173 
174 static void
175 check_read_watch (DBusTransport *transport)
176 {
177  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
178  dbus_bool_t need_read_watch;
179 
180  _dbus_verbose ("fd = %d\n",socket_transport->fd);
181 
182  if (transport->connection == NULL)
183  return;
184 
185  if (transport->disconnected)
186  {
187  _dbus_assert (socket_transport->read_watch == NULL);
188  return;
189  }
190 
191  _dbus_transport_ref (transport);
192 
193  if (_dbus_transport_try_to_authenticate (transport))
194  need_read_watch =
197  else
198  {
199  if (transport->receive_credentials_pending)
200  need_read_watch = TRUE;
201  else
202  {
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
206  */
207  DBusAuthState auth_state;
208 
209  auth_state = _dbus_auth_do_work (transport->auth);
210 
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
215  * authenticated.
216  */
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;
221  else
222  need_read_watch = FALSE;
223  }
224  }
225 
226  _dbus_verbose (" setting read watch enabled = %d\n", need_read_watch);
228  socket_transport->read_watch,
229  need_read_watch);
230 
231  _dbus_transport_unref (transport);
232 }
233 
234 static void
235 do_io_error (DBusTransport *transport)
236 {
237  _dbus_transport_ref (transport);
238  _dbus_transport_disconnect (transport);
239  _dbus_transport_unref (transport);
240 }
241 
242 /* return value is whether we successfully read any new data. */
243 static dbus_bool_t
244 read_data_into_auth (DBusTransport *transport,
245  dbus_bool_t *oom)
246 {
247  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
248  DBusString *buffer;
249  int bytes_read;
250 
251  *oom = FALSE;
252 
253  _dbus_auth_get_buffer (transport->auth, &buffer);
254 
255  bytes_read = _dbus_read_socket (socket_transport->fd,
256  buffer, socket_transport->max_bytes_read_per_iteration);
257 
258  _dbus_auth_return_buffer (transport->auth, buffer);
259 
260  if (bytes_read > 0)
261  {
262  _dbus_verbose (" read %d bytes in auth phase\n", bytes_read);
263 
264  return TRUE;
265  }
266  else if (bytes_read < 0)
267  {
268  /* EINTR already handled for us */
269 
271  {
272  *oom = TRUE;
273  }
275  ; /* do nothing, just return FALSE below */
276  else
277  {
278  _dbus_verbose ("Error reading from remote app: %s\n",
280  do_io_error (transport);
281  }
282 
283  return FALSE;
284  }
285  else
286  {
287  _dbus_assert (bytes_read == 0);
288 
289  _dbus_verbose ("Disconnected from remote app\n");
290  do_io_error (transport);
291 
292  return FALSE;
293  }
294 }
295 
296 /* Return value is whether we successfully wrote any bytes */
297 static dbus_bool_t
298 write_data_from_auth (DBusTransport *transport)
299 {
300  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
301  int bytes_written;
302  const DBusString *buffer;
303 
304  if (!_dbus_auth_get_bytes_to_send (transport->auth,
305  &buffer))
306  return FALSE;
307 
308  bytes_written = _dbus_write_socket (socket_transport->fd,
309  buffer,
310  0, _dbus_string_get_length (buffer));
311 
312  if (bytes_written > 0)
313  {
314  _dbus_auth_bytes_sent (transport->auth, bytes_written);
315  return TRUE;
316  }
317  else if (bytes_written < 0)
318  {
319  /* EINTR already handled for us */
320 
322  ;
323  else
324  {
325  _dbus_verbose ("Error writing to remote app: %s\n",
327  do_io_error (transport);
328  }
329  }
330 
331  return FALSE;
332 }
333 
334 /* FALSE on OOM */
335 static dbus_bool_t
336 exchange_credentials (DBusTransport *transport,
337  dbus_bool_t do_reading,
338  dbus_bool_t do_writing)
339 {
340  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
341  DBusError error = DBUS_ERROR_INIT;
342 
343  _dbus_verbose ("exchange_credentials: do_reading = %d, do_writing = %d\n",
344  do_reading, do_writing);
345 
346  if (do_writing && transport->send_credentials_pending)
347  {
348  if (_dbus_send_credentials_socket (socket_transport->fd,
349  &error))
350  {
351  transport->send_credentials_pending = FALSE;
352  }
353  else
354  {
355  _dbus_verbose ("Failed to write credentials: %s\n", error.message);
356  dbus_error_free (&error);
357  do_io_error (transport);
358  }
359  }
360 
361  if (do_reading && transport->receive_credentials_pending)
362  {
363  /* FIXME this can fail due to IO error _or_ OOM, broken
364  * (somewhat tricky to fix since the OOM error can be set after
365  * we already read the credentials byte, so basically we need to
366  * separate reading the byte and storing it in the
367  * transport->credentials). Does not really matter for now
368  * because storing in credentials never actually fails on unix.
369  */
370  if (_dbus_read_credentials_socket (socket_transport->fd,
371  transport->credentials,
372  &error))
373  {
374  transport->receive_credentials_pending = FALSE;
375  }
376  else
377  {
378  _dbus_verbose ("Failed to read credentials %s\n", error.message);
379  dbus_error_free (&error);
380  do_io_error (transport);
381  }
382  }
383 
384  if (!(transport->send_credentials_pending ||
385  transport->receive_credentials_pending))
386  {
387  if (!_dbus_auth_set_credentials (transport->auth,
388  transport->credentials))
389  return FALSE;
390  }
391 
392  return TRUE;
393 }
394 
395 static dbus_bool_t
396 do_authentication (DBusTransport *transport,
397  dbus_bool_t do_reading,
398  dbus_bool_t do_writing,
399  dbus_bool_t *auth_completed)
400 {
401  dbus_bool_t oom;
402  dbus_bool_t orig_auth_state;
403 
404  oom = FALSE;
405 
406  orig_auth_state = _dbus_transport_try_to_authenticate (transport);
407 
408  /* This is essential to avoid the check_write_watch() at the end,
409  * we don't want to add a write watch in do_iteration before
410  * we try writing and get EAGAIN
411  */
412  if (orig_auth_state)
413  {
414  if (auth_completed)
415  *auth_completed = FALSE;
416  return TRUE;
417  }
418 
419  _dbus_transport_ref (transport);
420 
421  while (!_dbus_transport_try_to_authenticate (transport) &&
423  {
424  if (!exchange_credentials (transport, do_reading, do_writing))
425  {
426  /* OOM */
427  oom = TRUE;
428  goto out;
429  }
430 
431  if (transport->send_credentials_pending ||
432  transport->receive_credentials_pending)
433  {
434  _dbus_verbose ("send_credentials_pending = %d receive_credentials_pending = %d\n",
435  transport->send_credentials_pending,
436  transport->receive_credentials_pending);
437  goto out;
438  }
439 
440 #define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")
441  switch (_dbus_auth_do_work (transport->auth))
442  {
443  case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
444  _dbus_verbose (" %s auth state: waiting for input\n",
445  TRANSPORT_SIDE (transport));
446  if (!do_reading || !read_data_into_auth (transport, &oom))
447  goto out;
448  break;
449 
450  case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
451  _dbus_verbose (" %s auth state: waiting for memory\n",
452  TRANSPORT_SIDE (transport));
453  oom = TRUE;
454  goto out;
455  break;
456 
457  case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
458  _dbus_verbose (" %s auth state: bytes to send\n",
459  TRANSPORT_SIDE (transport));
460  if (!do_writing || !write_data_from_auth (transport))
461  goto out;
462  break;
463 
464  case DBUS_AUTH_STATE_NEED_DISCONNECT:
465  _dbus_verbose (" %s auth state: need to disconnect\n",
466  TRANSPORT_SIDE (transport));
467  do_io_error (transport);
468  break;
469 
470  case DBUS_AUTH_STATE_AUTHENTICATED:
471  _dbus_verbose (" %s auth state: authenticated\n",
472  TRANSPORT_SIDE (transport));
473  break;
474  }
475  }
476 
477  out:
478  if (auth_completed)
479  *auth_completed = (orig_auth_state != _dbus_transport_try_to_authenticate (transport));
480 
481  check_read_watch (transport);
482  check_write_watch (transport);
483  _dbus_transport_unref (transport);
484 
485  if (oom)
486  return FALSE;
487  else
488  return TRUE;
489 }
490 
491 /* returns false on oom */
492 static dbus_bool_t
493 do_writing (DBusTransport *transport)
494 {
495  int total;
496  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
497  dbus_bool_t oom;
498 
499  /* No messages without authentication! */
500  if (!_dbus_transport_try_to_authenticate (transport))
501  {
502  _dbus_verbose ("Not authenticated, not writing anything\n");
503  return TRUE;
504  }
505 
506  if (transport->disconnected)
507  {
508  _dbus_verbose ("Not connected, not writing anything\n");
509  return TRUE;
510  }
511 
512 #if 1
513  _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",
515  socket_transport->fd);
516 #endif
517 
518  oom = FALSE;
519  total = 0;
520 
521  while (!transport->disconnected &&
523  {
524  int bytes_written;
525  DBusMessage *message;
526  const DBusString *header;
527  const DBusString *body;
528  int header_len, body_len;
529  int total_bytes_to_write;
530 
531  if (total > socket_transport->max_bytes_written_per_iteration)
532  {
533  _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",
534  total, socket_transport->max_bytes_written_per_iteration);
535  goto out;
536  }
537 
538  message = _dbus_connection_get_message_to_send (transport->connection);
539  _dbus_assert (message != NULL);
540  dbus_message_lock (message);
541 
542 #if 0
543  _dbus_verbose ("writing message %p\n", message);
544 #endif
545 
547  &header, &body);
548 
549  header_len = _dbus_string_get_length (header);
550  body_len = _dbus_string_get_length (body);
551 
552  if (_dbus_auth_needs_encoding (transport->auth))
553  {
554  /* Does fd passing even make sense with encoded data? */
555  _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
556 
557  if (_dbus_string_get_length (&socket_transport->encoded_outgoing) == 0)
558  {
559  if (!_dbus_auth_encode_data (transport->auth,
560  header, &socket_transport->encoded_outgoing))
561  {
562  oom = TRUE;
563  goto out;
564  }
565 
566  if (!_dbus_auth_encode_data (transport->auth,
567  body, &socket_transport->encoded_outgoing))
568  {
569  _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
570  oom = TRUE;
571  goto out;
572  }
573  }
574 
575  total_bytes_to_write = _dbus_string_get_length (&socket_transport->encoded_outgoing);
576 
577 #if 0
578  _dbus_verbose ("encoded message is %d bytes\n",
579  total_bytes_to_write);
580 #endif
581 
582  bytes_written =
583  _dbus_write_socket (socket_transport->fd,
584  &socket_transport->encoded_outgoing,
585  socket_transport->message_bytes_written,
586  total_bytes_to_write - socket_transport->message_bytes_written);
587  }
588  else
589  {
590  total_bytes_to_write = header_len + body_len;
591 
592 #if 0
593  _dbus_verbose ("message is %d bytes\n",
594  total_bytes_to_write);
595 #endif
596 
597 #ifdef HAVE_UNIX_FD_PASSING
598  if (socket_transport->message_bytes_written <= 0 && DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
599  {
600  /* Send the fds along with the first byte of the message */
601  const int *unix_fds;
602  unsigned n;
603 
604  _dbus_message_get_unix_fds(message, &unix_fds, &n);
605 
606  bytes_written =
607  _dbus_write_socket_with_unix_fds_two (socket_transport->fd,
608  header,
609  socket_transport->message_bytes_written,
610  header_len - socket_transport->message_bytes_written,
611  body,
612  0, body_len,
613  unix_fds,
614  n);
615 
616  if (bytes_written > 0 && n > 0)
617  _dbus_verbose("Wrote %i unix fds\n", n);
618  }
619  else
620 #endif
621  {
622  if (socket_transport->message_bytes_written < header_len)
623  {
624  bytes_written =
625  _dbus_write_socket_two (socket_transport->fd,
626  header,
627  socket_transport->message_bytes_written,
628  header_len - socket_transport->message_bytes_written,
629  body,
630  0, body_len);
631  }
632  else
633  {
634  bytes_written =
635  _dbus_write_socket (socket_transport->fd,
636  body,
637  (socket_transport->message_bytes_written - header_len),
638  body_len -
639  (socket_transport->message_bytes_written - header_len));
640  }
641  }
642  }
643 
644  if (bytes_written < 0)
645  {
646  /* EINTR already handled for us */
647 
648  /* If the other end closed the socket with close() or shutdown(), we
649  * receive EPIPE here but we must not close the socket yet: there
650  * might still be some data to read. See:
651  * http://lists.freedesktop.org/archives/dbus/2008-March/009526.html
652  */
653 
655  goto out;
656 
657  /* Since Linux commit 25888e (from 2.6.37-rc4, Nov 2010), sendmsg()
658  * on Unix sockets returns -1 errno=ETOOMANYREFS when the passfd
659  * mechanism (SCM_RIGHTS) is used recursively with a recursion level
660  * of maximum 4. The kernel does not have an API to check whether
661  * the passed fds can be forwarded and it can change asynchronously.
662  * See:
663  * https://bugs.freedesktop.org/show_bug.cgi?id=80163
664  */
665 
667  {
668  /* We only send fds in the first byte of the message.
669  * ETOOMANYREFS cannot happen after.
670  */
671  _dbus_assert (socket_transport->message_bytes_written == 0);
672 
673  _dbus_verbose (" discard message of %d bytes due to ETOOMANYREFS\n",
674  total_bytes_to_write);
675 
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);
679 
680  /* The message was not actually sent but it needs to be removed
681  * from the outgoing queue
682  */
684  message);
685  }
686  else
687  {
688  _dbus_verbose ("Error writing to remote app: %s\n",
690  do_io_error (transport);
691  goto out;
692  }
693  }
694  else
695  {
696  _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
697  total_bytes_to_write);
698 
699  total += bytes_written;
700  socket_transport->message_bytes_written += bytes_written;
701 
702  _dbus_assert (socket_transport->message_bytes_written <=
703  total_bytes_to_write);
704 
705  if (socket_transport->message_bytes_written == total_bytes_to_write)
706  {
707  socket_transport->message_bytes_written = 0;
708  _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
709  _dbus_string_compact (&socket_transport->encoded_outgoing, 2048);
710 
712  message);
713  }
714  }
715  }
716 
717  out:
718  if (oom)
719  return FALSE;
720  else
721  return TRUE;
722 }
723 
724 /* returns false on out-of-memory */
725 static dbus_bool_t
726 do_reading (DBusTransport *transport)
727 {
728  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
729  DBusString *buffer;
730  int bytes_read;
731  int total;
732  dbus_bool_t oom;
733 
734  _dbus_verbose ("fd = %d\n",socket_transport->fd);
735 
736  /* No messages without authentication! */
737  if (!_dbus_transport_try_to_authenticate (transport))
738  return TRUE;
739 
740  oom = FALSE;
741 
742  total = 0;
743 
744  again:
745 
746  /* See if we've exceeded max messages and need to disable reading */
747  check_read_watch (transport);
748 
749  if (total > socket_transport->max_bytes_read_per_iteration)
750  {
751  _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
752  total, socket_transport->max_bytes_read_per_iteration);
753  goto out;
754  }
755 
756  _dbus_assert (socket_transport->read_watch != NULL ||
757  transport->disconnected);
758 
759  if (transport->disconnected)
760  goto out;
761 
762  if (!dbus_watch_get_enabled (socket_transport->read_watch))
763  return TRUE;
764 
765  if (_dbus_auth_needs_decoding (transport->auth))
766  {
767  /* Does fd passing even make sense with encoded data? */
768  _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
769 
770  if (_dbus_string_get_length (&socket_transport->encoded_incoming) > 0)
771  bytes_read = _dbus_string_get_length (&socket_transport->encoded_incoming);
772  else
773  bytes_read = _dbus_read_socket (socket_transport->fd,
774  &socket_transport->encoded_incoming,
775  socket_transport->max_bytes_read_per_iteration);
776 
777  _dbus_assert (_dbus_string_get_length (&socket_transport->encoded_incoming) ==
778  bytes_read);
779 
780  if (bytes_read > 0)
781  {
783  &buffer);
784 
785  if (!_dbus_auth_decode_data (transport->auth,
786  &socket_transport->encoded_incoming,
787  buffer))
788  {
789  _dbus_verbose ("Out of memory decoding incoming data\n");
791  buffer);
792 
793  oom = TRUE;
794  goto out;
795  }
796 
798  buffer);
799 
800  _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
801  _dbus_string_compact (&socket_transport->encoded_incoming, 2048);
802  }
803  }
804  else
805  {
807  &buffer);
808 
809 #ifdef HAVE_UNIX_FD_PASSING
810  if (DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
811  {
812  int *fds, n_fds;
813 
814  if (!_dbus_message_loader_get_unix_fds(transport->loader, &fds, &n_fds))
815  {
816  _dbus_verbose ("Out of memory reading file descriptors\n");
817  _dbus_message_loader_return_buffer (transport->loader, buffer);
818  oom = TRUE;
819  goto out;
820  }
821 
822  bytes_read = _dbus_read_socket_with_unix_fds(socket_transport->fd,
823  buffer,
824  socket_transport->max_bytes_read_per_iteration,
825  fds, &n_fds);
826 
827  if (bytes_read >= 0 && n_fds > 0)
828  _dbus_verbose("Read %i unix fds\n", n_fds);
829 
830  _dbus_message_loader_return_unix_fds(transport->loader, fds, bytes_read < 0 ? 0 : n_fds);
831  }
832  else
833 #endif
834  {
835  bytes_read = _dbus_read_socket (socket_transport->fd,
836  buffer, socket_transport->max_bytes_read_per_iteration);
837  }
838 
840  buffer);
841  }
842 
843  if (bytes_read < 0)
844  {
845  /* EINTR already handled for us */
846 
848  {
849  _dbus_verbose ("Out of memory in read()/do_reading()\n");
850  oom = TRUE;
851  goto out;
852  }
854  goto out;
855  else
856  {
857  _dbus_verbose ("Error reading from remote app: %s\n",
859  do_io_error (transport);
860  goto out;
861  }
862  }
863  else if (bytes_read == 0)
864  {
865  _dbus_verbose ("Disconnected from remote app\n");
866  do_io_error (transport);
867  goto out;
868  }
869  else
870  {
871  _dbus_verbose (" read %d bytes\n", bytes_read);
872 
873  total += bytes_read;
874 
875  if (!_dbus_transport_queue_messages (transport))
876  {
877  oom = TRUE;
878  _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
879  goto out;
880  }
881 
882  /* Try reading more data until we get EAGAIN and return, or
883  * exceed max bytes per iteration. If in blocking mode of
884  * course we'll block instead of returning.
885  */
886  goto again;
887  }
888 
889  out:
890  if (oom)
891  return FALSE;
892  else
893  return TRUE;
894 }
895 
896 static dbus_bool_t
897 unix_error_with_read_to_come (DBusTransport *itransport,
898  DBusWatch *watch,
899  unsigned int flags)
900 {
901  DBusTransportSocket *transport = (DBusTransportSocket *) itransport;
902 
903  if (!(flags & DBUS_WATCH_HANGUP || flags & DBUS_WATCH_ERROR))
904  return FALSE;
905 
906  /* If we have a read watch enabled ...
907  we -might have data incoming ... => handle the HANGUP there */
908  if (watch != transport->read_watch &&
909  _dbus_watch_get_enabled (transport->read_watch))
910  return FALSE;
911 
912  return TRUE;
913 }
914 
915 static dbus_bool_t
916 socket_handle_watch (DBusTransport *transport,
917  DBusWatch *watch,
918  unsigned int flags)
919 {
920  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
921 
922  _dbus_assert (watch == socket_transport->read_watch ||
923  watch == socket_transport->write_watch);
924  _dbus_assert (watch != NULL);
925 
926  /* If we hit an error here on a write watch, don't disconnect the transport yet because data can
927  * still be in the buffer and do_reading may need several iteration to read
928  * it all (because of its max_bytes_read_per_iteration limit).
929  */
930  if (!(flags & DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
931  {
932  _dbus_verbose ("Hang up or error on watch\n");
933  _dbus_transport_disconnect (transport);
934  return TRUE;
935  }
936 
937  if (watch == socket_transport->read_watch &&
938  (flags & DBUS_WATCH_READABLE))
939  {
940  dbus_bool_t auth_finished;
941 #if 1
942  _dbus_verbose ("handling read watch %p flags = %x\n",
943  watch, flags);
944 #endif
945  if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
946  return FALSE;
947 
948  /* We don't want to do a read immediately following
949  * a successful authentication. This is so we
950  * have a chance to propagate the authentication
951  * state further up. Specifically, we need to
952  * process any pending data from the auth object.
953  */
954  if (!auth_finished)
955  {
956  if (!do_reading (transport))
957  {
958  _dbus_verbose ("no memory to read\n");
959  return FALSE;
960  }
961  }
962  else
963  {
964  _dbus_verbose ("Not reading anything since we just completed the authentication\n");
965  }
966  }
967  else if (watch == socket_transport->write_watch &&
968  (flags & DBUS_WATCH_WRITABLE))
969  {
970 #if 1
971  _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
973 #endif
974  if (!do_authentication (transport, FALSE, TRUE, NULL))
975  return FALSE;
976 
977  if (!do_writing (transport))
978  {
979  _dbus_verbose ("no memory to write\n");
980  return FALSE;
981  }
982 
983  /* See if we still need the write watch */
984  check_write_watch (transport);
985  }
986 #ifdef DBUS_ENABLE_VERBOSE_MODE
987  else
988  {
989  if (watch == socket_transport->read_watch)
990  _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
991  flags);
992  else if (watch == socket_transport->write_watch)
993  _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
994  flags);
995  else
996  _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
997  watch, dbus_watch_get_socket (watch));
998  }
999 #endif /* DBUS_ENABLE_VERBOSE_MODE */
1000 
1001  return TRUE;
1002 }
1003 
1004 static void
1005 socket_disconnect (DBusTransport *transport)
1006 {
1007  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1008 
1009  _dbus_verbose ("\n");
1010 
1011  free_watches (transport);
1012 
1013  _dbus_close_socket (socket_transport->fd, NULL);
1014  socket_transport->fd = -1;
1015 }
1016 
1017 static dbus_bool_t
1018 socket_connection_set (DBusTransport *transport)
1019 {
1020  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1021 
1022  _dbus_watch_set_handler (socket_transport->write_watch,
1024  transport->connection, NULL);
1025 
1026  _dbus_watch_set_handler (socket_transport->read_watch,
1028  transport->connection, NULL);
1029 
1031  socket_transport->write_watch))
1032  return FALSE;
1033 
1035  socket_transport->read_watch))
1036  {
1038  socket_transport->write_watch);
1039  return FALSE;
1040  }
1041 
1042  check_read_watch (transport);
1043  check_write_watch (transport);
1044 
1045  return TRUE;
1046 }
1047 
1055 static void
1056 socket_do_iteration (DBusTransport *transport,
1057  unsigned int flags,
1058  int timeout_milliseconds)
1059 {
1060  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1061  DBusPollFD poll_fd;
1062  int poll_res;
1063  int poll_timeout;
1064 
1065  _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
1066  flags & DBUS_ITERATION_DO_READING ? "read" : "",
1067  flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
1068  timeout_milliseconds,
1069  socket_transport->read_watch,
1070  socket_transport->write_watch,
1071  socket_transport->fd);
1072 
1073  /* the passed in DO_READING/DO_WRITING flags indicate whether to
1074  * read/write messages, but regardless of those we may need to block
1075  * for reading/writing to do auth. But if we do reading for auth,
1076  * we don't want to read any messages yet if not given DO_READING.
1077  */
1078 
1079  poll_fd.fd = socket_transport->fd;
1080  poll_fd.events = 0;
1081 
1082  if (_dbus_transport_try_to_authenticate (transport))
1083  {
1084  /* This is kind of a hack; if we have stuff to write, then try
1085  * to avoid the poll. This is probably about a 5% speedup on an
1086  * echo client/server.
1087  *
1088  * If both reading and writing were requested, we want to avoid this
1089  * since it could have funky effects:
1090  * - both ends spinning waiting for the other one to read
1091  * data so they can finish writing
1092  * - prioritizing all writing ahead of reading
1093  */
1094  if ((flags & DBUS_ITERATION_DO_WRITING) &&
1095  !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
1096  !transport->disconnected &&
1098  {
1099  do_writing (transport);
1100 
1101  if (transport->disconnected ||
1103  goto out;
1104  }
1105 
1106  /* If we get here, we decided to do the poll() after all */
1107  _dbus_assert (socket_transport->read_watch);
1108  if (flags & DBUS_ITERATION_DO_READING)
1109  poll_fd.events |= _DBUS_POLLIN;
1110 
1111  _dbus_assert (socket_transport->write_watch);
1112  if (flags & DBUS_ITERATION_DO_WRITING)
1113  poll_fd.events |= _DBUS_POLLOUT;
1114  }
1115  else
1116  {
1117  DBusAuthState auth_state;
1118 
1119  auth_state = _dbus_auth_do_work (transport->auth);
1120 
1121  if (transport->receive_credentials_pending ||
1122  auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1123  poll_fd.events |= _DBUS_POLLIN;
1124 
1125  if (transport->send_credentials_pending ||
1126  auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1127  poll_fd.events |= _DBUS_POLLOUT;
1128  }
1129 
1130  if (poll_fd.events)
1131  {
1132  if (flags & DBUS_ITERATION_BLOCK)
1133  poll_timeout = timeout_milliseconds;
1134  else
1135  poll_timeout = 0;
1136 
1137  /* For blocking selects we drop the connection lock here
1138  * to avoid blocking out connection access during a potentially
1139  * indefinite blocking call. The io path is still protected
1140  * by the io_path_cond condvar, so we won't reenter this.
1141  */
1142  if (flags & DBUS_ITERATION_BLOCK)
1143  {
1144  _dbus_verbose ("unlock pre poll\n");
1145  _dbus_connection_unlock (transport->connection);
1146  }
1147 
1148  again:
1149  poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1150 
1151  if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1152  goto again;
1153 
1154  if (flags & DBUS_ITERATION_BLOCK)
1155  {
1156  _dbus_verbose ("lock post poll\n");
1157  _dbus_connection_lock (transport->connection);
1158  }
1159 
1160  if (poll_res >= 0)
1161  {
1162  if (poll_res == 0)
1163  poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1164  * valgrind flags it as an error. though it probably
1165  * is guaranteed on linux at least.
1166  */
1167 
1168  if (poll_fd.revents & _DBUS_POLLERR)
1169  do_io_error (transport);
1170  else
1171  {
1172  dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1173  dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1174  dbus_bool_t authentication_completed;
1175 
1176  _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1177  need_read, need_write);
1178  do_authentication (transport, need_read, need_write,
1179  &authentication_completed);
1180 
1181  /* See comment in socket_handle_watch. */
1182  if (authentication_completed)
1183  goto out;
1184 
1185  if (need_read && (flags & DBUS_ITERATION_DO_READING))
1186  do_reading (transport);
1187  if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1188  do_writing (transport);
1189  }
1190  }
1191  else
1192  {
1193  _dbus_verbose ("Error from _dbus_poll(): %s\n",
1195  }
1196  }
1197 
1198 
1199  out:
1200  /* We need to install the write watch only if we did not
1201  * successfully write everything. Note we need to be careful that we
1202  * don't call check_write_watch *before* do_writing, since it's
1203  * inefficient to add the write watch, and we can avoid it most of
1204  * the time since we can write immediately.
1205  *
1206  * However, we MUST always call check_write_watch(); DBusConnection code
1207  * relies on the fact that running an iteration will notice that
1208  * messages are pending.
1209  */
1210  check_write_watch (transport);
1211 
1212  _dbus_verbose (" ... leaving do_iteration()\n");
1213 }
1214 
1215 static void
1216 socket_live_messages_changed (DBusTransport *transport)
1217 {
1218  /* See if we should look for incoming messages again */
1219  check_read_watch (transport);
1220 }
1221 
1222 
1223 static dbus_bool_t
1224 socket_get_socket_fd (DBusTransport *transport,
1225  int *fd_p)
1226 {
1227  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1228 
1229  *fd_p = socket_transport->fd;
1230 
1231  return TRUE;
1232 }
1233 
1234 static const DBusTransportVTable socket_vtable = {
1235  socket_finalize,
1236  socket_handle_watch,
1237  socket_disconnect,
1238  socket_connection_set,
1239  socket_do_iteration,
1240  socket_live_messages_changed,
1241  socket_get_socket_fd
1242 };
1243 
1257  const DBusString *server_guid,
1258  const DBusString *address)
1259 {
1260  DBusTransportSocket *socket_transport;
1261 
1262  socket_transport = dbus_new0 (DBusTransportSocket, 1);
1263  if (socket_transport == NULL)
1264  return NULL;
1265 
1266  if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1267  goto failed_0;
1268 
1269  if (!_dbus_string_init (&socket_transport->encoded_incoming))
1270  goto failed_1;
1271 
1272  socket_transport->write_watch = _dbus_watch_new (fd,
1273  DBUS_WATCH_WRITABLE,
1274  FALSE,
1275  NULL, NULL, NULL);
1276  if (socket_transport->write_watch == NULL)
1277  goto failed_2;
1278 
1279  socket_transport->read_watch = _dbus_watch_new (fd,
1280  DBUS_WATCH_READABLE,
1281  FALSE,
1282  NULL, NULL, NULL);
1283  if (socket_transport->read_watch == NULL)
1284  goto failed_3;
1285 
1286  if (!_dbus_transport_init_base (&socket_transport->base,
1287  &socket_vtable,
1288  server_guid, address))
1289  goto failed_4;
1290 
1291 #ifdef HAVE_UNIX_FD_PASSING
1293 #endif
1294 
1295  socket_transport->fd = fd;
1296  socket_transport->message_bytes_written = 0;
1297 
1298  /* These values should probably be tunable or something. */
1299  socket_transport->max_bytes_read_per_iteration = 2048;
1300  socket_transport->max_bytes_written_per_iteration = 2048;
1301 
1302  return (DBusTransport*) socket_transport;
1303 
1304  failed_4:
1305  _dbus_watch_invalidate (socket_transport->read_watch);
1306  _dbus_watch_unref (socket_transport->read_watch);
1307  failed_3:
1308  _dbus_watch_invalidate (socket_transport->write_watch);
1309  _dbus_watch_unref (socket_transport->write_watch);
1310  failed_2:
1311  _dbus_string_free (&socket_transport->encoded_incoming);
1312  failed_1:
1313  _dbus_string_free (&socket_transport->encoded_outgoing);
1314  failed_0:
1315  dbus_free (socket_transport);
1316  return NULL;
1317 }
1318 
1332  const char *port,
1333  const char *family,
1334  const char *noncefile,
1335  DBusError *error)
1336 {
1337  int fd;
1338  DBusTransport *transport;
1339  DBusString address;
1340 
1341  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1342 
1343  if (!_dbus_string_init (&address))
1344  {
1346  return NULL;
1347  }
1348 
1349  if (host == NULL)
1350  host = "localhost";
1351 
1352  if (!_dbus_string_append (&address, noncefile ? "nonce-tcp:" : "tcp:"))
1353  goto error;
1354 
1355  if (!_dbus_string_append (&address, "host=") ||
1356  !_dbus_string_append (&address, host))
1357  goto error;
1358 
1359  if (!_dbus_string_append (&address, ",port=") ||
1360  !_dbus_string_append (&address, port))
1361  goto error;
1362 
1363  if (family != NULL &&
1364  (!_dbus_string_append (&address, ",family=") ||
1365  !_dbus_string_append (&address, family)))
1366  goto error;
1367 
1368  if (noncefile != NULL &&
1369  (!_dbus_string_append (&address, ",noncefile=") ||
1370  !_dbus_string_append (&address, noncefile)))
1371  goto error;
1372 
1373  fd = _dbus_connect_tcp_socket_with_nonce (host, port, family, noncefile, error);
1374  if (fd < 0)
1375  {
1376  _DBUS_ASSERT_ERROR_IS_SET (error);
1377  _dbus_string_free (&address);
1378  return NULL;
1379  }
1380 
1381  _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1382  host, port);
1383 
1384  transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1385  _dbus_string_free (&address);
1386  if (transport == NULL)
1387  {
1389  _dbus_close_socket (fd, NULL);
1390  fd = -1;
1391  }
1392 
1393  return transport;
1394 
1395 error:
1396  _dbus_string_free (&address);
1398  return NULL;
1399 }
1400 
1409 DBusTransportOpenResult
1411  DBusTransport **transport_p,
1412  DBusError *error)
1413 {
1414  const char *method;
1415  dbus_bool_t isTcp;
1416  dbus_bool_t isNonceTcp;
1417 
1418  method = dbus_address_entry_get_method (entry);
1419  _dbus_assert (method != NULL);
1420 
1421  isTcp = strcmp (method, "tcp") == 0;
1422  isNonceTcp = strcmp (method, "nonce-tcp") == 0;
1423 
1424  if (isTcp || isNonceTcp)
1425  {
1426  const char *host = dbus_address_entry_get_value (entry, "host");
1427  const char *port = dbus_address_entry_get_value (entry, "port");
1428  const char *family = dbus_address_entry_get_value (entry, "family");
1429  const char *noncefile = dbus_address_entry_get_value (entry, "noncefile");
1430 
1431  if ((isNonceTcp == TRUE) != (noncefile != NULL)) {
1432  _dbus_set_bad_address (error, method, "noncefile", NULL);
1433  return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1434  }
1435 
1436  if (port == NULL)
1437  {
1438  _dbus_set_bad_address (error, method, "port", NULL);
1439  return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1440  }
1441 
1442  *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, noncefile, error);
1443  if (*transport_p == NULL)
1444  {
1445  _DBUS_ASSERT_ERROR_IS_SET (error);
1446  return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1447  }
1448  else
1449  {
1450  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1451  return DBUS_TRANSPORT_OPEN_OK;
1452  }
1453  }
1454  else
1455  {
1456  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1457  return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
1458  }
1459 }
1460 
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.
Definition: dbus-string.c:918
void dbus_message_lock(DBusMessage *message)
Locks a message.
Definition: dbus-message.c:384
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
Definition: dbus-errors.h:51
Implementation of DBusWatch.
Definition: dbus-watch.c:40
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++.
int fd
File descriptor.
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().
Definition: dbus-memory.c:701
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_socket_can_pass_unix_fd(int fd)
Checks whether file descriptors may be passed via the socket.
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...
Definition: dbus-auth.c:2650
void _dbus_watch_invalidate(DBusWatch *watch)
Clears the file descriptor from a now-invalid watch object so that no one tries to use it...
Definition: dbus-watch.c:169
long max_live_messages_size
Max total size of received messages.
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.
Definition: dbus-auth.c:2618
DBUS_EXPORT dbus_bool_t dbus_watch_get_enabled(DBusWatch *watch)
Returns whether a watch is enabled or not.
Definition: dbus-watch.c:667
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
int _dbus_write_socket_two(int 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.
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
const char * dbus_address_entry_get_method(DBusAddressEntry *entry)
Returns the method string of an address entry.
Definition: dbus-address.c:227
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...
dbus_bool_t _dbus_get_is_errno_etoomanyrefs(void)
See if errno is ETOOMANYREFS.
Definition: dbus-sysdeps.c:769
void _dbus_auth_return_buffer(DBusAuth *auth, DBusString *buffer)
Returns a buffer with new data read into it.
Definition: dbus-auth.c:2538
DBusAuthState _dbus_auth_do_work(DBusAuth *auth)
Analyzes buffered input and moves the auth conversation forward, returning the new state of the auth ...
Definition: dbus-auth.c:2431
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...
Definition: dbus-errors.c:211
int _dbus_read_socket_with_unix_fds(int fd, DBusString *buffer, int count, int *fds, int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
A portable struct pollfd wrapper.
Definition: dbus-sysdeps.h:310
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.
Definition: dbus-sysdeps.h:294
unsigned int send_credentials_pending
TRUE if we need to send credentials
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
DBusTransport * _dbus_transport_new_for_socket(int fd, const DBusString *server_guid, const DBusString *address)
Creates a new transport for the given socket file descriptor.
DBusMessage * _dbus_connection_get_message_to_send(DBusConnection *connection)
Gets the next outgoing message.
short events
Events to poll for.
Definition: dbus-sysdeps.h:313
dbus_bool_t _dbus_read_credentials_socket(int client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
DBusString encoded_incoming
Encoded version of current incoming data.
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.
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.
Definition: dbus-auth.c:2520
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.
Definition: dbus-auth.c:2681
const char * dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
Returns a value from a key of an entry.
Definition: dbus-address.c:244
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:59
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...
Definition: dbus-auth.c:2500
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.
Definition: dbus-string.c:372
unsigned int receive_credentials_pending
TRUE if we need to receive credentials
As in POLLOUT.
DBusCounter * live_messages
Counter for size/unix fds of all live messages.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
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...
Definition: dbus-watch.c:586
int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
#define _DBUS_POLLOUT
Writing now will not block.
Definition: dbus-sysdeps.h:298
Internals of DBusAddressEntry.
Definition: dbus-address.c:43
int _dbus_read_socket(int fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
DBusWatch * write_watch
Watch for writability.
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.
Definition: dbus-address.c:65
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_enomem(void)
See if errno is ENOMEM.
Definition: dbus-sysdeps.c:739
Object representing an exception.
Definition: dbus-errors.h:48
dbus_bool_t _dbus_send_credentials_socket(int server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
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.
Definition: dbus-errors.c:354
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...
int fd
File descriptor.
Definition: dbus-sysdeps.h:312
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().
Definition: dbus-string.c:242
#define TRUE
Expands to "1".
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.
Definition: dbus-message.c:208
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.
Definition: dbus-auth.c:2713
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.
Definition: dbus-auth.c:2789
const char * _dbus_strerror_from_errno(void)
Get error message from errno.
Definition: dbus-sysdeps.c:783
int _dbus_write_socket(int 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_get_is_errno_eintr(void)
See if errno is EINTR.
Definition: dbus-sysdeps.c:749
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.
DBusWatch * _dbus_watch_new(int fd, unsigned int flags, dbus_bool_t enabled, DBusWatchHandler handler, void *data, DBusFreeFunction free_data_function)
Creates a new DBusWatch.
Definition: dbus-watch.c:88
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_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer)
Gets the buffer to use for reading data from the network.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(void)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted) ...
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.
Definition: dbus-auth.c:2475
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.
Definition: dbus-string.c:785
int max_bytes_read_per_iteration
To avoid blocking too long.
void _dbus_watch_unref(DBusWatch *watch)
Decrements the reference count of a DBusWatch object and finalizes the object if the count reaches ze...
Definition: dbus-watch.c:138
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...
Definition: dbus-auth.c:2591
As in POLLIN.
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.
Definition: dbus-message.c:227
dbus_bool_t _dbus_close_socket(int 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.
Definition: dbus-watch.c:491
void _dbus_transport_disconnect(DBusTransport *transport)
Closes our end of the connection to a remote application.
void _dbus_transport_finalize_base(DBusTransport *transport)
Finalizes base class members of DBusTransport.
void _dbus_connection_unlock(DBusConnection *connection)
Releases the connection lock.
short revents
Events that occurred.
Definition: dbus-sysdeps.h:314
dbus_bool_t _dbus_get_is_errno_epipe(void)
See if errno is EPIPE.
Definition: dbus-sysdeps.c:759
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.
#define _DBUS_POLLERR
Error condition.
Definition: dbus-sysdeps.h:300
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.