D-Bus  1.7.6
dbus-transport.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-transport.c DBusTransport object (internal to D-Bus implementation)
3  *
4  * Copyright (C) 2002, 2003 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-transport-protected.h"
26 #include "dbus-transport-unix.h"
27 #include "dbus-transport-socket.h"
28 #include "dbus-connection-internal.h"
29 #include "dbus-watch.h"
30 #include "dbus-auth.h"
31 #include "dbus-address.h"
32 #include "dbus-credentials.h"
33 #include "dbus-mainloop.h"
34 #include "dbus-message.h"
35 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
36 #include "dbus-server-debug-pipe.h"
37 #endif
38 
60 static void
61 live_messages_notify (DBusCounter *counter,
62  void *user_data)
63 {
64  DBusTransport *transport = user_data;
65 
66  _dbus_transport_ref (transport);
67 
68 #if 0
69  _dbus_verbose ("Size counter value is now %d\n",
70  (int) _dbus_counter_get_size_value (counter));
71  _dbus_verbose ("Unix FD counter value is now %d\n",
72  (int) _dbus_counter_get_unix_fd_value (counter));
73 #endif
74 
75  /* disable or re-enable the read watch for the transport if
76  * required.
77  */
78  if (transport->vtable->live_messages_changed)
79  {
80  _dbus_connection_lock (transport->connection);
81  (* transport->vtable->live_messages_changed) (transport);
83  }
84 
85  _dbus_transport_unref (transport);
86 }
87 
103  const DBusTransportVTable *vtable,
104  const DBusString *server_guid,
105  const DBusString *address)
106 {
107  DBusMessageLoader *loader;
108  DBusAuth *auth;
109  DBusCounter *counter;
110  char *address_copy;
111  DBusCredentials *creds;
112 
113  loader = _dbus_message_loader_new ();
114  if (loader == NULL)
115  return FALSE;
116 
117  if (server_guid)
118  auth = _dbus_auth_server_new (server_guid);
119  else
120  auth = _dbus_auth_client_new ();
121  if (auth == NULL)
122  {
124  return FALSE;
125  }
126 
127  counter = _dbus_counter_new ();
128  if (counter == NULL)
129  {
130  _dbus_auth_unref (auth);
132  return FALSE;
133  }
134 
135  creds = _dbus_credentials_new ();
136  if (creds == NULL)
137  {
138  _dbus_counter_unref (counter);
139  _dbus_auth_unref (auth);
141  return FALSE;
142  }
143 
144  if (server_guid)
145  {
146  _dbus_assert (address == NULL);
147  address_copy = NULL;
148  }
149  else
150  {
151  _dbus_assert (address != NULL);
152 
153  if (!_dbus_string_copy_data (address, &address_copy))
154  {
155  _dbus_credentials_unref (creds);
156  _dbus_counter_unref (counter);
157  _dbus_auth_unref (auth);
159  return FALSE;
160  }
161  }
162 
163  transport->refcount = 1;
164  transport->vtable = vtable;
165  transport->loader = loader;
166  transport->auth = auth;
167  transport->live_messages = counter;
168  transport->authenticated = FALSE;
169  transport->disconnected = FALSE;
170  transport->is_server = (server_guid != NULL);
171  transport->send_credentials_pending = !transport->is_server;
172  transport->receive_credentials_pending = transport->is_server;
173  transport->address = address_copy;
174 
175  transport->unix_user_function = NULL;
176  transport->unix_user_data = NULL;
177  transport->free_unix_user_data = NULL;
178 
179  transport->windows_user_function = NULL;
180  transport->windows_user_data = NULL;
181  transport->free_windows_user_data = NULL;
182 
183  transport->expected_guid = NULL;
184 
185  /* Try to default to something that won't totally hose the system,
186  * but doesn't impose too much of a limitation.
187  */
188  transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;
189 
190  /* On Linux RLIMIT_NOFILE defaults to 1024, so allowing 4096 fds live
191  should be more than enough */
192  transport->max_live_messages_unix_fds = 4096;
193 
194  /* credentials read from socket if any */
195  transport->credentials = creds;
196 
198  transport->max_live_messages_size,
199  transport->max_live_messages_unix_fds,
200  live_messages_notify,
201  transport);
202 
203  if (transport->address)
204  _dbus_verbose ("Initialized transport on address %s\n", transport->address);
205 
206  return TRUE;
207 }
208 
215 void
217 {
218  if (!transport->disconnected)
219  _dbus_transport_disconnect (transport);
220 
221  if (transport->free_unix_user_data != NULL)
222  (* transport->free_unix_user_data) (transport->unix_user_data);
223 
224  if (transport->free_windows_user_data != NULL)
225  (* transport->free_windows_user_data) (transport->windows_user_data);
226 
227  _dbus_message_loader_unref (transport->loader);
228  _dbus_auth_unref (transport->auth);
230  0, 0, NULL, NULL);
231  _dbus_counter_unref (transport->live_messages);
232  dbus_free (transport->address);
233  dbus_free (transport->expected_guid);
234  if (transport->credentials)
236 }
237 
238 
249 static DBusTransport*
250 check_address (const char *address, DBusError *error)
251 {
252  DBusAddressEntry **entries;
253  DBusTransport *transport = NULL;
254  int len, i;
255 
256  _dbus_assert (address != NULL);
257 
258  if (!dbus_parse_address (address, &entries, &len, error))
259  return NULL; /* not a valid address */
260 
261  for (i = 0; i < len; i++)
262  {
263  transport = _dbus_transport_open (entries[i], error);
264  if (transport != NULL)
265  break;
266  }
267 
268  dbus_address_entries_free (entries);
269  return transport;
270 }
271 
280 static DBusTransport*
281 _dbus_transport_new_for_autolaunch (const char *scope, DBusError *error)
282 {
283  DBusString address;
284  DBusTransport *result = NULL;
285 
286  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
287 
288  if (!_dbus_string_init (&address))
289  {
291  return NULL;
292  }
293 
294  if (!_dbus_get_autolaunch_address (scope, &address, error))
295  {
296  _DBUS_ASSERT_ERROR_IS_SET (error);
297  goto out;
298  }
299 
300  result = check_address (_dbus_string_get_const_data (&address), error);
301  if (result == NULL)
302  _DBUS_ASSERT_ERROR_IS_SET (error);
303  else
304  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
305 
306  out:
307  _dbus_string_free (&address);
308  return result;
309 }
310 
311 static DBusTransportOpenResult
312 _dbus_transport_open_autolaunch (DBusAddressEntry *entry,
313  DBusTransport **transport_p,
314  DBusError *error)
315 {
316  const char *method;
317 
318  method = dbus_address_entry_get_method (entry);
319  _dbus_assert (method != NULL);
320 
321  if (strcmp (method, "autolaunch") == 0)
322  {
323  const char *scope = dbus_address_entry_get_value (entry, "scope");
324 
325  *transport_p = _dbus_transport_new_for_autolaunch (scope, error);
326 
327  if (*transport_p == NULL)
328  {
329  _DBUS_ASSERT_ERROR_IS_SET (error);
330  return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
331  }
332  else
333  {
334  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
335  return DBUS_TRANSPORT_OPEN_OK;
336  }
337  }
338  else
339  {
340  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
341  return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
342  }
343 }
344 
345 static const struct {
346  DBusTransportOpenResult (* func) (DBusAddressEntry *entry,
347  DBusTransport **transport_p,
348  DBusError *error);
349 } open_funcs[] = {
352  { _dbus_transport_open_autolaunch }
353 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
354  , { _dbus_transport_open_debug_pipe }
355 #endif
356 };
357 
368  DBusError *error)
369 {
370  DBusTransport *transport;
371  const char *expected_guid_orig;
372  char *expected_guid;
373  int i;
374  DBusError tmp_error = DBUS_ERROR_INIT;
375 
376  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
377 
378  transport = NULL;
379  expected_guid_orig = dbus_address_entry_get_value (entry, "guid");
380  expected_guid = _dbus_strdup (expected_guid_orig);
381 
382  if (expected_guid_orig != NULL && expected_guid == NULL)
383  {
384  _DBUS_SET_OOM (error);
385  return NULL;
386  }
387 
388  for (i = 0; i < (int) _DBUS_N_ELEMENTS (open_funcs); ++i)
389  {
390  DBusTransportOpenResult result;
391 
392  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
393  result = (* open_funcs[i].func) (entry, &transport, &tmp_error);
394 
395  switch (result)
396  {
397  case DBUS_TRANSPORT_OPEN_OK:
398  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
399  goto out;
400  break;
401  case DBUS_TRANSPORT_OPEN_NOT_HANDLED:
402  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
403  /* keep going through the loop of open funcs */
404  break;
405  case DBUS_TRANSPORT_OPEN_BAD_ADDRESS:
406  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
407  goto out;
408  break;
409  case DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT:
410  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
411  goto out;
412  break;
413  }
414  }
415 
416  out:
417 
418  if (transport == NULL)
419  {
420  if (!dbus_error_is_set (&tmp_error))
421  _dbus_set_bad_address (&tmp_error,
422  NULL, NULL,
423  "Unknown address type (examples of valid types are \"tcp\" and on UNIX \"unix\")");
424 
425  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
426  dbus_move_error(&tmp_error, error);
427  dbus_free (expected_guid);
428  }
429  else
430  {
431  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
432 
433  /* In the case of autostart the initial guid is NULL
434  * and the autostart transport recursively calls
435  * _dbus_open_transport wich returns a transport
436  * with a guid. That guid is the definitive one.
437  *
438  * FIXME: if more transports are added they may have
439  * an effect on the expected_guid semantics (i.e.
440  * expected_guid and transport->expected_guid may
441  * both have values). This is very unlikely though
442  * we should either throw asserts here for those
443  * corner cases or refactor the code so it is
444  * clearer on what is expected and what is not
445  */
446  if(expected_guid)
447  transport->expected_guid = expected_guid;
448  }
449 
450  return transport;
451 }
452 
461 {
462  _dbus_assert (transport->refcount > 0);
463 
464  transport->refcount += 1;
465 
466  return transport;
467 }
468 
476 void
478 {
479  _dbus_assert (transport != NULL);
480  _dbus_assert (transport->refcount > 0);
481 
482  transport->refcount -= 1;
483  if (transport->refcount == 0)
484  {
485  _dbus_verbose ("finalizing\n");
486 
487  _dbus_assert (transport->vtable->finalize != NULL);
488 
489  (* transport->vtable->finalize) (transport);
490  }
491 }
492 
501 void
503 {
504  _dbus_verbose ("start\n");
505 
506  _dbus_assert (transport->vtable->disconnect != NULL);
507 
508  if (transport->disconnected)
509  return;
510 
511  (* transport->vtable->disconnect) (transport);
512 
513  transport->disconnected = TRUE;
514 
515  _dbus_verbose ("end\n");
516 }
517 
528 {
529  return !transport->disconnected;
530 }
531 
532 static dbus_bool_t
533 auth_via_unix_user_function (DBusTransport *transport)
534 {
535  DBusCredentials *auth_identity;
536  dbus_bool_t allow;
537  DBusConnection *connection;
538  DBusAllowUnixUserFunction unix_user_function;
539  void *unix_user_data;
540  dbus_uid_t uid;
541 
542  /* Dropping the lock here probably isn't that safe. */
543 
544  auth_identity = _dbus_auth_get_identity (transport->auth);
545  _dbus_assert (auth_identity != NULL);
546 
547  connection = transport->connection;
548  unix_user_function = transport->unix_user_function;
549  unix_user_data = transport->unix_user_data;
550  uid = _dbus_credentials_get_unix_uid (auth_identity);
551 
552  _dbus_verbose ("unlock\n");
553  _dbus_connection_unlock (connection);
554 
555  allow = (* unix_user_function) (connection,
556  uid,
557  unix_user_data);
558 
559  _dbus_verbose ("lock post unix user function\n");
560  _dbus_connection_lock (connection);
561 
562  if (allow)
563  {
564  _dbus_verbose ("Client UID "DBUS_UID_FORMAT" authorized\n", uid);
565  }
566  else
567  {
568  _dbus_verbose ("Client UID "DBUS_UID_FORMAT
569  " was rejected, disconnecting\n",
570  _dbus_credentials_get_unix_uid (auth_identity));
571  _dbus_transport_disconnect (transport);
572  }
573 
574  return allow;
575 }
576 
577 static dbus_bool_t
578 auth_via_windows_user_function (DBusTransport *transport)
579 {
580  DBusCredentials *auth_identity;
581  dbus_bool_t allow;
582  DBusConnection *connection;
583  DBusAllowWindowsUserFunction windows_user_function;
584  void *windows_user_data;
585  char *windows_sid;
586 
587  /* Dropping the lock here probably isn't that safe. */
588 
589  auth_identity = _dbus_auth_get_identity (transport->auth);
590  _dbus_assert (auth_identity != NULL);
591 
592  connection = transport->connection;
593  windows_user_function = transport->windows_user_function;
594  windows_user_data = transport->unix_user_data;
595  windows_sid = _dbus_strdup (_dbus_credentials_get_windows_sid (auth_identity));
596 
597  if (windows_sid == NULL)
598  {
599  /* OOM */
600  return FALSE;
601  }
602 
603  _dbus_verbose ("unlock\n");
604  _dbus_connection_unlock (connection);
605 
606  allow = (* windows_user_function) (connection,
607  windows_sid,
608  windows_user_data);
609 
610  _dbus_verbose ("lock post windows user function\n");
611  _dbus_connection_lock (connection);
612 
613  if (allow)
614  {
615  _dbus_verbose ("Client SID '%s' authorized\n", windows_sid);
616  }
617  else
618  {
619  _dbus_verbose ("Client SID '%s' was rejected, disconnecting\n",
620  _dbus_credentials_get_windows_sid (auth_identity));
621  _dbus_transport_disconnect (transport);
622  }
623 
624  return allow;
625 }
626 
627 static dbus_bool_t
628 auth_via_default_rules (DBusTransport *transport)
629 {
630  DBusCredentials *auth_identity;
631  DBusCredentials *our_identity;
632  dbus_bool_t allow;
633 
634  auth_identity = _dbus_auth_get_identity (transport->auth);
635  _dbus_assert (auth_identity != NULL);
636 
637  /* By default, connection is allowed if the client is 1) root or 2)
638  * has the same UID as us or 3) anonymous is allowed.
639  */
640 
642  if (our_identity == NULL)
643  {
644  /* OOM */
645  return FALSE;
646  }
647 
648  if (transport->allow_anonymous ||
649  _dbus_credentials_get_unix_uid (auth_identity) == 0 ||
650  _dbus_credentials_same_user (our_identity,
651  auth_identity))
652  {
653  if (_dbus_credentials_include(our_identity,DBUS_CREDENTIAL_WINDOWS_SID))
654  _dbus_verbose ("Client authorized as SID '%s'"
655  "matching our SID '%s'\n",
656  _dbus_credentials_get_windows_sid(auth_identity),
657  _dbus_credentials_get_windows_sid(our_identity));
658  else
659  _dbus_verbose ("Client authorized as UID "DBUS_UID_FORMAT
660  " matching our UID "DBUS_UID_FORMAT"\n",
661  _dbus_credentials_get_unix_uid(auth_identity),
662  _dbus_credentials_get_unix_uid(our_identity));
663  /* We have authenticated! */
664  allow = TRUE;
665  }
666  else
667  {
668  if (_dbus_credentials_include(our_identity,DBUS_CREDENTIAL_WINDOWS_SID))
669  _dbus_verbose ("Client authorized as SID '%s'"
670  " but our SID is '%s', disconnecting\n",
671  (_dbus_credentials_get_windows_sid(auth_identity) ?
672  _dbus_credentials_get_windows_sid(auth_identity) : "<null>"),
673  (_dbus_credentials_get_windows_sid(our_identity) ?
674  _dbus_credentials_get_windows_sid(our_identity) : "<null>"));
675  else
676  _dbus_verbose ("Client authorized as UID "DBUS_UID_FORMAT
677  " but our UID is "DBUS_UID_FORMAT", disconnecting\n",
678  _dbus_credentials_get_unix_uid(auth_identity),
679  _dbus_credentials_get_unix_uid(our_identity));
680  _dbus_transport_disconnect (transport);
681  allow = FALSE;
682  }
683 
684  _dbus_credentials_unref (our_identity);
685 
686  return allow;
687 }
688 
702 {
703  return transport->authenticated;
704 }
705 
725 {
726  if (transport->authenticated)
727  return TRUE;
728  else
729  {
730  dbus_bool_t maybe_authenticated;
731 
732  if (transport->disconnected)
733  return FALSE;
734 
735  /* paranoia ref since we call user callbacks sometimes */
737 
738  maybe_authenticated =
739  (!(transport->send_credentials_pending ||
740  transport->receive_credentials_pending));
741 
742  if (maybe_authenticated)
743  {
744  switch (_dbus_auth_do_work (transport->auth))
745  {
746  case DBUS_AUTH_STATE_AUTHENTICATED:
747  /* leave as maybe_authenticated */
748  break;
749  default:
750  maybe_authenticated = FALSE;
751  }
752  }
753 
754  /* If we're the client, verify the GUID
755  */
756  if (maybe_authenticated && !transport->is_server)
757  {
758  const char *server_guid;
759 
760  server_guid = _dbus_auth_get_guid_from_server (transport->auth);
761  _dbus_assert (server_guid != NULL);
762 
763  if (transport->expected_guid &&
764  strcmp (transport->expected_guid, server_guid) != 0)
765  {
766  _dbus_verbose ("Client expected GUID '%s' and we got '%s' from the server\n",
767  transport->expected_guid, server_guid);
768  _dbus_transport_disconnect (transport);
770  return FALSE;
771  }
772  }
773 
774  /* If we're the server, see if we want to allow this identity to proceed.
775  */
776  if (maybe_authenticated && transport->is_server)
777  {
778  dbus_bool_t allow;
779  DBusCredentials *auth_identity;
780 
781  auth_identity = _dbus_auth_get_identity (transport->auth);
782  _dbus_assert (auth_identity != NULL);
783 
784  /* If we have an auth'd user and a user function, delegate
785  * deciding whether auth credentials are good enough to the
786  * app; otherwise, use our default decision process.
787  */
788  if (transport->unix_user_function != NULL &&
789  _dbus_credentials_include (auth_identity, DBUS_CREDENTIAL_UNIX_USER_ID))
790  {
791  allow = auth_via_unix_user_function (transport);
792  }
793  else if (transport->windows_user_function != NULL &&
794  _dbus_credentials_include (auth_identity, DBUS_CREDENTIAL_WINDOWS_SID))
795  {
796  allow = auth_via_windows_user_function (transport);
797  }
798  else
799  {
800  allow = auth_via_default_rules (transport);
801  }
802 
803  if (!allow)
804  maybe_authenticated = FALSE;
805  }
806 
807  transport->authenticated = maybe_authenticated;
808 
810  return maybe_authenticated;
811  }
812 }
813 
822 {
823  DBusCredentials *auth_identity;
824 
825  if (!transport->authenticated)
826  return TRUE;
827 
828  auth_identity = _dbus_auth_get_identity (transport->auth);
829 
830  if (_dbus_credentials_are_anonymous (auth_identity))
831  return TRUE;
832  else
833  return FALSE;
834 }
835 
844 {
845  return DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport);
846 }
847 
855 const char*
857 {
858  return transport->address;
859 }
860 
868 const char*
870 {
871  if (transport->is_server)
872  return NULL;
873  else if (transport->authenticated)
874  return _dbus_auth_get_guid_from_server (transport->auth);
875  else
876  return transport->expected_guid;
877 }
878 
890  DBusWatch *watch,
891  unsigned int condition)
892 {
893  dbus_bool_t retval;
894 
895  _dbus_assert (transport->vtable->handle_watch != NULL);
896 
897  if (transport->disconnected)
898  return TRUE;
899 
900  if (dbus_watch_get_socket (watch) < 0)
901  {
902  _dbus_warn_check_failed ("Tried to handle an invalidated watch; this watch should have been removed\n");
903  return TRUE;
904  }
905 
906  _dbus_watch_sanitize_condition (watch, &condition);
907 
908  _dbus_transport_ref (transport);
909  _dbus_watch_ref (watch);
910  retval = (* transport->vtable->handle_watch) (transport, watch, condition);
911  _dbus_watch_unref (watch);
912  _dbus_transport_unref (transport);
913 
914  return retval;
915 }
916 
928  DBusConnection *connection)
929 {
930  _dbus_assert (transport->vtable->connection_set != NULL);
931  _dbus_assert (transport->connection == NULL);
932 
933  transport->connection = connection;
934 
935  _dbus_transport_ref (transport);
936  if (!(* transport->vtable->connection_set) (transport))
937  transport->connection = NULL;
938  _dbus_transport_unref (transport);
939 
940  return transport->connection != NULL;
941 }
942 
952  int *fd_p)
953 {
954  dbus_bool_t retval;
955 
956  if (transport->vtable->get_socket_fd == NULL)
957  return FALSE;
958 
959  if (transport->disconnected)
960  return FALSE;
961 
962  _dbus_transport_ref (transport);
963 
964  retval = (* transport->vtable->get_socket_fd) (transport,
965  fd_p);
966 
967  _dbus_transport_unref (transport);
968 
969  return retval;
970 }
971 
983 void
985  unsigned int flags,
986  int timeout_milliseconds)
987 {
988  _dbus_assert (transport->vtable->do_iteration != NULL);
989 
990  _dbus_verbose ("Transport iteration flags 0x%x timeout %d connected = %d\n",
991  flags, timeout_milliseconds, !transport->disconnected);
992 
993  if ((flags & (DBUS_ITERATION_DO_WRITING |
994  DBUS_ITERATION_DO_READING)) == 0)
995  return; /* Nothing to do */
996 
997  if (transport->disconnected)
998  return;
999 
1000  _dbus_transport_ref (transport);
1001  (* transport->vtable->do_iteration) (transport, flags,
1002  timeout_milliseconds);
1003  _dbus_transport_unref (transport);
1004 
1005  _dbus_verbose ("end\n");
1006 }
1007 
1008 static dbus_bool_t
1009 recover_unused_bytes (DBusTransport *transport)
1010 {
1011  if (_dbus_auth_needs_decoding (transport->auth))
1012  {
1013  DBusString plaintext;
1014  const DBusString *encoded;
1015  DBusString *buffer;
1016  int orig_len;
1017 
1018  if (!_dbus_string_init (&plaintext))
1019  goto nomem;
1020 
1021  _dbus_auth_get_unused_bytes (transport->auth,
1022  &encoded);
1023 
1024  if (!_dbus_auth_decode_data (transport->auth,
1025  encoded, &plaintext))
1026  {
1027  _dbus_string_free (&plaintext);
1028  goto nomem;
1029  }
1030 
1032  &buffer);
1033 
1034  orig_len = _dbus_string_get_length (buffer);
1035 
1036  if (!_dbus_string_move (&plaintext, 0, buffer,
1037  orig_len))
1038  {
1039  _dbus_string_free (&plaintext);
1040  goto nomem;
1041  }
1042 
1043  _dbus_verbose (" %d unused bytes sent to message loader\n",
1044  _dbus_string_get_length (buffer) -
1045  orig_len);
1046 
1048  buffer);
1049 
1050  _dbus_auth_delete_unused_bytes (transport->auth);
1051 
1052  _dbus_string_free (&plaintext);
1053  }
1054  else
1055  {
1056  const DBusString *bytes;
1057  DBusString *buffer;
1058  int orig_len;
1059  dbus_bool_t succeeded;
1060 
1062  &buffer);
1063 
1064  orig_len = _dbus_string_get_length (buffer);
1065 
1066  _dbus_auth_get_unused_bytes (transport->auth,
1067  &bytes);
1068 
1069  succeeded = TRUE;
1070  if (!_dbus_string_copy (bytes, 0, buffer, _dbus_string_get_length (buffer)))
1071  succeeded = FALSE;
1072 
1073  _dbus_verbose (" %d unused bytes sent to message loader\n",
1074  _dbus_string_get_length (buffer) -
1075  orig_len);
1076 
1078  buffer);
1079 
1080  if (succeeded)
1081  _dbus_auth_delete_unused_bytes (transport->auth);
1082  else
1083  goto nomem;
1084  }
1085 
1086  return TRUE;
1087 
1088  nomem:
1089  _dbus_verbose ("Not enough memory to transfer unused bytes from auth conversation\n");
1090  return FALSE;
1091 }
1092 
1102 {
1103  if (_dbus_counter_get_size_value (transport->live_messages) >= transport->max_live_messages_size ||
1105  return DBUS_DISPATCH_COMPLETE; /* complete for now */
1106 
1107  if (!_dbus_transport_try_to_authenticate (transport))
1108  {
1109  if (_dbus_auth_do_work (transport->auth) ==
1110  DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
1112  else if (!_dbus_transport_try_to_authenticate (transport))
1113  return DBUS_DISPATCH_COMPLETE;
1114  }
1115 
1116  if (!transport->unused_bytes_recovered &&
1117  !recover_unused_bytes (transport))
1119 
1120  transport->unused_bytes_recovered = TRUE;
1121 
1122  if (!_dbus_message_loader_queue_messages (transport->loader))
1124 
1125  if (_dbus_message_loader_peek_message (transport->loader) != NULL)
1127  else
1128  return DBUS_DISPATCH_COMPLETE;
1129 }
1130 
1141 {
1142  DBusDispatchStatus status;
1143 
1144 #if 0
1145  _dbus_verbose ("_dbus_transport_queue_messages()\n");
1146 #endif
1147 
1148  /* Queue any messages */
1149  while ((status = _dbus_transport_get_dispatch_status (transport)) == DBUS_DISPATCH_DATA_REMAINS)
1150  {
1151  DBusMessage *message;
1152  DBusList *link;
1153 
1154  link = _dbus_message_loader_pop_message_link (transport->loader);
1155  _dbus_assert (link != NULL);
1156 
1157  message = link->data;
1158 
1159  _dbus_verbose ("queueing received message %p\n", message);
1160 
1161  if (!_dbus_message_add_counter (message, transport->live_messages))
1162  {
1164  link);
1165  status = DBUS_DISPATCH_NEED_MEMORY;
1166  break;
1167  }
1168  else
1169  {
1170  /* We didn't call the notify function when we added the counter, so
1171  * catch up now. Since we have the connection's lock, it's desirable
1172  * that we bypass the notify function and call this virtual method
1173  * directly. */
1174  if (transport->vtable->live_messages_changed)
1175  (* transport->vtable->live_messages_changed) (transport);
1176 
1177  /* pass ownership of link and message ref to connection */
1179  link);
1180  }
1181  }
1182 
1184  {
1185  _dbus_verbose ("Corrupted message stream, disconnecting\n");
1186  _dbus_transport_disconnect (transport);
1187  }
1188 
1189  return status != DBUS_DISPATCH_NEED_MEMORY;
1190 }
1191 
1198 void
1200  long size)
1201 {
1203 }
1204 
1211 void
1213  long n)
1214 {
1216 }
1217 
1224 long
1226 {
1228 }
1229 
1236 long
1238 {
1240 }
1241 
1248 void
1250  long size)
1251 {
1252  transport->max_live_messages_size = size;
1254  transport->max_live_messages_size,
1255  transport->max_live_messages_unix_fds,
1256  live_messages_notify,
1257  transport);
1258 }
1259 
1266 void
1268  long n)
1269 {
1270  transport->max_live_messages_unix_fds = n;
1272  transport->max_live_messages_size,
1273  transport->max_live_messages_unix_fds,
1274  live_messages_notify,
1275  transport);
1276 }
1277 
1284 long
1286 {
1287  return transport->max_live_messages_size;
1288 }
1289 
1296 long
1298 {
1299  return transport->max_live_messages_unix_fds;
1300 }
1301 
1311  unsigned long *uid)
1312 {
1313  DBusCredentials *auth_identity;
1314 
1315  *uid = _DBUS_INT32_MAX; /* better than some root or system user in
1316  * case of bugs in the caller. Caller should
1317  * never use this value on purpose, however.
1318  */
1319 
1320  if (!transport->authenticated)
1321  return FALSE;
1322 
1323  auth_identity = _dbus_auth_get_identity (transport->auth);
1324 
1325  if (_dbus_credentials_include (auth_identity,
1326  DBUS_CREDENTIAL_UNIX_USER_ID))
1327  {
1328  *uid = _dbus_credentials_get_unix_uid (auth_identity);
1329  return TRUE;
1330  }
1331  else
1332  return FALSE;
1333 }
1334 
1344  unsigned long *pid)
1345 {
1346  DBusCredentials *auth_identity;
1347 
1348  *pid = DBUS_PID_UNSET; /* Caller should never use this value on purpose,
1349  * but we set it to a safe number, INT_MAX,
1350  * just to root out possible bugs in bad callers.
1351  */
1352 
1353  if (!transport->authenticated)
1354  return FALSE;
1355 
1356  auth_identity = _dbus_auth_get_identity (transport->auth);
1357 
1358  if (_dbus_credentials_include (auth_identity,
1359  DBUS_CREDENTIAL_UNIX_PROCESS_ID))
1360  {
1361  *pid = _dbus_credentials_get_pid (auth_identity);
1362  return TRUE;
1363  }
1364  else
1365  return FALSE;
1366 }
1367 
1378  void **data,
1379  int *data_size)
1380 {
1381  DBusCredentials *auth_identity;
1382 
1383  *data = NULL;
1384  *data_size = 0;
1385 
1386  if (!transport->authenticated)
1387  return FALSE;
1388 
1389  auth_identity = _dbus_auth_get_identity (transport->auth);
1390 
1391  if (_dbus_credentials_include (auth_identity,
1392  DBUS_CREDENTIAL_ADT_AUDIT_DATA_ID))
1393  {
1394  *data = (void *) _dbus_credentials_get_adt_audit_data (auth_identity);
1395  *data_size = _dbus_credentials_get_adt_audit_data_size (auth_identity);
1396  return TRUE;
1397  }
1398  else
1399  return FALSE;
1400 }
1401 
1412 void
1414  DBusAllowUnixUserFunction function,
1415  void *data,
1416  DBusFreeFunction free_data_function,
1417  void **old_data,
1418  DBusFreeFunction *old_free_data_function)
1419 {
1420  *old_data = transport->unix_user_data;
1421  *old_free_data_function = transport->free_unix_user_data;
1422 
1423  transport->unix_user_function = function;
1424  transport->unix_user_data = data;
1425  transport->free_unix_user_data = free_data_function;
1426 }
1427 
1437  char **windows_sid_p)
1438 {
1439  DBusCredentials *auth_identity;
1440 
1441  *windows_sid_p = NULL;
1442 
1443  if (!transport->authenticated)
1444  return FALSE;
1445 
1446  auth_identity = _dbus_auth_get_identity (transport->auth);
1447 
1448  if (_dbus_credentials_include (auth_identity,
1449  DBUS_CREDENTIAL_WINDOWS_SID))
1450  {
1451  /* If no memory, we are supposed to return TRUE and set NULL */
1452  *windows_sid_p = _dbus_strdup (_dbus_credentials_get_windows_sid (auth_identity));
1453 
1454  return TRUE;
1455  }
1456  else
1457  return FALSE;
1458 }
1459 
1471 void
1474  void *data,
1475  DBusFreeFunction free_data_function,
1476  void **old_data,
1477  DBusFreeFunction *old_free_data_function)
1478 {
1479  *old_data = transport->windows_user_data;
1480  *old_free_data_function = transport->free_windows_user_data;
1481 
1482  transport->windows_user_function = function;
1483  transport->windows_user_data = data;
1484  transport->free_windows_user_data = free_data_function;
1485 }
1486 
1497  const char **mechanisms)
1498 {
1499  return _dbus_auth_set_mechanisms (transport->auth, mechanisms);
1500 }
1501 
1508 void
1510  dbus_bool_t value)
1511 {
1512  transport->allow_anonymous = value != FALSE;
1513 }
1514 
1515 #ifdef DBUS_ENABLE_STATS
1516 void
1517 _dbus_transport_get_stats (DBusTransport *transport,
1518  dbus_uint32_t *queue_bytes,
1519  dbus_uint32_t *queue_fds,
1520  dbus_uint32_t *peak_queue_bytes,
1521  dbus_uint32_t *peak_queue_fds)
1522 {
1523  if (queue_bytes != NULL)
1524  *queue_bytes = _dbus_counter_get_size_value (transport->live_messages);
1525 
1526  if (queue_fds != NULL)
1527  *queue_fds = _dbus_counter_get_unix_fd_value (transport->live_messages);
1528 
1529  if (peak_queue_bytes != NULL)
1530  *peak_queue_bytes = _dbus_counter_get_peak_size_value (transport->live_messages);
1531 
1532  if (peak_queue_fds != NULL)
1533  *peak_queue_fds = _dbus_counter_get_peak_unix_fd_value (transport->live_messages);
1534 }
1535 #endif /* DBUS_ENABLE_STATS */
1536