D-Bus  1.6.8
dbus-connection.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-connection.c DBusConnection object
3  *
4  * Copyright (C) 2002-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-shared.h"
26 #include "dbus-connection.h"
27 #include "dbus-list.h"
28 #include "dbus-timeout.h"
29 #include "dbus-transport.h"
30 #include "dbus-watch.h"
31 #include "dbus-connection-internal.h"
32 #include "dbus-pending-call-internal.h"
33 #include "dbus-list.h"
34 #include "dbus-hash.h"
35 #include "dbus-message-internal.h"
36 #include "dbus-message-private.h"
37 #include "dbus-threads.h"
38 #include "dbus-protocol.h"
39 #include "dbus-dataslot.h"
40 #include "dbus-string.h"
41 #include "dbus-signature.h"
42 #include "dbus-pending-call.h"
43 #include "dbus-object-tree.h"
44 #include "dbus-threads-internal.h"
45 #include "dbus-bus.h"
46 #include "dbus-marshal-basic.h"
47 
48 #ifdef DBUS_DISABLE_CHECKS
49 #define TOOK_LOCK_CHECK(connection)
50 #define RELEASING_LOCK_CHECK(connection)
51 #define HAVE_LOCK_CHECK(connection)
52 #else
53 #define TOOK_LOCK_CHECK(connection) do { \
54  _dbus_assert (!(connection)->have_connection_lock); \
55  (connection)->have_connection_lock = TRUE; \
56  } while (0)
57 #define RELEASING_LOCK_CHECK(connection) do { \
58  _dbus_assert ((connection)->have_connection_lock); \
59  (connection)->have_connection_lock = FALSE; \
60  } while (0)
61 #define HAVE_LOCK_CHECK(connection) _dbus_assert ((connection)->have_connection_lock)
62 /* A "DO_NOT_HAVE_LOCK_CHECK" is impossible since we need the lock to check the flag */
63 #endif
64 
65 #define TRACE_LOCKS 1
66 
67 #define CONNECTION_LOCK(connection) do { \
68  if (TRACE_LOCKS) { _dbus_verbose ("LOCK\n"); } \
69  _dbus_rmutex_lock ((connection)->mutex); \
70  TOOK_LOCK_CHECK (connection); \
71  } while (0)
72 
73 #define CONNECTION_UNLOCK(connection) _dbus_connection_unlock (connection)
74 
75 #define SLOTS_LOCK(connection) do { \
76  _dbus_rmutex_lock ((connection)->slot_mutex); \
77  } while (0)
78 
79 #define SLOTS_UNLOCK(connection) do { \
80  _dbus_rmutex_unlock ((connection)->slot_mutex); \
81  } while (0)
82 
83 #define DISPATCH_STATUS_NAME(s) \
84  ((s) == DBUS_DISPATCH_COMPLETE ? "complete" : \
85  (s) == DBUS_DISPATCH_DATA_REMAINS ? "data remains" : \
86  (s) == DBUS_DISPATCH_NEED_MEMORY ? "need memory" : \
87  "???")
88 
206 #ifdef DBUS_ENABLE_VERBOSE_MODE
207 static void
208 _dbus_connection_trace_ref (DBusConnection *connection,
209  int old_refcount,
210  int new_refcount,
211  const char *why)
212 {
213  static int enabled = -1;
214 
215  _dbus_trace_ref ("DBusConnection", connection, old_refcount, new_refcount,
216  why, "DBUS_CONNECTION_TRACE", &enabled);
217 }
218 #else
219 #define _dbus_connection_trace_ref(c,o,n,w) \
220  do \
221  {\
222  (void) (o); \
223  (void) (n); \
224  } while (0)
225 #endif
226 
231 
236 {
239  void *user_data;
241 };
242 
243 
248 {
252 };
253 
254 #if HAVE_DECL_MSG_NOSIGNAL
255 static dbus_bool_t _dbus_modify_sigpipe = FALSE;
256 #else
257 static dbus_bool_t _dbus_modify_sigpipe = TRUE;
258 #endif
259 
264 {
313  char *server_guid;
315  /* These two MUST be bools and not bitfields, because they are protected by a separate lock
316  * from connection->mutex and all bitfields in a word have to be read/written together.
317  * So you can't have a different lock for different bitfields in the same word.
318  */
322  unsigned int shareable : 1;
324  unsigned int exit_on_disconnect : 1;
326  unsigned int route_peer_messages : 1;
328  unsigned int disconnected_message_arrived : 1;
336 #ifndef DBUS_DISABLE_CHECKS
337  unsigned int have_connection_lock : 1;
338 #endif
339 
340 #ifndef DBUS_DISABLE_CHECKS
342 #endif
343 };
344 
345 static DBusDispatchStatus _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection);
346 static void _dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection,
347  DBusDispatchStatus new_status);
348 static void _dbus_connection_last_unref (DBusConnection *connection);
349 static void _dbus_connection_acquire_dispatch (DBusConnection *connection);
350 static void _dbus_connection_release_dispatch (DBusConnection *connection);
351 static DBusDispatchStatus _dbus_connection_flush_unlocked (DBusConnection *connection);
352 static void _dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection);
353 static dbus_bool_t _dbus_connection_get_is_connected_unlocked (DBusConnection *connection);
354 static dbus_bool_t _dbus_connection_peek_for_reply_unlocked (DBusConnection *connection,
355  dbus_uint32_t client_serial);
356 
357 static DBusMessageFilter *
358 _dbus_message_filter_ref (DBusMessageFilter *filter)
359 {
360 #ifdef DBUS_DISABLE_ASSERT
361  _dbus_atomic_inc (&filter->refcount);
362 #else
363  dbus_int32_t old_value;
364 
365  old_value = _dbus_atomic_inc (&filter->refcount);
366  _dbus_assert (old_value > 0);
367 #endif
368 
369  return filter;
370 }
371 
372 static void
373 _dbus_message_filter_unref (DBusMessageFilter *filter)
374 {
375  dbus_int32_t old_value;
376 
377  old_value = _dbus_atomic_dec (&filter->refcount);
378  _dbus_assert (old_value > 0);
379 
380  if (old_value == 1)
381  {
382  if (filter->free_user_data_function)
383  (* filter->free_user_data_function) (filter->user_data);
384 
385  dbus_free (filter);
386  }
387 }
388 
394 void
396 {
397  CONNECTION_LOCK (connection);
398 }
399 
405 void
407 {
408  DBusList *expired_messages;
409  DBusList *iter;
410 
411  if (TRACE_LOCKS)
412  {
413  _dbus_verbose ("UNLOCK\n");
414  }
415 
416  /* If we had messages that expired (fell off the incoming or outgoing
417  * queues) while we were locked, actually release them now */
418  expired_messages = connection->expired_messages;
419  connection->expired_messages = NULL;
420 
421  RELEASING_LOCK_CHECK (connection);
422  _dbus_rmutex_unlock (connection->mutex);
423 
424  for (iter = _dbus_list_pop_first_link (&expired_messages);
425  iter != NULL;
426  iter = _dbus_list_pop_first_link (&expired_messages))
427  {
428  DBusMessage *message = iter->data;
429 
430  dbus_message_unref (message);
431  _dbus_list_free_link (iter);
432  }
433 }
434 
442 static void
443 _dbus_connection_wakeup_mainloop (DBusConnection *connection)
444 {
445  if (connection->wakeup_main_function)
446  (*connection->wakeup_main_function) (connection->wakeup_main_data);
447 }
448 
449 #ifdef DBUS_BUILD_TESTS
450 
462 void
463 _dbus_connection_test_get_locks (DBusConnection *connection,
464  DBusMutex **mutex_loc,
465  DBusMutex **dispatch_mutex_loc,
466  DBusMutex **io_path_mutex_loc,
467  DBusCondVar **dispatch_cond_loc,
468  DBusCondVar **io_path_cond_loc)
469 {
470  *mutex_loc = (DBusMutex *) connection->mutex;
471  *dispatch_mutex_loc = (DBusMutex *) connection->dispatch_mutex;
472  *io_path_mutex_loc = (DBusMutex *) connection->io_path_mutex;
473  *dispatch_cond_loc = connection->dispatch_cond;
474  *io_path_cond_loc = connection->io_path_cond;
475 }
476 #endif
477 
486 void
488  DBusList *link)
489 {
490  DBusPendingCall *pending;
491  dbus_uint32_t reply_serial;
492  DBusMessage *message;
493 
495 
497  link);
498  message = link->data;
499 
500  /* If this is a reply we're waiting on, remove timeout for it */
501  reply_serial = dbus_message_get_reply_serial (message);
502  if (reply_serial != 0)
503  {
504  pending = _dbus_hash_table_lookup_int (connection->pending_replies,
505  reply_serial);
506  if (pending != NULL)
507  {
511 
513  }
514  }
515 
516 
517 
518  connection->n_incoming += 1;
519 
520  _dbus_connection_wakeup_mainloop (connection);
521 
522  _dbus_verbose ("Message %p (%s %s %s %s '%s' reply to %u) added to incoming queue %p, %d incoming\n",
523  message,
525  dbus_message_get_path (message) ?
526  dbus_message_get_path (message) :
527  "no path",
528  dbus_message_get_interface (message) ?
529  dbus_message_get_interface (message) :
530  "no interface",
531  dbus_message_get_member (message) ?
532  dbus_message_get_member (message) :
533  "no member",
534  dbus_message_get_signature (message),
536  connection,
537  connection->n_incoming);
538 
539  _dbus_message_trace_ref (message, -1, -1,
540  "_dbus_conection_queue_received_message_link");
541 }
542 
551 void
553  DBusList *link)
554 {
555  HAVE_LOCK_CHECK (connection);
556 
557  _dbus_list_append_link (&connection->incoming_messages, link);
558 
559  connection->n_incoming += 1;
560 
561  _dbus_connection_wakeup_mainloop (connection);
562 
563  _dbus_message_trace_ref (link->data, -1, -1,
564  "_dbus_connection_queue_synthesized_message_link");
565 
566  _dbus_verbose ("Synthesized message %p added to incoming queue %p, %d incoming\n",
567  link->data, connection, connection->n_incoming);
568 }
569 
570 
580 {
581  HAVE_LOCK_CHECK (connection);
582  return connection->outgoing_messages != NULL;
583 }
584 
596 {
597  dbus_bool_t v;
598 
599  _dbus_return_val_if_fail (connection != NULL, FALSE);
600 
601  CONNECTION_LOCK (connection);
603  CONNECTION_UNLOCK (connection);
604 
605  return v;
606 }
607 
617 {
618  HAVE_LOCK_CHECK (connection);
619 
620  return _dbus_list_get_last (&connection->outgoing_messages);
621 }
622 
631 void
633  DBusMessage *message)
634 {
635  DBusList *link;
636 
637  HAVE_LOCK_CHECK (connection);
638 
639  /* This can be called before we even complete authentication, since
640  * it's called on disconnect to clean up the outgoing queue.
641  * It's also called as we successfully send each message.
642  */
643 
644  link = _dbus_list_get_last_link (&connection->outgoing_messages);
645  _dbus_assert (link != NULL);
646  _dbus_assert (link->data == message);
647 
648  _dbus_list_unlink (&connection->outgoing_messages,
649  link);
650  _dbus_list_prepend_link (&connection->expired_messages, link);
651 
652  connection->n_outgoing -= 1;
653 
654  _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from outgoing queue %p, %d left to send\n",
655  message,
657  dbus_message_get_path (message) ?
658  dbus_message_get_path (message) :
659  "no path",
660  dbus_message_get_interface (message) ?
661  dbus_message_get_interface (message) :
662  "no interface",
663  dbus_message_get_member (message) ?
664  dbus_message_get_member (message) :
665  "no member",
666  dbus_message_get_signature (message),
667  connection, connection->n_outgoing);
668 
669  /* It's OK that in principle we call the notify function, because for the
670  * outgoing limit, there isn't one */
671  _dbus_message_remove_counter (message, connection->outgoing_counter);
672 
673  /* The message will actually be unreffed when we unlock */
674 }
675 
678  DBusWatch *watch);
680 typedef void (* DBusWatchRemoveFunction) (DBusWatchList *list,
681  DBusWatch *watch);
683 typedef void (* DBusWatchToggleFunction) (DBusWatchList *list,
684  DBusWatch *watch,
685  dbus_bool_t enabled);
686 
687 static dbus_bool_t
688 protected_change_watch (DBusConnection *connection,
689  DBusWatch *watch,
690  DBusWatchAddFunction add_function,
691  DBusWatchRemoveFunction remove_function,
692  DBusWatchToggleFunction toggle_function,
693  dbus_bool_t enabled)
694 {
695  dbus_bool_t retval;
696 
697  HAVE_LOCK_CHECK (connection);
698 
699  /* The original purpose of protected_change_watch() was to hold a
700  * ref on the connection while dropping the connection lock, then
701  * calling out to the app. This was a broken hack that did not
702  * work, since the connection was in a hosed state (no WatchList
703  * field) while calling out.
704  *
705  * So for now we'll just keep the lock while calling out. This means
706  * apps are not allowed to call DBusConnection methods inside a
707  * watch function or they will deadlock.
708  *
709  * The "real fix" is to use the _and_unlock() pattern found
710  * elsewhere in the code, to defer calling out to the app until
711  * we're about to drop locks and return flow of control to the app
712  * anyway.
713  *
714  * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144
715  */
716 
717  if (connection->watches)
718  {
719  if (add_function)
720  retval = (* add_function) (connection->watches, watch);
721  else if (remove_function)
722  {
723  retval = TRUE;
724  (* remove_function) (connection->watches, watch);
725  }
726  else
727  {
728  retval = TRUE;
729  (* toggle_function) (connection->watches, watch, enabled);
730  }
731  return retval;
732  }
733  else
734  return FALSE;
735 }
736 
737 
751  DBusWatch *watch)
752 {
753  return protected_change_watch (connection, watch,
755  NULL, NULL, FALSE);
756 }
757 
767 void
769  DBusWatch *watch)
770 {
771  protected_change_watch (connection, watch,
772  NULL,
774  NULL, FALSE);
775 }
776 
787 void
789  DBusWatch *watch,
790  dbus_bool_t enabled)
791 {
792  _dbus_assert (watch != NULL);
793 
794  protected_change_watch (connection, watch,
795  NULL, NULL,
797  enabled);
798 }
799 
802  DBusTimeout *timeout);
805  DBusTimeout *timeout);
808  DBusTimeout *timeout,
809  dbus_bool_t enabled);
810 
811 static dbus_bool_t
812 protected_change_timeout (DBusConnection *connection,
813  DBusTimeout *timeout,
814  DBusTimeoutAddFunction add_function,
815  DBusTimeoutRemoveFunction remove_function,
816  DBusTimeoutToggleFunction toggle_function,
817  dbus_bool_t enabled)
818 {
819  dbus_bool_t retval;
820 
821  HAVE_LOCK_CHECK (connection);
822 
823  /* The original purpose of protected_change_timeout() was to hold a
824  * ref on the connection while dropping the connection lock, then
825  * calling out to the app. This was a broken hack that did not
826  * work, since the connection was in a hosed state (no TimeoutList
827  * field) while calling out.
828  *
829  * So for now we'll just keep the lock while calling out. This means
830  * apps are not allowed to call DBusConnection methods inside a
831  * timeout function or they will deadlock.
832  *
833  * The "real fix" is to use the _and_unlock() pattern found
834  * elsewhere in the code, to defer calling out to the app until
835  * we're about to drop locks and return flow of control to the app
836  * anyway.
837  *
838  * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144
839  */
840 
841  if (connection->timeouts)
842  {
843  if (add_function)
844  retval = (* add_function) (connection->timeouts, timeout);
845  else if (remove_function)
846  {
847  retval = TRUE;
848  (* remove_function) (connection->timeouts, timeout);
849  }
850  else
851  {
852  retval = TRUE;
853  (* toggle_function) (connection->timeouts, timeout, enabled);
854  }
855  return retval;
856  }
857  else
858  return FALSE;
859 }
860 
875  DBusTimeout *timeout)
876 {
877  return protected_change_timeout (connection, timeout,
879  NULL, NULL, FALSE);
880 }
881 
891 void
893  DBusTimeout *timeout)
894 {
895  protected_change_timeout (connection, timeout,
896  NULL,
898  NULL, FALSE);
899 }
900 
911 void
913  DBusTimeout *timeout,
914  dbus_bool_t enabled)
915 {
916  protected_change_timeout (connection, timeout,
917  NULL, NULL,
919  enabled);
920 }
921 
922 static dbus_bool_t
923 _dbus_connection_attach_pending_call_unlocked (DBusConnection *connection,
924  DBusPendingCall *pending)
925 {
926  dbus_uint32_t reply_serial;
927  DBusTimeout *timeout;
928 
929  HAVE_LOCK_CHECK (connection);
930 
931  reply_serial = _dbus_pending_call_get_reply_serial_unlocked (pending);
932 
933  _dbus_assert (reply_serial != 0);
934 
935  timeout = _dbus_pending_call_get_timeout_unlocked (pending);
936 
937  if (timeout)
938  {
939  if (!_dbus_connection_add_timeout_unlocked (connection, timeout))
940  return FALSE;
941 
943  reply_serial,
944  pending))
945  {
946  _dbus_connection_remove_timeout_unlocked (connection, timeout);
947 
949  HAVE_LOCK_CHECK (connection);
950  return FALSE;
951  }
952 
954  }
955  else
956  {
958  reply_serial,
959  pending))
960  {
961  HAVE_LOCK_CHECK (connection);
962  return FALSE;
963  }
964  }
965 
967 
968  HAVE_LOCK_CHECK (connection);
969 
970  return TRUE;
971 }
972 
973 static void
974 free_pending_call_on_hash_removal (void *data)
975 {
976  DBusPendingCall *pending;
977  DBusConnection *connection;
978 
979  if (data == NULL)
980  return;
981 
982  pending = data;
983 
984  connection = _dbus_pending_call_get_connection_unlocked (pending);
985 
986  HAVE_LOCK_CHECK (connection);
987 
989  {
992 
994  }
995 
996  /* FIXME 1.0? this is sort of dangerous and undesirable to drop the lock
997  * here, but the pending call finalizer could in principle call out to
998  * application code so we pretty much have to... some larger code reorg
999  * might be needed.
1000  */
1001  _dbus_connection_ref_unlocked (connection);
1003  CONNECTION_LOCK (connection);
1004  _dbus_connection_unref_unlocked (connection);
1005 }
1006 
1007 static void
1008 _dbus_connection_detach_pending_call_unlocked (DBusConnection *connection,
1009  DBusPendingCall *pending)
1010 {
1011  /* This ends up unlocking to call the pending call finalizer, which is unexpected to
1012  * say the least.
1013  */
1016 }
1017 
1018 static void
1019 _dbus_connection_detach_pending_call_and_unlock (DBusConnection *connection,
1020  DBusPendingCall *pending)
1021 {
1022  /* The idea here is to avoid finalizing the pending call
1023  * with the lock held, since there's a destroy notifier
1024  * in pending call that goes out to application code.
1025  *
1026  * There's an extra unlock inside the hash table
1027  * "free pending call" function FIXME...
1028  */
1032 
1036 
1038 
1040 }
1041 
1050 void
1052  DBusPendingCall *pending)
1053 {
1054  CONNECTION_LOCK (connection);
1055  _dbus_connection_detach_pending_call_and_unlock (connection, pending);
1056 }
1057 
1067 static dbus_bool_t
1068 _dbus_connection_acquire_io_path (DBusConnection *connection,
1069  int timeout_milliseconds)
1070 {
1071  dbus_bool_t we_acquired;
1072 
1073  HAVE_LOCK_CHECK (connection);
1074 
1075  /* We don't want the connection to vanish */
1076  _dbus_connection_ref_unlocked (connection);
1077 
1078  /* We will only touch io_path_acquired which is protected by our mutex */
1079  CONNECTION_UNLOCK (connection);
1080 
1081  _dbus_verbose ("locking io_path_mutex\n");
1082  _dbus_cmutex_lock (connection->io_path_mutex);
1083 
1084  _dbus_verbose ("start connection->io_path_acquired = %d timeout = %d\n",
1085  connection->io_path_acquired, timeout_milliseconds);
1086 
1087  we_acquired = FALSE;
1088 
1089  if (connection->io_path_acquired)
1090  {
1091  if (timeout_milliseconds != -1)
1092  {
1093  _dbus_verbose ("waiting %d for IO path to be acquirable\n",
1094  timeout_milliseconds);
1095 
1096  if (!_dbus_condvar_wait_timeout (connection->io_path_cond,
1097  connection->io_path_mutex,
1098  timeout_milliseconds))
1099  {
1100  /* We timed out before anyone signaled. */
1101  /* (writing the loop to handle the !timedout case by
1102  * waiting longer if needed is a pain since dbus
1103  * wraps pthread_cond_timedwait to take a relative
1104  * time instead of absolute, something kind of stupid
1105  * on our part. for now it doesn't matter, we will just
1106  * end up back here eventually.)
1107  */
1108  }
1109  }
1110  else
1111  {
1112  while (connection->io_path_acquired)
1113  {
1114  _dbus_verbose ("waiting for IO path to be acquirable\n");
1115  _dbus_condvar_wait (connection->io_path_cond,
1116  connection->io_path_mutex);
1117  }
1118  }
1119  }
1120 
1121  if (!connection->io_path_acquired)
1122  {
1123  we_acquired = TRUE;
1124  connection->io_path_acquired = TRUE;
1125  }
1126 
1127  _dbus_verbose ("end connection->io_path_acquired = %d we_acquired = %d\n",
1128  connection->io_path_acquired, we_acquired);
1129 
1130  _dbus_verbose ("unlocking io_path_mutex\n");
1131  _dbus_cmutex_unlock (connection->io_path_mutex);
1132 
1133  CONNECTION_LOCK (connection);
1134 
1135  HAVE_LOCK_CHECK (connection);
1136 
1137  _dbus_connection_unref_unlocked (connection);
1138 
1139  return we_acquired;
1140 }
1141 
1149 static void
1150 _dbus_connection_release_io_path (DBusConnection *connection)
1151 {
1152  HAVE_LOCK_CHECK (connection);
1153 
1154  _dbus_verbose ("locking io_path_mutex\n");
1155  _dbus_cmutex_lock (connection->io_path_mutex);
1156 
1157  _dbus_assert (connection->io_path_acquired);
1158 
1159  _dbus_verbose ("start connection->io_path_acquired = %d\n",
1160  connection->io_path_acquired);
1161 
1162  connection->io_path_acquired = FALSE;
1163  _dbus_condvar_wake_one (connection->io_path_cond);
1164 
1165  _dbus_verbose ("unlocking io_path_mutex\n");
1166  _dbus_cmutex_unlock (connection->io_path_mutex);
1167 }
1168 
1204 void
1206  DBusPendingCall *pending,
1207  unsigned int flags,
1208  int timeout_milliseconds)
1209 {
1210  _dbus_verbose ("start\n");
1211 
1212  HAVE_LOCK_CHECK (connection);
1213 
1214  if (connection->n_outgoing == 0)
1215  flags &= ~DBUS_ITERATION_DO_WRITING;
1216 
1217  if (_dbus_connection_acquire_io_path (connection,
1218  (flags & DBUS_ITERATION_BLOCK) ? timeout_milliseconds : 0))
1219  {
1220  HAVE_LOCK_CHECK (connection);
1221 
1222  if ( (pending != NULL) && _dbus_pending_call_get_completed_unlocked(pending))
1223  {
1224  _dbus_verbose ("pending call completed while acquiring I/O path");
1225  }
1226  else if ( (pending != NULL) &&
1227  _dbus_connection_peek_for_reply_unlocked (connection,
1229  {
1230  _dbus_verbose ("pending call completed while acquiring I/O path (reply found in queue)");
1231  }
1232  else
1233  {
1235  flags, timeout_milliseconds);
1236  }
1237 
1238  _dbus_connection_release_io_path (connection);
1239  }
1240 
1241  HAVE_LOCK_CHECK (connection);
1242 
1243  _dbus_verbose ("end\n");
1244 }
1245 
1257 {
1258  DBusConnection *connection;
1259  DBusWatchList *watch_list;
1260  DBusTimeoutList *timeout_list;
1261  DBusHashTable *pending_replies;
1262  DBusList *disconnect_link;
1263  DBusMessage *disconnect_message;
1264  DBusCounter *outgoing_counter;
1265  DBusObjectTree *objects;
1266 
1267  watch_list = NULL;
1268  connection = NULL;
1269  pending_replies = NULL;
1270  timeout_list = NULL;
1271  disconnect_link = NULL;
1272  disconnect_message = NULL;
1273  outgoing_counter = NULL;
1274  objects = NULL;
1275 
1276  watch_list = _dbus_watch_list_new ();
1277  if (watch_list == NULL)
1278  goto error;
1279 
1280  timeout_list = _dbus_timeout_list_new ();
1281  if (timeout_list == NULL)
1282  goto error;
1283 
1284  pending_replies =
1286  NULL,
1287  (DBusFreeFunction)free_pending_call_on_hash_removal);
1288  if (pending_replies == NULL)
1289  goto error;
1290 
1291  connection = dbus_new0 (DBusConnection, 1);
1292  if (connection == NULL)
1293  goto error;
1294 
1295  _dbus_rmutex_new_at_location (&connection->mutex);
1296  if (connection->mutex == NULL)
1297  goto error;
1298 
1300  if (connection->io_path_mutex == NULL)
1301  goto error;
1302 
1304  if (connection->dispatch_mutex == NULL)
1305  goto error;
1306 
1308  if (connection->dispatch_cond == NULL)
1309  goto error;
1310 
1312  if (connection->io_path_cond == NULL)
1313  goto error;
1314 
1316  if (connection->slot_mutex == NULL)
1317  goto error;
1318 
1319  disconnect_message = dbus_message_new_signal (DBUS_PATH_LOCAL,
1321  "Disconnected");
1322 
1323  if (disconnect_message == NULL)
1324  goto error;
1325 
1326  disconnect_link = _dbus_list_alloc_link (disconnect_message);
1327  if (disconnect_link == NULL)
1328  goto error;
1329 
1330  outgoing_counter = _dbus_counter_new ();
1331  if (outgoing_counter == NULL)
1332  goto error;
1333 
1334  objects = _dbus_object_tree_new (connection);
1335  if (objects == NULL)
1336  goto error;
1337 
1338  if (_dbus_modify_sigpipe)
1340 
1341  /* initialized to 0: use atomic op to avoid mixing atomic and non-atomic */
1342  _dbus_atomic_inc (&connection->refcount);
1343  connection->transport = transport;
1344  connection->watches = watch_list;
1345  connection->timeouts = timeout_list;
1346  connection->pending_replies = pending_replies;
1347  connection->outgoing_counter = outgoing_counter;
1348  connection->filter_list = NULL;
1349  connection->last_dispatch_status = DBUS_DISPATCH_COMPLETE; /* so we're notified first time there's data */
1350  connection->objects = objects;
1351  connection->exit_on_disconnect = FALSE;
1352  connection->shareable = FALSE;
1353  connection->route_peer_messages = FALSE;
1354  connection->disconnected_message_arrived = FALSE;
1355  connection->disconnected_message_processed = FALSE;
1356 
1357 #ifndef DBUS_DISABLE_CHECKS
1358  connection->generation = _dbus_current_generation;
1359 #endif
1360 
1361  _dbus_data_slot_list_init (&connection->slot_list);
1362 
1363  connection->client_serial = 1;
1364 
1365  connection->disconnect_message_link = disconnect_link;
1366 
1367  CONNECTION_LOCK (connection);
1368 
1369  if (!_dbus_transport_set_connection (transport, connection))
1370  {
1371  CONNECTION_UNLOCK (connection);
1372 
1373  goto error;
1374  }
1375 
1376  _dbus_transport_ref (transport);
1377 
1378  CONNECTION_UNLOCK (connection);
1379 
1380  _dbus_connection_trace_ref (connection, 0, 1, "new_for_transport");
1381  return connection;
1382 
1383  error:
1384  if (disconnect_message != NULL)
1385  dbus_message_unref (disconnect_message);
1386 
1387  if (disconnect_link != NULL)
1388  _dbus_list_free_link (disconnect_link);
1389 
1390  if (connection != NULL)
1391  {
1394  _dbus_rmutex_free_at_location (&connection->mutex);
1398  dbus_free (connection);
1399  }
1400  if (pending_replies)
1401  _dbus_hash_table_unref (pending_replies);
1402 
1403  if (watch_list)
1404  _dbus_watch_list_free (watch_list);
1405 
1406  if (timeout_list)
1407  _dbus_timeout_list_free (timeout_list);
1408 
1409  if (outgoing_counter)
1410  _dbus_counter_unref (outgoing_counter);
1411 
1412  if (objects)
1413  _dbus_object_tree_unref (objects);
1414 
1415  return NULL;
1416 }
1417 
1427 {
1428  dbus_int32_t old_refcount;
1429 
1430  _dbus_assert (connection != NULL);
1432 
1433  HAVE_LOCK_CHECK (connection);
1434 
1435  old_refcount = _dbus_atomic_inc (&connection->refcount);
1436  _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
1437  "ref_unlocked");
1438 
1439  return connection;
1440 }
1441 
1448 void
1450 {
1451  dbus_int32_t old_refcount;
1452 
1453  HAVE_LOCK_CHECK (connection);
1454 
1455  _dbus_assert (connection != NULL);
1456 
1457  old_refcount = _dbus_atomic_dec (&connection->refcount);
1458 
1459  _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
1460  "unref_unlocked");
1461 
1462  if (old_refcount == 1)
1463  _dbus_connection_last_unref (connection);
1464 }
1465 
1466 static dbus_uint32_t
1467 _dbus_connection_get_next_client_serial (DBusConnection *connection)
1468 {
1469  dbus_uint32_t serial;
1470 
1471  serial = connection->client_serial++;
1472 
1473  if (connection->client_serial == 0)
1474  connection->client_serial = 1;
1475 
1476  return serial;
1477 }
1478 
1494  unsigned int condition,
1495  void *data)
1496 {
1497  DBusConnection *connection;
1498  dbus_bool_t retval;
1499  DBusDispatchStatus status;
1500 
1501  connection = data;
1502 
1503  _dbus_verbose ("start\n");
1504 
1505  CONNECTION_LOCK (connection);
1506 
1507  if (!_dbus_connection_acquire_io_path (connection, 1))
1508  {
1509  /* another thread is handling the message */
1510  CONNECTION_UNLOCK (connection);
1511  return TRUE;
1512  }
1513 
1514  HAVE_LOCK_CHECK (connection);
1515  retval = _dbus_transport_handle_watch (connection->transport,
1516  watch, condition);
1517 
1518  _dbus_connection_release_io_path (connection);
1519 
1520  HAVE_LOCK_CHECK (connection);
1521 
1522  _dbus_verbose ("middle\n");
1523 
1524  status = _dbus_connection_get_dispatch_status_unlocked (connection);
1525 
1526  /* this calls out to user code */
1527  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
1528 
1529  _dbus_verbose ("end\n");
1530 
1531  return retval;
1532 }
1533 
1534 _DBUS_DEFINE_GLOBAL_LOCK (shared_connections);
1535 static DBusHashTable *shared_connections = NULL;
1536 static DBusList *shared_connections_no_guid = NULL;
1537 
1538 static void
1539 close_connection_on_shutdown (DBusConnection *connection)
1540 {
1541  DBusMessage *message;
1542 
1543  dbus_connection_ref (connection);
1545 
1546  /* Churn through to the Disconnected message */
1547  while ((message = dbus_connection_pop_message (connection)))
1548  {
1549  dbus_message_unref (message);
1550  }
1551  dbus_connection_unref (connection);
1552 }
1553 
1554 static void
1555 shared_connections_shutdown (void *data)
1556 {
1557  int n_entries;
1558 
1559  _DBUS_LOCK (shared_connections);
1560 
1561  /* This is a little bit unpleasant... better ideas? */
1562  while ((n_entries = _dbus_hash_table_get_n_entries (shared_connections)) > 0)
1563  {
1564  DBusConnection *connection;
1565  DBusHashIter iter;
1566 
1567  _dbus_hash_iter_init (shared_connections, &iter);
1568  _dbus_hash_iter_next (&iter);
1569 
1570  connection = _dbus_hash_iter_get_value (&iter);
1571 
1572  _DBUS_UNLOCK (shared_connections);
1573  close_connection_on_shutdown (connection);
1574  _DBUS_LOCK (shared_connections);
1575 
1576  /* The connection should now be dead and not in our hash ... */
1577  _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) < n_entries);
1578  }
1579 
1580  _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) == 0);
1581 
1582  _dbus_hash_table_unref (shared_connections);
1583  shared_connections = NULL;
1584 
1585  if (shared_connections_no_guid != NULL)
1586  {
1587  DBusConnection *connection;
1588  connection = _dbus_list_pop_first (&shared_connections_no_guid);
1589  while (connection != NULL)
1590  {
1591  _DBUS_UNLOCK (shared_connections);
1592  close_connection_on_shutdown (connection);
1593  _DBUS_LOCK (shared_connections);
1594  connection = _dbus_list_pop_first (&shared_connections_no_guid);
1595  }
1596  }
1597 
1598  shared_connections_no_guid = NULL;
1599 
1600  _DBUS_UNLOCK (shared_connections);
1601 }
1602 
1603 static dbus_bool_t
1604 connection_lookup_shared (DBusAddressEntry *entry,
1605  DBusConnection **result)
1606 {
1607  _dbus_verbose ("checking for existing connection\n");
1608 
1609  *result = NULL;
1610 
1611  _DBUS_LOCK (shared_connections);
1612 
1613  if (shared_connections == NULL)
1614  {
1615  _dbus_verbose ("creating shared_connections hash table\n");
1616 
1617  shared_connections = _dbus_hash_table_new (DBUS_HASH_STRING,
1618  dbus_free,
1619  NULL);
1620  if (shared_connections == NULL)
1621  {
1622  _DBUS_UNLOCK (shared_connections);
1623  return FALSE;
1624  }
1625 
1626  if (!_dbus_register_shutdown_func (shared_connections_shutdown, NULL))
1627  {
1628  _dbus_hash_table_unref (shared_connections);
1629  shared_connections = NULL;
1630  _DBUS_UNLOCK (shared_connections);
1631  return FALSE;
1632  }
1633 
1634  _dbus_verbose (" successfully created shared_connections\n");
1635 
1636  _DBUS_UNLOCK (shared_connections);
1637  return TRUE; /* no point looking up in the hash we just made */
1638  }
1639  else
1640  {
1641  const char *guid;
1642 
1643  guid = dbus_address_entry_get_value (entry, "guid");
1644 
1645  if (guid != NULL)
1646  {
1647  DBusConnection *connection;
1648 
1649  connection = _dbus_hash_table_lookup_string (shared_connections,
1650  guid);
1651 
1652  if (connection)
1653  {
1654  /* The DBusConnection can't be finalized without taking
1655  * the shared_connections lock to remove it from the
1656  * hash. So it's safe to ref the connection here.
1657  * However, it may be disconnected if the Disconnected
1658  * message hasn't been processed yet, in which case we
1659  * want to pretend it isn't in the hash and avoid
1660  * returning it.
1661  *
1662  * The idea is to avoid ever returning a disconnected connection
1663  * from dbus_connection_open(). We could just synchronously
1664  * drop our shared ref to the connection on connection disconnect,
1665  * and then assert here that the connection is connected, but
1666  * that causes reentrancy headaches.
1667  */
1668  CONNECTION_LOCK (connection);
1669  if (_dbus_connection_get_is_connected_unlocked (connection))
1670  {
1671  _dbus_connection_ref_unlocked (connection);
1672  *result = connection;
1673  _dbus_verbose ("looked up existing connection to server guid %s\n",
1674  guid);
1675  }
1676  else
1677  {
1678  _dbus_verbose ("looked up existing connection to server guid %s but it was disconnected so ignoring it\n",
1679  guid);
1680  }
1681  CONNECTION_UNLOCK (connection);
1682  }
1683  }
1684 
1685  _DBUS_UNLOCK (shared_connections);
1686  return TRUE;
1687  }
1688 }
1689 
1690 static dbus_bool_t
1691 connection_record_shared_unlocked (DBusConnection *connection,
1692  const char *guid)
1693 {
1694  char *guid_key;
1695  char *guid_in_connection;
1696 
1697  HAVE_LOCK_CHECK (connection);
1698  _dbus_assert (connection->server_guid == NULL);
1699  _dbus_assert (connection->shareable);
1700 
1701  /* get a hard ref on this connection, even if
1702  * we won't in fact store it in the hash, we still
1703  * need to hold a ref on it until it's disconnected.
1704  */
1705  _dbus_connection_ref_unlocked (connection);
1706 
1707  if (guid == NULL)
1708  {
1709  _DBUS_LOCK (shared_connections);
1710 
1711  if (!_dbus_list_prepend (&shared_connections_no_guid, connection))
1712  {
1713  _DBUS_UNLOCK (shared_connections);
1714  return FALSE;
1715  }
1716 
1717  _DBUS_UNLOCK (shared_connections);
1718  return TRUE; /* don't store in the hash */
1719  }
1720 
1721  /* A separate copy of the key is required in the hash table, because
1722  * we don't have a lock on the connection when we are doing a hash
1723  * lookup.
1724  */
1725 
1726  guid_key = _dbus_strdup (guid);
1727  if (guid_key == NULL)
1728  return FALSE;
1729 
1730  guid_in_connection = _dbus_strdup (guid);
1731  if (guid_in_connection == NULL)
1732  {
1733  dbus_free (guid_key);
1734  return FALSE;
1735  }
1736 
1737  _DBUS_LOCK (shared_connections);
1738  _dbus_assert (shared_connections != NULL);
1739 
1740  if (!_dbus_hash_table_insert_string (shared_connections,
1741  guid_key, connection))
1742  {
1743  dbus_free (guid_key);
1744  dbus_free (guid_in_connection);
1745  _DBUS_UNLOCK (shared_connections);
1746  return FALSE;
1747  }
1748 
1749  connection->server_guid = guid_in_connection;
1750 
1751  _dbus_verbose ("stored connection to %s to be shared\n",
1752  connection->server_guid);
1753 
1754  _DBUS_UNLOCK (shared_connections);
1755 
1756  _dbus_assert (connection->server_guid != NULL);
1757 
1758  return TRUE;
1759 }
1760 
1761 static void
1762 connection_forget_shared_unlocked (DBusConnection *connection)
1763 {
1764  HAVE_LOCK_CHECK (connection);
1765 
1766  if (!connection->shareable)
1767  return;
1768 
1769  _DBUS_LOCK (shared_connections);
1770 
1771  if (connection->server_guid != NULL)
1772  {
1773  _dbus_verbose ("dropping connection to %s out of the shared table\n",
1774  connection->server_guid);
1775 
1776  if (!_dbus_hash_table_remove_string (shared_connections,
1777  connection->server_guid))
1778  _dbus_assert_not_reached ("connection was not in the shared table");
1779 
1780  dbus_free (connection->server_guid);
1781  connection->server_guid = NULL;
1782  }
1783  else
1784  {
1785  _dbus_list_remove (&shared_connections_no_guid, connection);
1786  }
1787 
1788  _DBUS_UNLOCK (shared_connections);
1789 
1790  /* remove our reference held on all shareable connections */
1791  _dbus_connection_unref_unlocked (connection);
1792 }
1793 
1794 static DBusConnection*
1795 connection_try_from_address_entry (DBusAddressEntry *entry,
1796  DBusError *error)
1797 {
1798  DBusTransport *transport;
1799  DBusConnection *connection;
1800 
1801  transport = _dbus_transport_open (entry, error);
1802 
1803  if (transport == NULL)
1804  {
1805  _DBUS_ASSERT_ERROR_IS_SET (error);
1806  return NULL;
1807  }
1808 
1809  connection = _dbus_connection_new_for_transport (transport);
1810 
1811  _dbus_transport_unref (transport);
1812 
1813  if (connection == NULL)
1814  {
1815  _DBUS_SET_OOM (error);
1816  return NULL;
1817  }
1818 
1819 #ifndef DBUS_DISABLE_CHECKS
1820  _dbus_assert (!connection->have_connection_lock);
1821 #endif
1822  return connection;
1823 }
1824 
1825 /*
1826  * If the shared parameter is true, then any existing connection will
1827  * be used (and if a new connection is created, it will be available
1828  * for use by others). If the shared parameter is false, a new
1829  * connection will always be created, and the new connection will
1830  * never be returned to other callers.
1831  *
1832  * @param address the address
1833  * @param shared whether the connection is shared or private
1834  * @param error error return
1835  * @returns the connection or #NULL on error
1836  */
1837 static DBusConnection*
1838 _dbus_connection_open_internal (const char *address,
1839  dbus_bool_t shared,
1840  DBusError *error)
1841 {
1842  DBusConnection *connection;
1843  DBusAddressEntry **entries;
1844  DBusError tmp_error = DBUS_ERROR_INIT;
1845  DBusError first_error = DBUS_ERROR_INIT;
1846  int len, i;
1847 
1848  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1849 
1850  _dbus_verbose ("opening %s connection to: %s\n",
1851  shared ? "shared" : "private", address);
1852 
1853  if (!dbus_parse_address (address, &entries, &len, error))
1854  return NULL;
1855 
1856  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1857 
1858  connection = NULL;
1859 
1860  for (i = 0; i < len; i++)
1861  {
1862  if (shared)
1863  {
1864  if (!connection_lookup_shared (entries[i], &connection))
1865  _DBUS_SET_OOM (&tmp_error);
1866  }
1867 
1868  if (connection == NULL)
1869  {
1870  connection = connection_try_from_address_entry (entries[i],
1871  &tmp_error);
1872 
1873  if (connection != NULL && shared)
1874  {
1875  const char *guid;
1876 
1877  connection->shareable = TRUE;
1878 
1879  /* guid may be NULL */
1880  guid = dbus_address_entry_get_value (entries[i], "guid");
1881 
1882  CONNECTION_LOCK (connection);
1883 
1884  if (!connection_record_shared_unlocked (connection, guid))
1885  {
1886  _DBUS_SET_OOM (&tmp_error);
1887  _dbus_connection_close_possibly_shared_and_unlock (connection);
1888  dbus_connection_unref (connection);
1889  connection = NULL;
1890  }
1891  else
1892  CONNECTION_UNLOCK (connection);
1893  }
1894  }
1895 
1896  if (connection)
1897  break;
1898 
1899  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
1900 
1901  if (i == 0)
1902  dbus_move_error (&tmp_error, &first_error);
1903  else
1904  dbus_error_free (&tmp_error);
1905  }
1906 
1907  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1908  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
1909 
1910  if (connection == NULL)
1911  {
1912  _DBUS_ASSERT_ERROR_IS_SET (&first_error);
1913  dbus_move_error (&first_error, error);
1914  }
1915  else
1916  dbus_error_free (&first_error);
1917 
1918  dbus_address_entries_free (entries);
1919  return connection;
1920 }
1921 
1930 void
1932 {
1933  _dbus_assert (connection != NULL);
1935 
1936  CONNECTION_LOCK (connection);
1937  _dbus_connection_close_possibly_shared_and_unlock (connection);
1938 }
1939 
1940 static DBusPreallocatedSend*
1941 _dbus_connection_preallocate_send_unlocked (DBusConnection *connection)
1942 {
1943  DBusPreallocatedSend *preallocated;
1944 
1945  HAVE_LOCK_CHECK (connection);
1946 
1947  _dbus_assert (connection != NULL);
1948 
1949  preallocated = dbus_new (DBusPreallocatedSend, 1);
1950  if (preallocated == NULL)
1951  return NULL;
1952 
1953  preallocated->queue_link = _dbus_list_alloc_link (NULL);
1954  if (preallocated->queue_link == NULL)
1955  goto failed_0;
1956 
1957  preallocated->counter_link = _dbus_list_alloc_link (connection->outgoing_counter);
1958  if (preallocated->counter_link == NULL)
1959  goto failed_1;
1960 
1961  _dbus_counter_ref (preallocated->counter_link->data);
1962 
1963  preallocated->connection = connection;
1964 
1965  return preallocated;
1966 
1967  failed_1:
1968  _dbus_list_free_link (preallocated->queue_link);
1969  failed_0:
1970  dbus_free (preallocated);
1971 
1972  return NULL;
1973 }
1974 
1975 /* Called with lock held, does not update dispatch status */
1976 static void
1977 _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *connection,
1978  DBusPreallocatedSend *preallocated,
1979  DBusMessage *message,
1980  dbus_uint32_t *client_serial)
1981 {
1982  dbus_uint32_t serial;
1983 
1984  preallocated->queue_link->data = message;
1986  preallocated->queue_link);
1987 
1988  /* It's OK that we'll never call the notify function, because for the
1989  * outgoing limit, there isn't one */
1991  preallocated->counter_link);
1992 
1993  dbus_free (preallocated);
1994  preallocated = NULL;
1995 
1996  dbus_message_ref (message);
1997 
1998  connection->n_outgoing += 1;
1999 
2000  _dbus_verbose ("Message %p (%s %s %s %s '%s') for %s added to outgoing queue %p, %d pending to send\n",
2001  message,
2003  dbus_message_get_path (message) ?
2004  dbus_message_get_path (message) :
2005  "no path",
2006  dbus_message_get_interface (message) ?
2007  dbus_message_get_interface (message) :
2008  "no interface",
2009  dbus_message_get_member (message) ?
2010  dbus_message_get_member (message) :
2011  "no member",
2012  dbus_message_get_signature (message),
2013  dbus_message_get_destination (message) ?
2014  dbus_message_get_destination (message) :
2015  "null",
2016  connection,
2017  connection->n_outgoing);
2018 
2019  if (dbus_message_get_serial (message) == 0)
2020  {
2021  serial = _dbus_connection_get_next_client_serial (connection);
2022  dbus_message_set_serial (message, serial);
2023  if (client_serial)
2024  *client_serial = serial;
2025  }
2026  else
2027  {
2028  if (client_serial)
2029  *client_serial = dbus_message_get_serial (message);
2030  }
2031 
2032  _dbus_verbose ("Message %p serial is %u\n",
2033  message, dbus_message_get_serial (message));
2034 
2035  dbus_message_lock (message);
2036 
2037  /* Now we need to run an iteration to hopefully just write the messages
2038  * out immediately, and otherwise get them queued up
2039  */
2041  NULL,
2042  DBUS_ITERATION_DO_WRITING,
2043  -1);
2044 
2045  /* If stuff is still queued up, be sure we wake up the main loop */
2046  if (connection->n_outgoing > 0)
2047  _dbus_connection_wakeup_mainloop (connection);
2048 }
2049 
2050 static void
2051 _dbus_connection_send_preallocated_and_unlock (DBusConnection *connection,
2052  DBusPreallocatedSend *preallocated,
2053  DBusMessage *message,
2054  dbus_uint32_t *client_serial)
2055 {
2056  DBusDispatchStatus status;
2057 
2058  HAVE_LOCK_CHECK (connection);
2059 
2060  _dbus_connection_send_preallocated_unlocked_no_update (connection,
2061  preallocated,
2062  message, client_serial);
2063 
2064  _dbus_verbose ("middle\n");
2065  status = _dbus_connection_get_dispatch_status_unlocked (connection);
2066 
2067  /* this calls out to user code */
2068  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2069 }
2070 
2082  DBusMessage *message,
2083  dbus_uint32_t *client_serial)
2084 {
2085  DBusPreallocatedSend *preallocated;
2086 
2087  _dbus_assert (connection != NULL);
2088  _dbus_assert (message != NULL);
2089 
2090  preallocated = _dbus_connection_preallocate_send_unlocked (connection);
2091  if (preallocated == NULL)
2092  {
2093  CONNECTION_UNLOCK (connection);
2094  return FALSE;
2095  }
2096 
2097  _dbus_connection_send_preallocated_and_unlock (connection,
2098  preallocated,
2099  message,
2100  client_serial);
2101  return TRUE;
2102 }
2103 
2128 void
2130 {
2131  dbus_int32_t refcount;
2132 
2133  CONNECTION_LOCK (connection);
2134 
2135  refcount = _dbus_atomic_get (&connection->refcount);
2136  /* The caller should have at least one ref */
2137  _dbus_assert (refcount >= 1);
2138 
2139  if (refcount == 1)
2140  _dbus_connection_close_possibly_shared_and_unlock (connection);
2141  else
2142  CONNECTION_UNLOCK (connection);
2143 }
2144 
2145 
2155 static void
2156 _dbus_memory_pause_based_on_timeout (int timeout_milliseconds)
2157 {
2158  if (timeout_milliseconds == -1)
2159  _dbus_sleep_milliseconds (1000);
2160  else if (timeout_milliseconds < 100)
2161  ; /* just busy loop */
2162  else if (timeout_milliseconds <= 1000)
2163  _dbus_sleep_milliseconds (timeout_milliseconds / 3);
2164  else
2165  _dbus_sleep_milliseconds (1000);
2166 }
2167 
2168 static DBusMessage *
2169 generate_local_error_message (dbus_uint32_t serial,
2170  char *error_name,
2171  char *error_msg)
2172 {
2173  DBusMessage *message;
2175  if (!message)
2176  goto out;
2177 
2178  if (!dbus_message_set_error_name (message, error_name))
2179  {
2180  dbus_message_unref (message);
2181  message = NULL;
2182  goto out;
2183  }
2184 
2185  dbus_message_set_no_reply (message, TRUE);
2186 
2187  if (!dbus_message_set_reply_serial (message,
2188  serial))
2189  {
2190  dbus_message_unref (message);
2191  message = NULL;
2192  goto out;
2193  }
2194 
2195  if (error_msg != NULL)
2196  {
2197  DBusMessageIter iter;
2198 
2199  dbus_message_iter_init_append (message, &iter);
2200  if (!dbus_message_iter_append_basic (&iter,
2202  &error_msg))
2203  {
2204  dbus_message_unref (message);
2205  message = NULL;
2206  goto out;
2207  }
2208  }
2209 
2210  out:
2211  return message;
2212 }
2213 
2214 /*
2215  * Peek the incoming queue to see if we got reply for a specific serial
2216  */
2217 static dbus_bool_t
2218 _dbus_connection_peek_for_reply_unlocked (DBusConnection *connection,
2219  dbus_uint32_t client_serial)
2220 {
2221  DBusList *link;
2222  HAVE_LOCK_CHECK (connection);
2223 
2224  link = _dbus_list_get_first_link (&connection->incoming_messages);
2225 
2226  while (link != NULL)
2227  {
2228  DBusMessage *reply = link->data;
2229 
2230  if (dbus_message_get_reply_serial (reply) == client_serial)
2231  {
2232  _dbus_verbose ("%s reply to %d found in queue\n", _DBUS_FUNCTION_NAME, client_serial);
2233  return TRUE;
2234  }
2235  link = _dbus_list_get_next_link (&connection->incoming_messages, link);
2236  }
2237 
2238  return FALSE;
2239 }
2240 
2241 /* This is slightly strange since we can pop a message here without
2242  * the dispatch lock.
2243  */
2244 static DBusMessage*
2245 check_for_reply_unlocked (DBusConnection *connection,
2246  dbus_uint32_t client_serial)
2247 {
2248  DBusList *link;
2249 
2250  HAVE_LOCK_CHECK (connection);
2251 
2252  link = _dbus_list_get_first_link (&connection->incoming_messages);
2253 
2254  while (link != NULL)
2255  {
2256  DBusMessage *reply = link->data;
2257 
2258  if (dbus_message_get_reply_serial (reply) == client_serial)
2259  {
2260  _dbus_list_remove_link (&connection->incoming_messages, link);
2261  connection->n_incoming -= 1;
2262  return reply;
2263  }
2264  link = _dbus_list_get_next_link (&connection->incoming_messages, link);
2265  }
2266 
2267  return NULL;
2268 }
2269 
2270 static void
2271 connection_timeout_and_complete_all_pending_calls_unlocked (DBusConnection *connection)
2272 {
2273  /* We can't iterate over the hash in the normal way since we'll be
2274  * dropping the lock for each item. So we restart the
2275  * iter each time as we drain the hash table.
2276  */
2277 
2278  while (_dbus_hash_table_get_n_entries (connection->pending_replies) > 0)
2279  {
2280  DBusPendingCall *pending;
2281  DBusHashIter iter;
2282 
2283  _dbus_hash_iter_init (connection->pending_replies, &iter);
2284  _dbus_hash_iter_next (&iter);
2285 
2286  pending = _dbus_hash_iter_get_value (&iter);
2288 
2290  connection);
2291 
2297 
2299  CONNECTION_LOCK (connection);
2300  }
2301  HAVE_LOCK_CHECK (connection);
2302 }
2303 
2304 static void
2305 complete_pending_call_and_unlock (DBusConnection *connection,
2306  DBusPendingCall *pending,
2307  DBusMessage *message)
2308 {
2309  _dbus_pending_call_set_reply_unlocked (pending, message);
2310  _dbus_pending_call_ref_unlocked (pending); /* in case there's no app with a ref held */
2311  _dbus_connection_detach_pending_call_and_unlock (connection, pending);
2312 
2313  /* Must be called unlocked since it invokes app callback */
2314  _dbus_pending_call_complete (pending);
2315  dbus_pending_call_unref (pending);
2316 }
2317 
2318 static dbus_bool_t
2319 check_for_reply_and_update_dispatch_unlocked (DBusConnection *connection,
2320  DBusPendingCall *pending)
2321 {
2322  DBusMessage *reply;
2323  DBusDispatchStatus status;
2324 
2325  reply = check_for_reply_unlocked (connection,
2327  if (reply != NULL)
2328  {
2329  _dbus_verbose ("checked for reply\n");
2330 
2331  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): got reply\n");
2332 
2333  complete_pending_call_and_unlock (connection, pending, reply);
2334  dbus_message_unref (reply);
2335 
2336  CONNECTION_LOCK (connection);
2337  status = _dbus_connection_get_dispatch_status_unlocked (connection);
2338  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2339  dbus_pending_call_unref (pending);
2340 
2341  return TRUE;
2342  }
2343 
2344  return FALSE;
2345 }
2346 
2361 void
2363 {
2364  long start_tv_sec, start_tv_usec;
2365  long tv_sec, tv_usec;
2366  DBusDispatchStatus status;
2367  DBusConnection *connection;
2368  dbus_uint32_t client_serial;
2369  DBusTimeout *timeout;
2370  int timeout_milliseconds, elapsed_milliseconds;
2371 
2372  _dbus_assert (pending != NULL);
2373 
2374  if (dbus_pending_call_get_completed (pending))
2375  return;
2376 
2377  dbus_pending_call_ref (pending); /* necessary because the call could be canceled */
2378 
2379  connection = _dbus_pending_call_get_connection_and_lock (pending);
2380 
2381  /* Flush message queue - note, can affect dispatch status */
2382  _dbus_connection_flush_unlocked (connection);
2383 
2384  client_serial = _dbus_pending_call_get_reply_serial_unlocked (pending);
2385 
2386  /* note that timeout_milliseconds is limited to a smallish value
2387  * in _dbus_pending_call_new() so overflows aren't possible
2388  * below
2389  */
2390  timeout = _dbus_pending_call_get_timeout_unlocked (pending);
2391  _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
2392  if (timeout)
2393  {
2394  timeout_milliseconds = dbus_timeout_get_interval (timeout);
2395 
2396  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block %d milliseconds for reply serial %u from %ld sec %ld usec\n",
2397  timeout_milliseconds,
2398  client_serial,
2399  start_tv_sec, start_tv_usec);
2400  }
2401  else
2402  {
2403  timeout_milliseconds = -1;
2404 
2405  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block for reply serial %u\n", client_serial);
2406  }
2407 
2408  /* check to see if we already got the data off the socket */
2409  /* from another blocked pending call */
2410  if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
2411  return;
2412 
2413  /* Now we wait... */
2414  /* always block at least once as we know we don't have the reply yet */
2416  pending,
2417  DBUS_ITERATION_DO_READING |
2418  DBUS_ITERATION_BLOCK,
2419  timeout_milliseconds);
2420 
2421  recheck_status:
2422 
2423  _dbus_verbose ("top of recheck\n");
2424 
2425  HAVE_LOCK_CHECK (connection);
2426 
2427  /* queue messages and get status */
2428 
2429  status = _dbus_connection_get_dispatch_status_unlocked (connection);
2430 
2431  /* the get_completed() is in case a dispatch() while we were blocking
2432  * got the reply instead of us.
2433  */
2435  {
2436  _dbus_verbose ("Pending call completed by dispatch\n");
2437  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2438  dbus_pending_call_unref (pending);
2439  return;
2440  }
2441 
2442  if (status == DBUS_DISPATCH_DATA_REMAINS)
2443  {
2444  if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
2445  return;
2446  }
2447 
2448  _dbus_get_monotonic_time (&tv_sec, &tv_usec);
2449  elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 +
2450  (tv_usec - start_tv_usec) / 1000;
2451 
2452  if (!_dbus_connection_get_is_connected_unlocked (connection))
2453  {
2454  DBusMessage *error_msg;
2455 
2456  error_msg = generate_local_error_message (client_serial,
2458  "Connection was disconnected before a reply was received");
2459 
2460  /* on OOM error_msg is set to NULL */
2461  complete_pending_call_and_unlock (connection, pending, error_msg);
2462  dbus_pending_call_unref (pending);
2463  return;
2464  }
2465  else if (connection->disconnect_message_link == NULL)
2466  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): disconnected\n");
2467  else if (timeout == NULL)
2468  {
2469  if (status == DBUS_DISPATCH_NEED_MEMORY)
2470  {
2471  /* Try sleeping a bit, as we aren't sure we need to block for reading,
2472  * we may already have a reply in the buffer and just can't process
2473  * it.
2474  */
2475  _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n");
2476 
2477  _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
2478  }
2479  else
2480  {
2481  /* block again, we don't have the reply buffered yet. */
2483  pending,
2484  DBUS_ITERATION_DO_READING |
2485  DBUS_ITERATION_BLOCK,
2486  timeout_milliseconds - elapsed_milliseconds);
2487  }
2488 
2489  goto recheck_status;
2490  }
2491  else if (tv_sec < start_tv_sec)
2492  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): clock set backward\n");
2493  else if (elapsed_milliseconds < timeout_milliseconds)
2494  {
2495  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): %d milliseconds remain\n", timeout_milliseconds - elapsed_milliseconds);
2496 
2497  if (status == DBUS_DISPATCH_NEED_MEMORY)
2498  {
2499  /* Try sleeping a bit, as we aren't sure we need to block for reading,
2500  * we may already have a reply in the buffer and just can't process
2501  * it.
2502  */
2503  _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n");
2504 
2505  _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
2506  }
2507  else
2508  {
2509  /* block again, we don't have the reply buffered yet. */
2511  NULL,
2512  DBUS_ITERATION_DO_READING |
2513  DBUS_ITERATION_BLOCK,
2514  timeout_milliseconds - elapsed_milliseconds);
2515  }
2516 
2517  goto recheck_status;
2518  }
2519 
2520  _dbus_verbose ("dbus_connection_send_with_reply_and_block(): Waited %d milliseconds and got no reply\n",
2521  elapsed_milliseconds);
2522 
2524 
2525  /* unlock and call user code */
2526  complete_pending_call_and_unlock (connection, pending, NULL);
2527 
2528  /* update user code on dispatch status */
2529  CONNECTION_LOCK (connection);
2530  status = _dbus_connection_get_dispatch_status_unlocked (connection);
2531  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2532  dbus_pending_call_unref (pending);
2533 }
2534 
2540 int
2542 {
2543  return _dbus_transport_get_pending_fds_count (connection->transport);
2544 }
2545 
2553 void
2555  DBusPendingFdsChangeFunction callback,
2556  void *data)
2557 {
2559  callback, data);
2560 }
2561 
2599 dbus_connection_open (const char *address,
2600  DBusError *error)
2601 {
2602  DBusConnection *connection;
2603 
2604  _dbus_return_val_if_fail (address != NULL, NULL);
2605  _dbus_return_val_if_error_is_set (error, NULL);
2606 
2607  connection = _dbus_connection_open_internal (address,
2608  TRUE,
2609  error);
2610 
2611  return connection;
2612 }
2613 
2642 dbus_connection_open_private (const char *address,
2643  DBusError *error)
2644 {
2645  DBusConnection *connection;
2646 
2647  _dbus_return_val_if_fail (address != NULL, NULL);
2648  _dbus_return_val_if_error_is_set (error, NULL);
2649 
2650  connection = _dbus_connection_open_internal (address,
2651  FALSE,
2652  error);
2653 
2654  return connection;
2655 }
2656 
2665 {
2666  dbus_int32_t old_refcount;
2667 
2668  _dbus_return_val_if_fail (connection != NULL, NULL);
2669  _dbus_return_val_if_fail (connection->generation == _dbus_current_generation, NULL);
2670  old_refcount = _dbus_atomic_inc (&connection->refcount);
2671  _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
2672  "ref");
2673 
2674  return connection;
2675 }
2676 
2677 static void
2678 free_outgoing_message (void *element,
2679  void *data)
2680 {
2681  DBusMessage *message = element;
2682  DBusConnection *connection = data;
2683 
2684  _dbus_message_remove_counter (message, connection->outgoing_counter);
2685  dbus_message_unref (message);
2686 }
2687 
2688 /* This is run without the mutex held, but after the last reference
2689  * to the connection has been dropped we should have no thread-related
2690  * problems
2691  */
2692 static void
2693 _dbus_connection_last_unref (DBusConnection *connection)
2694 {
2695  DBusList *link;
2696 
2697  _dbus_verbose ("Finalizing connection %p\n", connection);
2698 
2699  _dbus_assert (_dbus_atomic_get (&connection->refcount) == 0);
2700 
2701  /* You have to disconnect the connection before unref:ing it. Otherwise
2702  * you won't get the disconnected message.
2703  */
2705  _dbus_assert (connection->server_guid == NULL);
2706 
2707  /* ---- We're going to call various application callbacks here, hope it doesn't break anything... */
2709 
2713 
2714  _dbus_watch_list_free (connection->watches);
2715  connection->watches = NULL;
2716 
2717  _dbus_timeout_list_free (connection->timeouts);
2718  connection->timeouts = NULL;
2719 
2720  _dbus_data_slot_list_free (&connection->slot_list);
2721 
2722  link = _dbus_list_get_first_link (&connection->filter_list);
2723  while (link != NULL)
2724  {
2725  DBusMessageFilter *filter = link->data;
2726  DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link);
2727 
2728  filter->function = NULL;
2729  _dbus_message_filter_unref (filter); /* calls app callback */
2730  link->data = NULL;
2731 
2732  link = next;
2733  }
2734  _dbus_list_clear (&connection->filter_list);
2735 
2736  /* ---- Done with stuff that invokes application callbacks */
2737 
2738  _dbus_object_tree_unref (connection->objects);
2739 
2741  connection->pending_replies = NULL;
2742 
2743  _dbus_list_clear (&connection->filter_list);
2744 
2745  _dbus_list_foreach (&connection->outgoing_messages,
2746  free_outgoing_message,
2747  connection);
2748  _dbus_list_clear (&connection->outgoing_messages);
2749 
2750  _dbus_list_foreach (&connection->incoming_messages,
2752  NULL);
2753  _dbus_list_clear (&connection->incoming_messages);
2754 
2755  _dbus_counter_unref (connection->outgoing_counter);
2756 
2757  _dbus_transport_unref (connection->transport);
2758 
2759  if (connection->disconnect_message_link)
2760  {
2761  DBusMessage *message = connection->disconnect_message_link->data;
2762  dbus_message_unref (message);
2764  }
2765 
2768 
2771 
2773 
2774  _dbus_rmutex_free_at_location (&connection->mutex);
2775 
2776  dbus_free (connection);
2777 }
2778 
2798 void
2800 {
2801  dbus_int32_t old_refcount;
2802 
2803  _dbus_return_if_fail (connection != NULL);
2804  _dbus_return_if_fail (connection->generation == _dbus_current_generation);
2805 
2806  old_refcount = _dbus_atomic_dec (&connection->refcount);
2807 
2808  _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
2809  "unref");
2810 
2811  if (old_refcount == 1)
2812  {
2813 #ifndef DBUS_DISABLE_CHECKS
2814  if (_dbus_transport_get_is_connected (connection->transport))
2815  {
2816  _dbus_warn_check_failed ("The last reference on a connection was dropped without closing the connection. This is a bug in an application. See dbus_connection_unref() documentation for details.\n%s",
2817  connection->shareable ?
2818  "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection.\n" :
2819  "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.\n");
2820  return;
2821  }
2822 #endif
2823  _dbus_connection_last_unref (connection);
2824  }
2825 }
2826 
2827 /*
2828  * Note that the transport can disconnect itself (other end drops us)
2829  * and in that case this function never runs. So this function must
2830  * not do anything more than disconnect the transport and update the
2831  * dispatch status.
2832  *
2833  * If the transport self-disconnects, then we assume someone will
2834  * dispatch the connection to cause the dispatch status update.
2835  */
2836 static void
2837 _dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection)
2838 {
2839  DBusDispatchStatus status;
2840 
2841  HAVE_LOCK_CHECK (connection);
2842 
2843  _dbus_verbose ("Disconnecting %p\n", connection);
2844 
2845  /* We need to ref because update_dispatch_status_and_unlock will unref
2846  * the connection if it was shared and libdbus was the only remaining
2847  * refcount holder.
2848  */
2849  _dbus_connection_ref_unlocked (connection);
2850 
2851  _dbus_transport_disconnect (connection->transport);
2852 
2853  /* This has the side effect of queuing the disconnect message link
2854  * (unless we don't have enough memory, possibly, so don't assert it).
2855  * After the disconnect message link is queued, dbus_bus_get/dbus_connection_open
2856  * should never again return the newly-disconnected connection.
2857  *
2858  * However, we only unref the shared connection and exit_on_disconnect when
2859  * the disconnect message reaches the head of the message queue,
2860  * NOT when it's first queued.
2861  */
2862  status = _dbus_connection_get_dispatch_status_unlocked (connection);
2863 
2864  /* This calls out to user code */
2865  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2866 
2867  /* Could also call out to user code */
2868  dbus_connection_unref (connection);
2869 }
2870 
2913 void
2915 {
2916  _dbus_return_if_fail (connection != NULL);
2917  _dbus_return_if_fail (connection->generation == _dbus_current_generation);
2918 
2919  CONNECTION_LOCK (connection);
2920 
2921 #ifndef DBUS_DISABLE_CHECKS
2922  if (connection->shareable)
2923  {
2924  CONNECTION_UNLOCK (connection);
2925 
2926  _dbus_warn_check_failed ("Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.\n");
2927  return;
2928  }
2929 #endif
2930 
2931  _dbus_connection_close_possibly_shared_and_unlock (connection);
2932 }
2933 
2934 static dbus_bool_t
2935 _dbus_connection_get_is_connected_unlocked (DBusConnection *connection)
2936 {
2937  HAVE_LOCK_CHECK (connection);
2938  return _dbus_transport_get_is_connected (connection->transport);
2939 }
2940 
2956 {
2957  dbus_bool_t res;
2958 
2959  _dbus_return_val_if_fail (connection != NULL, FALSE);
2960 
2961  CONNECTION_LOCK (connection);
2962  res = _dbus_connection_get_is_connected_unlocked (connection);
2963  CONNECTION_UNLOCK (connection);
2964 
2965  return res;
2966 }
2967 
2978 {
2979  dbus_bool_t res;
2980 
2981  _dbus_return_val_if_fail (connection != NULL, FALSE);
2982 
2983  CONNECTION_LOCK (connection);
2984  res = _dbus_transport_get_is_authenticated (connection->transport);
2985  CONNECTION_UNLOCK (connection);
2986 
2987  return res;
2988 }
2989 
3012 {
3013  dbus_bool_t res;
3014 
3015  _dbus_return_val_if_fail (connection != NULL, FALSE);
3016 
3017  CONNECTION_LOCK (connection);
3018  res = _dbus_transport_get_is_anonymous (connection->transport);
3019  CONNECTION_UNLOCK (connection);
3020 
3021  return res;
3022 }
3023 
3055 char*
3057 {
3058  char *id;
3059 
3060  _dbus_return_val_if_fail (connection != NULL, NULL);
3061 
3062  CONNECTION_LOCK (connection);
3064  CONNECTION_UNLOCK (connection);
3065 
3066  return id;
3067 }
3068 
3088  int type)
3089 {
3090  _dbus_return_val_if_fail (connection != NULL, FALSE);
3091 
3092  if (!dbus_type_is_valid (type))
3093  return FALSE;
3094 
3095  if (type != DBUS_TYPE_UNIX_FD)
3096  return TRUE;
3097 
3098 #ifdef HAVE_UNIX_FD_PASSING
3099  {
3100  dbus_bool_t b;
3101 
3102  CONNECTION_LOCK(connection);
3104  CONNECTION_UNLOCK(connection);
3105 
3106  return b;
3107  }
3108 #endif
3109 
3110  return FALSE;
3111 }
3112 
3126 void
3128  dbus_bool_t exit_on_disconnect)
3129 {
3130  _dbus_return_if_fail (connection != NULL);
3131 
3132  CONNECTION_LOCK (connection);
3133  connection->exit_on_disconnect = exit_on_disconnect != FALSE;
3134  CONNECTION_UNLOCK (connection);
3135 }
3136 
3148 {
3149  DBusPreallocatedSend *preallocated;
3150 
3151  _dbus_return_val_if_fail (connection != NULL, NULL);
3152 
3153  CONNECTION_LOCK (connection);
3154 
3155  preallocated =
3156  _dbus_connection_preallocate_send_unlocked (connection);
3157 
3158  CONNECTION_UNLOCK (connection);
3159 
3160  return preallocated;
3161 }
3162 
3172 void
3174  DBusPreallocatedSend *preallocated)
3175 {
3176  _dbus_return_if_fail (connection != NULL);
3177  _dbus_return_if_fail (preallocated != NULL);
3178  _dbus_return_if_fail (connection == preallocated->connection);
3179 
3180  _dbus_list_free_link (preallocated->queue_link);
3181  _dbus_counter_unref (preallocated->counter_link->data);
3182  _dbus_list_free_link (preallocated->counter_link);
3183  dbus_free (preallocated);
3184 }
3185 
3198 void
3200  DBusPreallocatedSend *preallocated,
3201  DBusMessage *message,
3202  dbus_uint32_t *client_serial)
3203 {
3204  _dbus_return_if_fail (connection != NULL);
3205  _dbus_return_if_fail (preallocated != NULL);
3206  _dbus_return_if_fail (message != NULL);
3207  _dbus_return_if_fail (preallocated->connection == connection);
3208  _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL ||
3209  dbus_message_get_member (message) != NULL);
3210  _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL ||
3211  (dbus_message_get_interface (message) != NULL &&
3212  dbus_message_get_member (message) != NULL));
3213 
3214  CONNECTION_LOCK (connection);
3215 
3216 #ifdef HAVE_UNIX_FD_PASSING
3217 
3218  if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3219  message->n_unix_fds > 0)
3220  {
3221  /* Refuse to send fds on a connection that cannot handle
3222  them. Unfortunately we cannot return a proper error here, so
3223  the best we can is just return. */
3224  CONNECTION_UNLOCK (connection);
3225  return;
3226  }
3227 
3228 #endif
3229 
3230  _dbus_connection_send_preallocated_and_unlock (connection,
3231  preallocated,
3232  message, client_serial);
3233 }
3234 
3235 static dbus_bool_t
3236 _dbus_connection_send_unlocked_no_update (DBusConnection *connection,
3237  DBusMessage *message,
3238  dbus_uint32_t *client_serial)
3239 {
3240  DBusPreallocatedSend *preallocated;
3241 
3242  _dbus_assert (connection != NULL);
3243  _dbus_assert (message != NULL);
3244 
3245  preallocated = _dbus_connection_preallocate_send_unlocked (connection);
3246  if (preallocated == NULL)
3247  return FALSE;
3248 
3249  _dbus_connection_send_preallocated_unlocked_no_update (connection,
3250  preallocated,
3251  message,
3252  client_serial);
3253  return TRUE;
3254 }
3255 
3285  DBusMessage *message,
3286  dbus_uint32_t *serial)
3287 {
3288  _dbus_return_val_if_fail (connection != NULL, FALSE);
3289  _dbus_return_val_if_fail (message != NULL, FALSE);
3290 
3291  CONNECTION_LOCK (connection);
3292 
3293 #ifdef HAVE_UNIX_FD_PASSING
3294 
3295  if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3296  message->n_unix_fds > 0)
3297  {
3298  /* Refuse to send fds on a connection that cannot handle
3299  them. Unfortunately we cannot return a proper error here, so
3300  the best we can is just return. */
3301  CONNECTION_UNLOCK (connection);
3302  return FALSE;
3303  }
3304 
3305 #endif
3306 
3307  return _dbus_connection_send_and_unlock (connection,
3308  message,
3309  serial);
3310 }
3311 
3312 static dbus_bool_t
3313 reply_handler_timeout (void *data)
3314 {
3315  DBusConnection *connection;
3316  DBusDispatchStatus status;
3317  DBusPendingCall *pending = data;
3318 
3319  connection = _dbus_pending_call_get_connection_and_lock (pending);
3320  _dbus_connection_ref_unlocked (connection);
3321 
3323  connection);
3327 
3328  _dbus_verbose ("middle\n");
3329  status = _dbus_connection_get_dispatch_status_unlocked (connection);
3330 
3331  /* Unlocks, and calls out to user code */
3332  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3333  dbus_connection_unref (connection);
3334 
3335  return TRUE;
3336 }
3337 
3382  DBusMessage *message,
3383  DBusPendingCall **pending_return,
3384  int timeout_milliseconds)
3385 {
3386  DBusPendingCall *pending;
3387  dbus_int32_t serial = -1;
3388  DBusDispatchStatus status;
3389 
3390  _dbus_return_val_if_fail (connection != NULL, FALSE);
3391  _dbus_return_val_if_fail (message != NULL, FALSE);
3392  _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3393 
3394  if (pending_return)
3395  *pending_return = NULL;
3396 
3397  CONNECTION_LOCK (connection);
3398 
3399 #ifdef HAVE_UNIX_FD_PASSING
3400 
3401  if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3402  message->n_unix_fds > 0)
3403  {
3404  /* Refuse to send fds on a connection that cannot handle
3405  them. Unfortunately we cannot return a proper error here, so
3406  the best we can do is return TRUE but leave *pending_return
3407  as NULL. */
3408  CONNECTION_UNLOCK (connection);
3409  return TRUE;
3410  }
3411 
3412 #endif
3413 
3414  if (!_dbus_connection_get_is_connected_unlocked (connection))
3415  {
3416  CONNECTION_UNLOCK (connection);
3417 
3418  return TRUE;
3419  }
3420 
3421  pending = _dbus_pending_call_new_unlocked (connection,
3422  timeout_milliseconds,
3423  reply_handler_timeout);
3424 
3425  if (pending == NULL)
3426  {
3427  CONNECTION_UNLOCK (connection);
3428  return FALSE;
3429  }
3430 
3431  /* Assign a serial to the message */
3432  serial = dbus_message_get_serial (message);
3433  if (serial == 0)
3434  {
3435  serial = _dbus_connection_get_next_client_serial (connection);
3436  dbus_message_set_serial (message, serial);
3437  }
3438 
3439  if (!_dbus_pending_call_set_timeout_error_unlocked (pending, message, serial))
3440  goto error;
3441 
3442  /* Insert the serial in the pending replies hash;
3443  * hash takes a refcount on DBusPendingCall.
3444  * Also, add the timeout.
3445  */
3446  if (!_dbus_connection_attach_pending_call_unlocked (connection,
3447  pending))
3448  goto error;
3449 
3450  if (!_dbus_connection_send_unlocked_no_update (connection, message, NULL))
3451  {
3452  _dbus_connection_detach_pending_call_and_unlock (connection,
3453  pending);
3454  goto error_unlocked;
3455  }
3456 
3457  if (pending_return)
3458  *pending_return = pending; /* hand off refcount */
3459  else
3460  {
3461  _dbus_connection_detach_pending_call_unlocked (connection, pending);
3462  /* we still have a ref to the pending call in this case, we unref
3463  * after unlocking, below
3464  */
3465  }
3466 
3467  status = _dbus_connection_get_dispatch_status_unlocked (connection);
3468 
3469  /* this calls out to user code */
3470  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3471 
3472  if (pending_return == NULL)
3473  dbus_pending_call_unref (pending);
3474 
3475  return TRUE;
3476 
3477  error:
3478  CONNECTION_UNLOCK (connection);
3479  error_unlocked:
3480  dbus_pending_call_unref (pending);
3481  return FALSE;
3482 }
3483 
3516 DBusMessage*
3518  DBusMessage *message,
3519  int timeout_milliseconds,
3520  DBusError *error)
3521 {
3522  DBusMessage *reply;
3523  DBusPendingCall *pending;
3524 
3525  _dbus_return_val_if_fail (connection != NULL, NULL);
3526  _dbus_return_val_if_fail (message != NULL, NULL);
3527  _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, NULL);
3528  _dbus_return_val_if_error_is_set (error, NULL);
3529 
3530 #ifdef HAVE_UNIX_FD_PASSING
3531 
3532  CONNECTION_LOCK (connection);
3533  if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3534  message->n_unix_fds > 0)
3535  {
3536  CONNECTION_UNLOCK (connection);
3537  dbus_set_error(error, DBUS_ERROR_FAILED, "Cannot send file descriptors on this connection.");
3538  return NULL;
3539  }
3540  CONNECTION_UNLOCK (connection);
3541 
3542 #endif
3543 
3544  if (!dbus_connection_send_with_reply (connection, message,
3545  &pending, timeout_milliseconds))
3546  {
3547  _DBUS_SET_OOM (error);
3548  return NULL;
3549  }
3550 
3551  if (pending == NULL)
3552  {
3553  dbus_set_error (error, DBUS_ERROR_DISCONNECTED, "Connection is closed");
3554  return NULL;
3555  }
3556 
3557  dbus_pending_call_block (pending);
3558 
3559  reply = dbus_pending_call_steal_reply (pending);
3560  dbus_pending_call_unref (pending);
3561 
3562  /* call_complete_and_unlock() called from pending_call_block() should
3563  * always fill this in.
3564  */
3565  _dbus_assert (reply != NULL);
3566 
3567  if (dbus_set_error_from_message (error, reply))
3568  {
3569  dbus_message_unref (reply);
3570  return NULL;
3571  }
3572  else
3573  return reply;
3574 }
3575 
3584 static DBusDispatchStatus
3585 _dbus_connection_flush_unlocked (DBusConnection *connection)
3586 {
3587  /* We have to specify DBUS_ITERATION_DO_READING here because
3588  * otherwise we could have two apps deadlock if they are both doing
3589  * a flush(), and the kernel buffers fill up. This could change the
3590  * dispatch status.
3591  */
3592  DBusDispatchStatus status;
3593 
3594  HAVE_LOCK_CHECK (connection);
3595 
3596  while (connection->n_outgoing > 0 &&
3597  _dbus_connection_get_is_connected_unlocked (connection))
3598  {
3599  _dbus_verbose ("doing iteration in\n");
3600  HAVE_LOCK_CHECK (connection);
3602  NULL,
3603  DBUS_ITERATION_DO_READING |
3604  DBUS_ITERATION_DO_WRITING |
3605  DBUS_ITERATION_BLOCK,
3606  -1);
3607  }
3608 
3609  HAVE_LOCK_CHECK (connection);
3610  _dbus_verbose ("middle\n");
3611  status = _dbus_connection_get_dispatch_status_unlocked (connection);
3612 
3613  HAVE_LOCK_CHECK (connection);
3614  return status;
3615 }
3616 
3622 void
3624 {
3625  /* We have to specify DBUS_ITERATION_DO_READING here because
3626  * otherwise we could have two apps deadlock if they are both doing
3627  * a flush(), and the kernel buffers fill up. This could change the
3628  * dispatch status.
3629  */
3630  DBusDispatchStatus status;
3631 
3632  _dbus_return_if_fail (connection != NULL);
3633 
3634  CONNECTION_LOCK (connection);
3635 
3636  status = _dbus_connection_flush_unlocked (connection);
3637 
3638  HAVE_LOCK_CHECK (connection);
3639  /* Unlocks and calls out to user code */
3640  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3641 
3642  _dbus_verbose ("end\n");
3643 }
3644 
3655 static dbus_bool_t
3656 _dbus_connection_read_write_dispatch (DBusConnection *connection,
3657  int timeout_milliseconds,
3658  dbus_bool_t dispatch)
3659 {
3660  DBusDispatchStatus dstatus;
3661  dbus_bool_t progress_possible;
3662 
3663  /* Need to grab a ref here in case we're a private connection and
3664  * the user drops the last ref in a handler we call; see bug
3665  * https://bugs.freedesktop.org/show_bug.cgi?id=15635
3666  */
3667  dbus_connection_ref (connection);
3668  dstatus = dbus_connection_get_dispatch_status (connection);
3669 
3670  if (dispatch && dstatus == DBUS_DISPATCH_DATA_REMAINS)
3671  {
3672  _dbus_verbose ("doing dispatch\n");
3673  dbus_connection_dispatch (connection);
3674  CONNECTION_LOCK (connection);
3675  }
3676  else if (dstatus == DBUS_DISPATCH_NEED_MEMORY)
3677  {
3678  _dbus_verbose ("pausing for memory\n");
3679  _dbus_memory_pause_based_on_timeout (timeout_milliseconds);
3680  CONNECTION_LOCK (connection);
3681  }
3682  else
3683  {
3684  CONNECTION_LOCK (connection);
3685  if (_dbus_connection_get_is_connected_unlocked (connection))
3686  {
3687  _dbus_verbose ("doing iteration\n");
3689  NULL,
3690  DBUS_ITERATION_DO_READING |
3691  DBUS_ITERATION_DO_WRITING |
3692  DBUS_ITERATION_BLOCK,
3693  timeout_milliseconds);
3694  }
3695  }
3696 
3697  HAVE_LOCK_CHECK (connection);
3698  /* If we can dispatch, we can make progress until the Disconnected message
3699  * has been processed; if we can only read/write, we can make progress
3700  * as long as the transport is open.
3701  */
3702  if (dispatch)
3703  progress_possible = connection->n_incoming != 0 ||
3704  connection->disconnect_message_link != NULL;
3705  else
3706  progress_possible = _dbus_connection_get_is_connected_unlocked (connection);
3707 
3708  CONNECTION_UNLOCK (connection);
3709 
3710  dbus_connection_unref (connection);
3711 
3712  return progress_possible; /* TRUE if we can make more progress */
3713 }
3714 
3715 
3752  int timeout_milliseconds)
3753 {
3754  _dbus_return_val_if_fail (connection != NULL, FALSE);
3755  _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3756  return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, TRUE);
3757 }
3758 
3782 dbus_bool_t
3784  int timeout_milliseconds)
3785 {
3786  _dbus_return_val_if_fail (connection != NULL, FALSE);
3787  _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3788  return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, FALSE);
3789 }
3790 
3791 /* We need to call this anytime we pop the head of the queue, and then
3792  * update_dispatch_status_and_unlock needs to be called afterward
3793  * which will "process" the disconnected message and set
3794  * disconnected_message_processed.
3795  */
3796 static void
3797 check_disconnected_message_arrived_unlocked (DBusConnection *connection,
3798  DBusMessage *head_of_queue)
3799 {
3800  HAVE_LOCK_CHECK (connection);
3801 
3802  /* checking that the link is NULL is an optimization to avoid the is_signal call */
3803  if (connection->disconnect_message_link == NULL &&
3804  dbus_message_is_signal (head_of_queue,
3806  "Disconnected"))
3807  {
3808  connection->disconnected_message_arrived = TRUE;
3809  }
3810 }
3811 
3831 DBusMessage*
3833 {
3834  DBusDispatchStatus status;
3835  DBusMessage *message;
3836 
3837  _dbus_return_val_if_fail (connection != NULL, NULL);
3838 
3839  _dbus_verbose ("start\n");
3840 
3841  /* this is called for the side effect that it queues
3842  * up any messages from the transport
3843  */
3844  status = dbus_connection_get_dispatch_status (connection);
3845  if (status != DBUS_DISPATCH_DATA_REMAINS)
3846  return NULL;
3847 
3848  CONNECTION_LOCK (connection);
3849 
3850  _dbus_connection_acquire_dispatch (connection);
3851 
3852  /* While a message is outstanding, the dispatch lock is held */
3853  _dbus_assert (connection->message_borrowed == NULL);
3854 
3855  connection->message_borrowed = _dbus_list_get_first (&connection->incoming_messages);
3856 
3857  message = connection->message_borrowed;
3858 
3859  check_disconnected_message_arrived_unlocked (connection, message);
3860 
3861  /* Note that we KEEP the dispatch lock until the message is returned */
3862  if (message == NULL)
3863  _dbus_connection_release_dispatch (connection);
3864 
3865  CONNECTION_UNLOCK (connection);
3866 
3867  _dbus_message_trace_ref (message, -1, -1, "dbus_connection_borrow_message");
3868 
3869  /* We don't update dispatch status until it's returned or stolen */
3870 
3871  return message;
3872 }
3873 
3882 void
3884  DBusMessage *message)
3885 {
3886  DBusDispatchStatus status;
3887 
3888  _dbus_return_if_fail (connection != NULL);
3889  _dbus_return_if_fail (message != NULL);
3890  _dbus_return_if_fail (message == connection->message_borrowed);
3891  _dbus_return_if_fail (connection->dispatch_acquired);
3892 
3893  CONNECTION_LOCK (connection);
3894 
3895  _dbus_assert (message == connection->message_borrowed);
3896 
3897  connection->message_borrowed = NULL;
3898 
3899  _dbus_connection_release_dispatch (connection);
3900 
3901  status = _dbus_connection_get_dispatch_status_unlocked (connection);
3902  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3903 
3904  _dbus_message_trace_ref (message, -1, -1, "dbus_connection_return_message");
3905 }
3906 
3916 void
3918  DBusMessage *message)
3919 {
3920  DBusMessage *pop_message;
3921  DBusDispatchStatus status;
3922 
3923  _dbus_return_if_fail (connection != NULL);
3924  _dbus_return_if_fail (message != NULL);
3925  _dbus_return_if_fail (message == connection->message_borrowed);
3926  _dbus_return_if_fail (connection->dispatch_acquired);
3927 
3928  CONNECTION_LOCK (connection);
3929 
3930  _dbus_assert (message == connection->message_borrowed);
3931 
3932  pop_message = _dbus_list_pop_first (&connection->incoming_messages);
3933  _dbus_assert (message == pop_message);
3934  (void) pop_message; /* unused unless asserting */
3935 
3936  connection->n_incoming -= 1;
3937 
3938  _dbus_verbose ("Incoming message %p stolen from queue, %d incoming\n",
3939  message, connection->n_incoming);
3940 
3941  connection->message_borrowed = NULL;
3942 
3943  _dbus_connection_release_dispatch (connection);
3944 
3945  status = _dbus_connection_get_dispatch_status_unlocked (connection);
3946  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3947  _dbus_message_trace_ref (message, -1, -1,
3948  "dbus_connection_steal_borrowed_message");
3949 }
3950 
3951 /* See dbus_connection_pop_message, but requires the caller to own
3952  * the lock before calling. May drop the lock while running.
3953  */
3954 static DBusList*
3955 _dbus_connection_pop_message_link_unlocked (DBusConnection *connection)
3956 {
3957  HAVE_LOCK_CHECK (connection);
3958 
3959  _dbus_assert (connection->message_borrowed == NULL);
3960 
3961  if (connection->n_incoming > 0)
3962  {
3963  DBusList *link;
3964 
3965  link = _dbus_list_pop_first_link (&connection->incoming_messages);
3966  connection->n_incoming -= 1;
3967 
3968  _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from incoming queue %p, %d incoming\n",
3969  link->data,
3971  dbus_message_get_path (link->data) ?
3972  dbus_message_get_path (link->data) :
3973  "no path",
3976  "no interface",
3977  dbus_message_get_member (link->data) ?
3978  dbus_message_get_member (link->data) :
3979  "no member",
3981  connection, connection->n_incoming);
3982 
3983  _dbus_message_trace_ref (link->data, -1, -1,
3984  "_dbus_connection_pop_message_link_unlocked");
3985 
3986  check_disconnected_message_arrived_unlocked (connection, link->data);
3987 
3988  return link;
3989  }
3990  else
3991  return NULL;
3992 }
3993 
3994 /* See dbus_connection_pop_message, but requires the caller to own
3995  * the lock before calling. May drop the lock while running.
3996  */
3997 static DBusMessage*
3998 _dbus_connection_pop_message_unlocked (DBusConnection *connection)
3999 {
4000  DBusList *link;
4001 
4002  HAVE_LOCK_CHECK (connection);
4003 
4004  link = _dbus_connection_pop_message_link_unlocked (connection);
4005 
4006  if (link != NULL)
4007  {
4008  DBusMessage *message;
4009 
4010  message = link->data;
4011 
4012  _dbus_list_free_link (link);
4013 
4014  return message;
4015  }
4016  else
4017  return NULL;
4018 }
4019 
4020 static void
4021 _dbus_connection_putback_message_link_unlocked (DBusConnection *connection,
4022  DBusList *message_link)
4023 {
4024  HAVE_LOCK_CHECK (connection);
4025 
4026  _dbus_assert (message_link != NULL);
4027  /* You can't borrow a message while a link is outstanding */
4028  _dbus_assert (connection->message_borrowed == NULL);
4029  /* We had to have the dispatch lock across the pop/putback */
4030  _dbus_assert (connection->dispatch_acquired);
4031 
4033  message_link);
4034  connection->n_incoming += 1;
4035 
4036  _dbus_verbose ("Message %p (%s %s %s '%s') put back into queue %p, %d incoming\n",
4037  message_link->data,
4039  dbus_message_get_interface (message_link->data) ?
4040  dbus_message_get_interface (message_link->data) :
4041  "no interface",
4042  dbus_message_get_member (message_link->data) ?
4043  dbus_message_get_member (message_link->data) :
4044  "no member",
4045  dbus_message_get_signature (message_link->data),
4046  connection, connection->n_incoming);
4047 
4048  _dbus_message_trace_ref (message_link->data, -1, -1,
4049  "_dbus_connection_putback_message_link_unlocked");
4050 }
4051 
4071 DBusMessage*
4073 {
4074  DBusMessage *message;
4075  DBusDispatchStatus status;
4076 
4077  _dbus_verbose ("start\n");
4078 
4079  /* this is called for the side effect that it queues
4080  * up any messages from the transport
4081  */
4082  status = dbus_connection_get_dispatch_status (connection);
4083  if (status != DBUS_DISPATCH_DATA_REMAINS)
4084  return NULL;
4085 
4086  CONNECTION_LOCK (connection);
4087  _dbus_connection_acquire_dispatch (connection);
4088  HAVE_LOCK_CHECK (connection);
4089 
4090  message = _dbus_connection_pop_message_unlocked (connection);
4091 
4092  _dbus_verbose ("Returning popped message %p\n", message);
4093 
4094  _dbus_connection_release_dispatch (connection);
4095 
4096  status = _dbus_connection_get_dispatch_status_unlocked (connection);
4097  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4098 
4099  return message;
4100 }
4101 
4109 static void
4110 _dbus_connection_acquire_dispatch (DBusConnection *connection)
4111 {
4112  HAVE_LOCK_CHECK (connection);
4113 
4114  _dbus_connection_ref_unlocked (connection);
4115  CONNECTION_UNLOCK (connection);
4116 
4117  _dbus_verbose ("locking dispatch_mutex\n");
4118  _dbus_cmutex_lock (connection->dispatch_mutex);
4119 
4120  while (connection->dispatch_acquired)
4121  {
4122  _dbus_verbose ("waiting for dispatch to be acquirable\n");
4123  _dbus_condvar_wait (connection->dispatch_cond,
4124  connection->dispatch_mutex);
4125  }
4126 
4127  _dbus_assert (!connection->dispatch_acquired);
4128 
4129  connection->dispatch_acquired = TRUE;
4130 
4131  _dbus_verbose ("unlocking dispatch_mutex\n");
4132  _dbus_cmutex_unlock (connection->dispatch_mutex);
4133 
4134  CONNECTION_LOCK (connection);
4135  _dbus_connection_unref_unlocked (connection);
4136 }
4137 
4145 static void
4146 _dbus_connection_release_dispatch (DBusConnection *connection)
4147 {
4148  HAVE_LOCK_CHECK (connection);
4149 
4150  _dbus_verbose ("locking dispatch_mutex\n");
4151  _dbus_cmutex_lock (connection->dispatch_mutex);
4152 
4153  _dbus_assert (connection->dispatch_acquired);
4154 
4155  connection->dispatch_acquired = FALSE;
4156  _dbus_condvar_wake_one (connection->dispatch_cond);
4157 
4158  _dbus_verbose ("unlocking dispatch_mutex\n");
4159  _dbus_cmutex_unlock (connection->dispatch_mutex);
4160 }
4161 
4162 static void
4163 _dbus_connection_failed_pop (DBusConnection *connection,
4164  DBusList *message_link)
4165 {
4167  message_link);
4168  connection->n_incoming += 1;
4169 }
4170 
4171 /* Note this may be called multiple times since we don't track whether we already did it */
4172 static void
4173 notify_disconnected_unlocked (DBusConnection *connection)
4174 {
4175  HAVE_LOCK_CHECK (connection);
4176 
4177  /* Set the weakref in dbus-bus.c to NULL, so nobody will get a disconnected
4178  * connection from dbus_bus_get(). We make the same guarantee for
4179  * dbus_connection_open() but in a different way since we don't want to
4180  * unref right here; we instead check for connectedness before returning
4181  * the connection from the hash.
4182  */
4184 
4185  /* Dump the outgoing queue, we aren't going to be able to
4186  * send it now, and we'd like accessors like
4187  * dbus_connection_get_outgoing_size() to be accurate.
4188  */
4189  if (connection->n_outgoing > 0)
4190  {
4191  DBusList *link;
4192 
4193  _dbus_verbose ("Dropping %d outgoing messages since we're disconnected\n",
4194  connection->n_outgoing);
4195 
4196  while ((link = _dbus_list_get_last_link (&connection->outgoing_messages)))
4197  {
4198  _dbus_connection_message_sent_unlocked (connection, link->data);
4199  }
4200  }
4201 }
4202 
4203 /* Note this may be called multiple times since we don't track whether we already did it */
4204 static DBusDispatchStatus
4205 notify_disconnected_and_dispatch_complete_unlocked (DBusConnection *connection)
4206 {
4207  HAVE_LOCK_CHECK (connection);
4208 
4209  if (connection->disconnect_message_link != NULL)
4210  {
4211  _dbus_verbose ("Sending disconnect message\n");
4212 
4213  /* If we have pending calls, queue their timeouts - we want the Disconnected
4214  * to be the last message, after these timeouts.
4215  */
4216  connection_timeout_and_complete_all_pending_calls_unlocked (connection);
4217 
4218  /* We haven't sent the disconnect message already,
4219  * and all real messages have been queued up.
4220  */
4222  connection->disconnect_message_link);
4223  connection->disconnect_message_link = NULL;
4224 
4226  }
4227 
4228  return DBUS_DISPATCH_COMPLETE;
4229 }
4230 
4231 static DBusDispatchStatus
4232 _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection)
4233 {
4234  HAVE_LOCK_CHECK (connection);
4235 
4236  if (connection->n_incoming > 0)
4238  else if (!_dbus_transport_queue_messages (connection->transport))
4240  else
4241  {
4242  DBusDispatchStatus status;
4243  dbus_bool_t is_connected;
4244 
4245  status = _dbus_transport_get_dispatch_status (connection->transport);
4246  is_connected = _dbus_transport_get_is_connected (connection->transport);
4247 
4248  _dbus_verbose ("dispatch status = %s is_connected = %d\n",
4249  DISPATCH_STATUS_NAME (status), is_connected);
4250 
4251  if (!is_connected)
4252  {
4253  /* It's possible this would be better done by having an explicit
4254  * notification from _dbus_transport_disconnect() that would
4255  * synchronously do this, instead of waiting for the next dispatch
4256  * status check. However, probably not good to change until it causes
4257  * a problem.
4258  */
4259  notify_disconnected_unlocked (connection);
4260 
4261  /* I'm not sure this is needed; the idea is that we want to
4262  * queue the Disconnected only after we've read all the
4263  * messages, but if we're disconnected maybe we are guaranteed
4264  * to have read them all ?
4265  */
4266  if (status == DBUS_DISPATCH_COMPLETE)
4267  status = notify_disconnected_and_dispatch_complete_unlocked (connection);
4268  }
4269 
4270  if (status != DBUS_DISPATCH_COMPLETE)
4271  return status;
4272  else if (connection->n_incoming > 0)
4274  else
4275  return DBUS_DISPATCH_COMPLETE;
4276  }
4277 }
4278 
4279 static void
4280 _dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection,
4281  DBusDispatchStatus new_status)
4282 {
4283  dbus_bool_t changed;
4284  DBusDispatchStatusFunction function;
4285  void *data;
4286 
4287  HAVE_LOCK_CHECK (connection);
4288 
4289  _dbus_connection_ref_unlocked (connection);
4290 
4291  changed = new_status != connection->last_dispatch_status;
4292 
4293  connection->last_dispatch_status = new_status;
4294 
4295  function = connection->dispatch_status_function;
4296  data = connection->dispatch_status_data;
4297 
4298  if (connection->disconnected_message_arrived &&
4299  !connection->disconnected_message_processed)
4300  {
4301  connection->disconnected_message_processed = TRUE;
4302 
4303  /* this does an unref, but we have a ref
4304  * so we should not run the finalizer here
4305  * inside the lock.
4306  */
4307  connection_forget_shared_unlocked (connection);
4308 
4309  if (connection->exit_on_disconnect)
4310  {
4311  CONNECTION_UNLOCK (connection);
4312 
4313  _dbus_verbose ("Exiting on Disconnected signal\n");
4314  _dbus_exit (1);
4315  _dbus_assert_not_reached ("Call to exit() returned");
4316  }
4317  }
4318 
4319  /* We drop the lock */
4320  CONNECTION_UNLOCK (connection);
4321 
4322  if (changed && function)
4323  {
4324  _dbus_verbose ("Notifying of change to dispatch status of %p now %d (%s)\n",
4325  connection, new_status,
4326  DISPATCH_STATUS_NAME (new_status));
4327  (* function) (connection, new_status, data);
4328  }
4329 
4330  dbus_connection_unref (connection);
4331 }
4332 
4360 {
4361  DBusDispatchStatus status;
4362 
4363  _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
4364 
4365  _dbus_verbose ("start\n");
4366 
4367  CONNECTION_LOCK (connection);
4368 
4369  status = _dbus_connection_get_dispatch_status_unlocked (connection);
4370 
4371  CONNECTION_UNLOCK (connection);
4372 
4373  return status;
4374 }
4375 
4379 static DBusHandlerResult
4380 _dbus_connection_peer_filter_unlocked_no_update (DBusConnection *connection,
4381  DBusMessage *message)
4382 {
4383  dbus_bool_t sent = FALSE;
4384  DBusMessage *ret = NULL;
4385  DBusList *expire_link;
4386 
4387  if (connection->route_peer_messages && dbus_message_get_destination (message) != NULL)
4388  {
4389  /* This means we're letting the bus route this message */
4391  }
4392 
4394  {
4396  }
4397 
4398  /* Preallocate a linked-list link, so that if we need to dispose of a
4399  * message, we can attach it to the expired list */
4400  expire_link = _dbus_list_alloc_link (NULL);
4401 
4402  if (!expire_link)
4404 
4405  if (dbus_message_is_method_call (message,
4407  "Ping"))
4408  {
4409  ret = dbus_message_new_method_return (message);
4410  if (ret == NULL)
4411  goto out;
4412 
4413  sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4414  }
4415  else if (dbus_message_is_method_call (message,
4417  "GetMachineId"))
4418  {
4419  DBusString uuid;
4420 
4421  ret = dbus_message_new_method_return (message);
4422  if (ret == NULL)
4423  goto out;
4424 
4425  _dbus_string_init (&uuid);
4427  {
4428  const char *v_STRING = _dbus_string_get_const_data (&uuid);
4429  if (dbus_message_append_args (ret,
4430  DBUS_TYPE_STRING, &v_STRING,
4432  {
4433  sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4434  }
4435  }
4436  _dbus_string_free (&uuid);
4437  }
4438  else
4439  {
4440  /* We need to bounce anything else with this interface, otherwise apps
4441  * could start extending the interface and when we added extensions
4442  * here to DBusConnection we'd break those apps.
4443  */
4444  ret = dbus_message_new_error (message,
4446  "Unknown method invoked on org.freedesktop.DBus.Peer interface");
4447  if (ret == NULL)
4448  goto out;
4449 
4450  sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4451  }
4452 
4453 out:
4454  if (ret == NULL)
4455  {
4456  _dbus_list_free_link (expire_link);
4457  }
4458  else
4459  {
4460  /* It'll be safe to unref the reply when we unlock */
4461  expire_link->data = ret;
4462  _dbus_list_prepend_link (&connection->expired_messages, expire_link);
4463  }
4464 
4465  if (!sent)
4467 
4469 }
4470 
4477 static DBusHandlerResult
4478 _dbus_connection_run_builtin_filters_unlocked_no_update (DBusConnection *connection,
4479  DBusMessage *message)
4480 {
4481  /* We just run one filter for now but have the option to run more
4482  if the spec calls for it in the future */
4483 
4484  return _dbus_connection_peer_filter_unlocked_no_update (connection, message);
4485 }
4486 
4531 {
4532  DBusMessage *message;
4533  DBusList *link, *filter_list_copy, *message_link;
4534  DBusHandlerResult result;
4535  DBusPendingCall *pending;
4536  dbus_int32_t reply_serial;
4537  DBusDispatchStatus status;
4538  dbus_bool_t found_object;
4539 
4540  _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
4541 
4542  _dbus_verbose ("\n");
4543 
4544  CONNECTION_LOCK (connection);
4545  status = _dbus_connection_get_dispatch_status_unlocked (connection);
4546  if (status != DBUS_DISPATCH_DATA_REMAINS)
4547  {
4548  /* unlocks and calls out to user code */
4549  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4550  return status;
4551  }
4552 
4553  /* We need to ref the connection since the callback could potentially
4554  * drop the last ref to it
4555  */
4556  _dbus_connection_ref_unlocked (connection);
4557 
4558  _dbus_connection_acquire_dispatch (connection);
4559  HAVE_LOCK_CHECK (connection);
4560 
4561  message_link = _dbus_connection_pop_message_link_unlocked (connection);
4562  if (message_link == NULL)
4563  {
4564  /* another thread dispatched our stuff */
4565 
4566  _dbus_verbose ("another thread dispatched message (during acquire_dispatch above)\n");
4567 
4568  _dbus_connection_release_dispatch (connection);
4569 
4570  status = _dbus_connection_get_dispatch_status_unlocked (connection);
4571 
4572  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4573 
4574  dbus_connection_unref (connection);
4575 
4576  return status;
4577  }
4578 
4579  message = message_link->data;
4580 
4581  _dbus_verbose (" dispatching message %p (%s %s %s '%s')\n",
4582  message,
4584  dbus_message_get_interface (message) ?
4585  dbus_message_get_interface (message) :
4586  "no interface",
4587  dbus_message_get_member (message) ?
4588  dbus_message_get_member (message) :
4589  "no member",
4590  dbus_message_get_signature (message));
4591 
4593 
4594  /* Pending call handling must be first, because if you do
4595  * dbus_connection_send_with_reply_and_block() or
4596  * dbus_pending_call_block() then no handlers/filters will be run on
4597  * the reply. We want consistent semantics in the case where we
4598  * dbus_connection_dispatch() the reply.
4599  */
4600 
4601  reply_serial = dbus_message_get_reply_serial (message);
4602  pending = _dbus_hash_table_lookup_int (connection->pending_replies,
4603  reply_serial);
4604  if (pending)
4605  {
4606  _dbus_verbose ("Dispatching a pending reply\n");
4607  complete_pending_call_and_unlock (connection, pending, message);
4608  pending = NULL; /* it's probably unref'd */
4609 
4610  CONNECTION_LOCK (connection);
4611  _dbus_verbose ("pending call completed in dispatch\n");
4612  result = DBUS_HANDLER_RESULT_HANDLED;
4613  goto out;
4614  }
4615 
4616  result = _dbus_connection_run_builtin_filters_unlocked_no_update (connection, message);
4618  goto out;
4619 
4620  if (!_dbus_list_copy (&connection->filter_list, &filter_list_copy))
4621  {
4622  _dbus_connection_release_dispatch (connection);
4623  HAVE_LOCK_CHECK (connection);
4624 
4625  _dbus_connection_failed_pop (connection, message_link);
4626 
4627  /* unlocks and calls user code */
4628  _dbus_connection_update_dispatch_status_and_unlock (connection,
4630  dbus_connection_unref (connection);
4631 
4633  }
4634 
4635  _dbus_list_foreach (&filter_list_copy,
4636  (DBusForeachFunction)_dbus_message_filter_ref,
4637  NULL);
4638 
4639  /* We're still protected from dispatch() reentrancy here
4640  * since we acquired the dispatcher
4641  */
4642  CONNECTION_UNLOCK (connection);
4643 
4644  link = _dbus_list_get_first_link (&filter_list_copy);
4645  while (link != NULL)
4646  {
4647  DBusMessageFilter *filter = link->data;
4648  DBusList *next = _dbus_list_get_next_link (&filter_list_copy, link);
4649 
4650  if (filter->function == NULL)
4651  {
4652  _dbus_verbose (" filter was removed in a callback function\n");
4653  link = next;
4654  continue;
4655  }
4656 
4657  _dbus_verbose (" running filter on message %p\n", message);
4658  result = (* filter->function) (connection, message, filter->user_data);
4659 
4661  break;
4662 
4663  link = next;
4664  }
4665 
4666  _dbus_list_foreach (&filter_list_copy,
4667  (DBusForeachFunction)_dbus_message_filter_unref,
4668  NULL);
4669  _dbus_list_clear (&filter_list_copy);
4670 
4671  CONNECTION_LOCK (connection);
4672 
4673  if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
4674  {
4675  _dbus_verbose ("No memory\n");
4676  goto out;
4677  }
4678  else if (result == DBUS_HANDLER_RESULT_HANDLED)
4679  {
4680  _dbus_verbose ("filter handled message in dispatch\n");
4681  goto out;
4682  }
4683 
4684  /* We're still protected from dispatch() reentrancy here
4685  * since we acquired the dispatcher
4686  */
4687  _dbus_verbose (" running object path dispatch on message %p (%s %s %s '%s')\n",
4688  message,
4690  dbus_message_get_interface (message) ?
4691  dbus_message_get_interface (message) :
4692  "no interface",
4693  dbus_message_get_member (message) ?
4694  dbus_message_get_member (message) :
4695  "no member",
4696  dbus_message_get_signature (message));
4697 
4698  HAVE_LOCK_CHECK (connection);
4699  result = _dbus_object_tree_dispatch_and_unlock (connection->objects,
4700  message,
4701  &found_object);
4702 
4703  CONNECTION_LOCK (connection);
4704 
4706  {
4707  _dbus_verbose ("object tree handled message in dispatch\n");
4708  goto out;
4709  }
4710 
4712  {
4713  DBusMessage *reply;
4714  DBusString str;
4715  DBusPreallocatedSend *preallocated;
4716  DBusList *expire_link;
4717 
4718  _dbus_verbose (" sending error %s\n",
4720 
4721  if (!_dbus_string_init (&str))
4722  {
4724  _dbus_verbose ("no memory for error string in dispatch\n");
4725  goto out;
4726  }
4727 
4728  if (!_dbus_string_append_printf (&str,
4729  "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
4730  dbus_message_get_member (message),
4731  dbus_message_get_signature (message),
4732  dbus_message_get_interface (message)))
4733  {
4734  _dbus_string_free (&str);
4736  _dbus_verbose ("no memory for error string in dispatch\n");
4737  goto out;
4738  }
4739 
4740  reply = dbus_message_new_error (message,
4743  _dbus_string_free (&str);
4744 
4745  if (reply == NULL)
4746  {
4748  _dbus_verbose ("no memory for error reply in dispatch\n");
4749  goto out;
4750  }
4751 
4752  expire_link = _dbus_list_alloc_link (reply);
4753 
4754  if (expire_link == NULL)
4755  {
4756  dbus_message_unref (reply);
4758  _dbus_verbose ("no memory for error send in dispatch\n");
4759  goto out;
4760  }
4761 
4762  preallocated = _dbus_connection_preallocate_send_unlocked (connection);
4763 
4764  if (preallocated == NULL)
4765  {
4766  _dbus_list_free_link (expire_link);
4767  /* It's OK that this is finalized, because it hasn't been seen by
4768  * anything that could attach user callbacks */
4769  dbus_message_unref (reply);
4771  _dbus_verbose ("no memory for error send in dispatch\n");
4772  goto out;
4773  }
4774 
4775  _dbus_connection_send_preallocated_unlocked_no_update (connection, preallocated,
4776  reply, NULL);
4777  /* reply will be freed when we release the lock */
4778  _dbus_list_prepend_link (&connection->expired_messages, expire_link);
4779 
4780  result = DBUS_HANDLER_RESULT_HANDLED;
4781  }
4782 
4783  _dbus_verbose (" done dispatching %p (%s %s %s '%s') on connection %p\n", message,
4785  dbus_message_get_interface (message) ?
4786  dbus_message_get_interface (message) :
4787  "no interface",
4788  dbus_message_get_member (message) ?
4789  dbus_message_get_member (message) :
4790  "no member",
4791  dbus_message_get_signature (message),
4792  connection);
4793 
4794  out:
4795  if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
4796  {
4797  _dbus_verbose ("out of memory\n");
4798 
4799  /* Put message back, and we'll start over.
4800  * Yes this means handlers must be idempotent if they
4801  * don't return HANDLED; c'est la vie.
4802  */
4803  _dbus_connection_putback_message_link_unlocked (connection,
4804  message_link);
4805  /* now we don't want to free them */
4806  message_link = NULL;
4807  message = NULL;
4808  }
4809  else
4810  {
4811  _dbus_verbose (" ... done dispatching\n");
4812  }
4813 
4814  _dbus_connection_release_dispatch (connection);
4815  HAVE_LOCK_CHECK (connection);
4816 
4817  if (message != NULL)
4818  {
4819  /* We don't want this message to count in maximum message limits when
4820  * computing the dispatch status, below. We have to drop the lock
4821  * temporarily, because finalizing a message can trigger callbacks.
4822  *
4823  * We have a reference to the connection, and we don't use any cached
4824  * pointers to the connection's internals below this point, so it should
4825  * be safe to drop the lock and take it back. */
4826  CONNECTION_UNLOCK (connection);
4827  dbus_message_unref (message);
4828  CONNECTION_LOCK (connection);
4829  }
4830 
4831  if (message_link != NULL)
4832  _dbus_list_free_link (message_link);
4833 
4834  _dbus_verbose ("before final status update\n");
4835  status = _dbus_connection_get_dispatch_status_unlocked (connection);
4836 
4837  /* unlocks and calls user code */
4838  _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4839 
4840  dbus_connection_unref (connection);
4841 
4842  return status;
4843 }
4844 
4908  DBusAddWatchFunction add_function,
4909  DBusRemoveWatchFunction remove_function,
4910  DBusWatchToggledFunction toggled_function,
4911  void *data,
4912  DBusFreeFunction free_data_function)
4913 {
4914  dbus_bool_t retval;
4915 
4916  _dbus_return_val_if_fail (connection != NULL, FALSE);
4917 
4918  CONNECTION_LOCK (connection);
4919 
4920  retval = _dbus_watch_list_set_functions (connection->watches,
4921  add_function, remove_function,
4922  toggled_function,
4923  data, free_data_function);
4924 
4925  CONNECTION_UNLOCK (connection);
4926 
4927  return retval;
4928 }
4929 
4971  DBusAddTimeoutFunction add_function,
4972  DBusRemoveTimeoutFunction remove_function,
4973  DBusTimeoutToggledFunction toggled_function,
4974  void *data,
4975  DBusFreeFunction free_data_function)
4976 {
4977  dbus_bool_t retval;
4978 
4979  _dbus_return_val_if_fail (connection != NULL, FALSE);
4980 
4981  CONNECTION_LOCK (connection);
4982 
4983  retval = _dbus_timeout_list_set_functions (connection->timeouts,
4984  add_function, remove_function,
4985  toggled_function,
4986  data, free_data_function);
4987 
4988  CONNECTION_UNLOCK (connection);
4989 
4990  return retval;
4991 }
4992 
5007 void
5009  DBusWakeupMainFunction wakeup_main_function,
5010  void *data,
5011  DBusFreeFunction free_data_function)
5012 {
5013  void *old_data;
5014  DBusFreeFunction old_free_data;
5015 
5016  _dbus_return_if_fail (connection != NULL);
5017 
5018  CONNECTION_LOCK (connection);
5019  old_data = connection->wakeup_main_data;
5020  old_free_data = connection->free_wakeup_main_data;
5021 
5022  connection->wakeup_main_function = wakeup_main_function;
5023  connection->wakeup_main_data = data;
5024  connection->free_wakeup_main_data = free_data_function;
5025 
5026  CONNECTION_UNLOCK (connection);
5027 
5028  /* Callback outside the lock */
5029  if (old_free_data)
5030  (*old_free_data) (old_data);
5031 }
5032 
5053 void
5055  DBusDispatchStatusFunction function,
5056  void *data,
5057  DBusFreeFunction free_data_function)
5058 {
5059  void *old_data;
5060  DBusFreeFunction old_free_data;
5061 
5062  _dbus_return_if_fail (connection != NULL);
5063 
5064  CONNECTION_LOCK (connection);
5065  old_data = connection->dispatch_status_data;
5066  old_free_data = connection->free_dispatch_status_data;
5067 
5068  connection->dispatch_status_function = function;
5069  connection->dispatch_status_data = data;
5070  connection->free_dispatch_status_data = free_data_function;
5071 
5072  CONNECTION_UNLOCK (connection);
5073 
5074  /* Callback outside the lock */
5075  if (old_free_data)
5076  (*old_free_data) (old_data);
5077 }
5078 
5100  int *fd)
5101 {
5102  _dbus_return_val_if_fail (connection != NULL, FALSE);
5103  _dbus_return_val_if_fail (connection->transport != NULL, FALSE);
5104 
5105 #ifdef DBUS_WIN
5106  /* FIXME do this on a lower level */
5107  return FALSE;
5108 #endif
5109 
5110  return dbus_connection_get_socket(connection, fd);
5111 }
5112 
5130  int *fd)
5131 {
5132  dbus_bool_t retval;
5133 
5134  _dbus_return_val_if_fail (connection != NULL, FALSE);
5135  _dbus_return_val_if_fail (connection->transport != NULL, FALSE);
5136 
5137  CONNECTION_LOCK (connection);
5138 
5139  retval = _dbus_transport_get_socket_fd (connection->transport,
5140  fd);
5141 
5142  CONNECTION_UNLOCK (connection);
5143 
5144  return retval;
5145 }
5146 
5147 
5172  unsigned long *uid)
5173 {
5174  dbus_bool_t result;
5175 
5176  _dbus_return_val_if_fail (connection != NULL, FALSE);
5177  _dbus_return_val_if_fail (uid != NULL, FALSE);
5178 
5179  CONNECTION_LOCK (connection);
5180 
5182  result = FALSE;
5183  else
5184  result = _dbus_transport_get_unix_user (connection->transport,
5185  uid);
5186 
5187 #ifdef DBUS_WIN
5188  _dbus_assert (!result);
5189 #endif
5190 
5191  CONNECTION_UNLOCK (connection);
5192 
5193  return result;
5194 }
5195 
5208  unsigned long *pid)
5209 {
5210  dbus_bool_t result;
5211 
5212  _dbus_return_val_if_fail (connection != NULL, FALSE);
5213  _dbus_return_val_if_fail (pid != NULL, FALSE);
5214 
5215  CONNECTION_LOCK (connection);
5216 
5218  result = FALSE;
5219  else
5220  result = _dbus_transport_get_unix_process_id (connection->transport,
5221  pid);
5222 
5223  CONNECTION_UNLOCK (connection);
5224 
5225  return result;
5226 }
5227 
5240  void **data,
5241  dbus_int32_t *data_size)
5242 {
5243  dbus_bool_t result;
5244 
5245  _dbus_return_val_if_fail (connection != NULL, FALSE);
5246  _dbus_return_val_if_fail (data != NULL, FALSE);
5247  _dbus_return_val_if_fail (data_size != NULL, FALSE);
5248 
5249  CONNECTION_LOCK (connection);
5250 
5252  result = FALSE;
5253  else
5255  data,
5256  data_size);
5257  CONNECTION_UNLOCK (connection);
5258 
5259  return result;
5260 }
5261 
5284 void
5286  DBusAllowUnixUserFunction function,
5287  void *data,
5288  DBusFreeFunction free_data_function)
5289 {
5290  void *old_data = NULL;
5291  DBusFreeFunction old_free_function = NULL;
5292 
5293  _dbus_return_if_fail (connection != NULL);
5294 
5295  CONNECTION_LOCK (connection);
5297  function, data, free_data_function,
5298  &old_data, &old_free_function);
5299  CONNECTION_UNLOCK (connection);
5300 
5301  if (old_free_function != NULL)
5302  (* old_free_function) (old_data);
5303 }
5304 
5338  char **windows_sid_p)
5339 {
5340  dbus_bool_t result;
5341 
5342  _dbus_return_val_if_fail (connection != NULL, FALSE);
5343  _dbus_return_val_if_fail (windows_sid_p != NULL, FALSE);
5344 
5345  CONNECTION_LOCK (connection);
5346 
5348  result = FALSE;
5349  else
5350  result = _dbus_transport_get_windows_user (connection->transport,
5351  windows_sid_p);
5352 
5353 #ifdef DBUS_UNIX
5354  _dbus_assert (!result);
5355 #endif
5356 
5357  CONNECTION_UNLOCK (connection);
5358 
5359  return result;
5360 }
5361 
5383 void
5386  void *data,
5387  DBusFreeFunction free_data_function)
5388 {
5389  void *old_data = NULL;
5390  DBusFreeFunction old_free_function = NULL;
5391 
5392  _dbus_return_if_fail (connection != NULL);
5393 
5394  CONNECTION_LOCK (connection);
5396  function, data, free_data_function,
5397  &old_data, &old_free_function);
5398  CONNECTION_UNLOCK (connection);
5399 
5400  if (old_free_function != NULL)
5401  (* old_free_function) (old_data);
5402 }
5403 
5430 void
5432  dbus_bool_t value)
5433 {
5434  _dbus_return_if_fail (connection != NULL);
5435 
5436  CONNECTION_LOCK (connection);
5437  _dbus_transport_set_allow_anonymous (connection->transport, value);
5438  CONNECTION_UNLOCK (connection);
5439 }
5440 
5458 void
5460  dbus_bool_t value)
5461 {
5462  _dbus_return_if_fail (connection != NULL);
5463 
5464  CONNECTION_LOCK (connection);
5465  connection->route_peer_messages = TRUE;
5466  CONNECTION_UNLOCK (connection);
5467 }
5468 
5492  DBusHandleMessageFunction function,
5493  void *user_data,
5494  DBusFreeFunction free_data_function)
5495 {
5496  DBusMessageFilter *filter;
5497 
5498  _dbus_return_val_if_fail (connection != NULL, FALSE);
5499  _dbus_return_val_if_fail (function != NULL, FALSE);
5500 
5501  filter = dbus_new0 (DBusMessageFilter, 1);
5502  if (filter == NULL)
5503  return FALSE;
5504 
5505  _dbus_atomic_inc (&filter->refcount);
5506 
5507  CONNECTION_LOCK (connection);
5508 
5509  if (!_dbus_list_append (&connection->filter_list,
5510  filter))
5511  {
5512  _dbus_message_filter_unref (filter);
5513  CONNECTION_UNLOCK (connection);
5514  return FALSE;
5515  }
5516 
5517  /* Fill in filter after all memory allocated,
5518  * so we don't run the free_user_data_function
5519  * if the add_filter() fails
5520  */
5521 
5522  filter->function = function;
5523  filter->user_data = user_data;
5524  filter->free_user_data_function = free_data_function;
5525 
5526  CONNECTION_UNLOCK (connection);
5527  return TRUE;
5528 }
5529 
5542 void
5544  DBusHandleMessageFunction function,
5545  void *user_data)
5546 {
5547  DBusList *link;
5548  DBusMessageFilter *filter;
5549 
5550  _dbus_return_if_fail (connection != NULL);
5551  _dbus_return_if_fail (function != NULL);
5552 
5553  CONNECTION_LOCK (connection);
5554 
5555  filter = NULL;
5556 
5557  link = _dbus_list_get_last_link (&connection->filter_list);
5558  while (link != NULL)
5559  {
5560  filter = link->data;
5561 
5562  if (filter->function == function &&
5563  filter->user_data == user_data)
5564  {
5565  _dbus_list_remove_link (&connection->filter_list, link);
5566  filter->function = NULL;
5567 
5568  break;
5569  }
5570 
5571  link = _dbus_list_get_prev_link (&connection->filter_list, link);
5572  filter = NULL;
5573  }
5574 
5575  CONNECTION_UNLOCK (connection);
5576 
5577 #ifndef DBUS_DISABLE_CHECKS
5578  if (filter == NULL)
5579  {
5580  _dbus_warn_check_failed ("Attempt to remove filter function %p user data %p, but no such filter has been added\n",
5581  function, user_data);
5582  return;
5583  }
5584 #endif
5585 
5586  /* Call application code */
5587  if (filter->free_user_data_function)
5588  (* filter->free_user_data_function) (filter->user_data);
5589 
5590  filter->free_user_data_function = NULL;
5591  filter->user_data = NULL;
5592 
5593  _dbus_message_filter_unref (filter);
5594 }
5595 
5611 static dbus_bool_t
5612 _dbus_connection_register_object_path (DBusConnection *connection,
5613  dbus_bool_t fallback,
5614  const char *path,
5615  const DBusObjectPathVTable *vtable,
5616  void *user_data,
5617  DBusError *error)
5618 {
5619  char **decomposed_path;
5620  dbus_bool_t retval;
5621 
5622  if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5623  return FALSE;
5624 
5625  CONNECTION_LOCK (connection);
5626 
5627  retval = _dbus_object_tree_register (connection->objects,
5628  fallback,
5629  (const char **) decomposed_path, vtable,
5630  user_data, error);
5631 
5632  CONNECTION_UNLOCK (connection);
5633 
5634  dbus_free_string_array (decomposed_path);
5635 
5636  return retval;
5637 }
5638 
5653  const char *path,
5654  const DBusObjectPathVTable *vtable,
5655  void *user_data,
5656  DBusError *error)
5657 {
5658  _dbus_return_val_if_fail (connection != NULL, FALSE);
5659  _dbus_return_val_if_fail (path != NULL, FALSE);
5660  _dbus_return_val_if_fail (path[0] == '/', FALSE);
5661  _dbus_return_val_if_fail (vtable != NULL, FALSE);
5662 
5663  return _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, error);
5664 }
5665 
5683  const char *path,
5684  const DBusObjectPathVTable *vtable,
5685  void *user_data)
5686 {
5687  dbus_bool_t retval;
5688  DBusError error = DBUS_ERROR_INIT;
5689 
5690  _dbus_return_val_if_fail (connection != NULL, FALSE);
5691  _dbus_return_val_if_fail (path != NULL, FALSE);
5692  _dbus_return_val_if_fail (path[0] == '/', FALSE);
5693  _dbus_return_val_if_fail (vtable != NULL, FALSE);
5694 
5695  retval = _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, &error);
5696 
5698  {
5699  _dbus_warn ("%s\n", error.message);
5700  dbus_error_free (&error);
5701  return FALSE;
5702  }
5703 
5704  return retval;
5705 }
5706 
5723  const char *path,
5724  const DBusObjectPathVTable *vtable,
5725  void *user_data,
5726  DBusError *error)
5727 {
5728  _dbus_return_val_if_fail (connection != NULL, FALSE);
5729  _dbus_return_val_if_fail (path != NULL, FALSE);
5730  _dbus_return_val_if_fail (path[0] == '/', FALSE);
5731  _dbus_return_val_if_fail (vtable != NULL, FALSE);
5732 
5733  return _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, error);
5734 }
5735 
5755  const char *path,
5756  const DBusObjectPathVTable *vtable,
5757  void *user_data)
5758 {
5759  dbus_bool_t retval;
5760  DBusError error = DBUS_ERROR_INIT;
5761 
5762  _dbus_return_val_if_fail (connection != NULL, FALSE);
5763  _dbus_return_val_if_fail (path != NULL, FALSE);
5764  _dbus_return_val_if_fail (path[0] == '/', FALSE);
5765  _dbus_return_val_if_fail (vtable != NULL, FALSE);
5766 
5767  retval = _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, &error);
5768 
5770  {
5771  _dbus_warn ("%s\n", error.message);
5772  dbus_error_free (&error);
5773  return FALSE;
5774  }
5775 
5776  return retval;
5777 }
5778 
5790  const char *path)
5791 {
5792  char **decomposed_path;
5793 
5794  _dbus_return_val_if_fail (connection != NULL, FALSE);
5795  _dbus_return_val_if_fail (path != NULL, FALSE);
5796  _dbus_return_val_if_fail (path[0] == '/', FALSE);
5797 
5798  if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5799  return FALSE;
5800 
5801  CONNECTION_LOCK (connection);
5802 
5803  _dbus_object_tree_unregister_and_unlock (connection->objects, (const char **) decomposed_path);
5804 
5805  dbus_free_string_array (decomposed_path);
5806 
5807  return TRUE;
5808 }
5809 
5822  const char *path,
5823  void **data_p)
5824 {
5825  char **decomposed_path;
5826 
5827  _dbus_return_val_if_fail (connection != NULL, FALSE);
5828  _dbus_return_val_if_fail (path != NULL, FALSE);
5829  _dbus_return_val_if_fail (data_p != NULL, FALSE);
5830 
5831  *data_p = NULL;
5832 
5833  if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5834  return FALSE;
5835 
5836  CONNECTION_LOCK (connection);
5837 
5838  *data_p = _dbus_object_tree_get_user_data_unlocked (connection->objects, (const char**) decomposed_path);
5839 
5840  CONNECTION_UNLOCK (connection);
5841 
5842  dbus_free_string_array (decomposed_path);
5843 
5844  return TRUE;
5845 }
5846 
5859  const char *parent_path,
5860  char ***child_entries)
5861 {
5862  char **decomposed_path;
5863  dbus_bool_t retval;
5864  _dbus_return_val_if_fail (connection != NULL, FALSE);
5865  _dbus_return_val_if_fail (parent_path != NULL, FALSE);
5866  _dbus_return_val_if_fail (parent_path[0] == '/', FALSE);
5867  _dbus_return_val_if_fail (child_entries != NULL, FALSE);
5868 
5869  if (!_dbus_decompose_path (parent_path, strlen (parent_path), &decomposed_path, NULL))
5870  return FALSE;
5871 
5872  CONNECTION_LOCK (connection);
5873 
5875  (const char **) decomposed_path,
5876  child_entries);
5877  dbus_free_string_array (decomposed_path);
5878 
5879  return retval;
5880 }
5881 
5882 static DBusDataSlotAllocator slot_allocator;
5883 _DBUS_DEFINE_GLOBAL_LOCK (connection_slots);
5884 
5901 {
5902  return _dbus_data_slot_allocator_alloc (&slot_allocator,
5903  &_DBUS_LOCK_NAME (connection_slots),
5904  slot_p);
5905 }
5906 
5918 void
5920 {
5921  _dbus_return_if_fail (*slot_p >= 0);
5922 
5923  _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
5924 }
5925 
5950  dbus_int32_t slot,
5951  void *data,
5952  DBusFreeFunction free_data_func)
5953 {
5954  DBusFreeFunction old_free_func;
5955  void *old_data;
5956  dbus_bool_t retval;
5957 
5958  _dbus_return_val_if_fail (connection != NULL, FALSE);
5959  _dbus_return_val_if_fail (slot >= 0, FALSE);
5960 
5961  SLOTS_LOCK (connection);
5962 
5963  retval = _dbus_data_slot_list_set (&slot_allocator,
5964  &connection->slot_list,
5965  slot, data, free_data_func,
5966  &old_free_func, &old_data);
5967 
5968  SLOTS_UNLOCK (connection);
5969 
5970  if (retval)
5971  {
5972  /* Do the actual free outside the connection lock */
5973  if (old_free_func)
5974  (* old_free_func) (old_data);
5975  }
5976 
5977  return retval;
5978 }
5979 
5997 void*
5999  dbus_int32_t slot)
6000 {
6001  void *res;
6002 
6003  _dbus_return_val_if_fail (connection != NULL, NULL);
6004 
6005  SLOTS_LOCK (connection);
6006 
6007  res = _dbus_data_slot_list_get (&slot_allocator,
6008  &connection->slot_list,
6009  slot);
6010 
6011  SLOTS_UNLOCK (connection);
6012 
6013  return res;
6014 }
6015 
6022 void
6024 {
6025  _dbus_modify_sigpipe = will_modify_sigpipe != FALSE;
6026 }
6027 
6036 void
6038  long size)
6039 {
6040  _dbus_return_if_fail (connection != NULL);
6041 
6042  CONNECTION_LOCK (connection);
6044  size);
6045  CONNECTION_UNLOCK (connection);
6046 }
6047 
6054 long
6056 {
6057  long res;
6058 
6059  _dbus_return_val_if_fail (connection != NULL, 0);
6060 
6061  CONNECTION_LOCK (connection);
6062  res = _dbus_transport_get_max_message_size (connection->transport);
6063  CONNECTION_UNLOCK (connection);
6064  return res;
6065 }
6066 
6075 void
6077  long n)
6078 {
6079  _dbus_return_if_fail (connection != NULL);
6080 
6081  CONNECTION_LOCK (connection);
6083  n);
6084  CONNECTION_UNLOCK (connection);
6085 }
6086 
6093 long
6095 {
6096  long res;
6097 
6098  _dbus_return_val_if_fail (connection != NULL, 0);
6099 
6100  CONNECTION_LOCK (connection);
6102  CONNECTION_UNLOCK (connection);
6103  return res;
6104 }
6105 
6131 void
6133  long size)
6134 {
6135  _dbus_return_if_fail (connection != NULL);
6136 
6137  CONNECTION_LOCK (connection);
6139  size);
6140  CONNECTION_UNLOCK (connection);
6141 }
6142 
6149 long
6151 {
6152  long res;
6153 
6154  _dbus_return_val_if_fail (connection != NULL, 0);
6155 
6156  CONNECTION_LOCK (connection);
6158  CONNECTION_UNLOCK (connection);
6159  return res;
6160 }
6161 
6173 void
6175  long n)
6176 {
6177  _dbus_return_if_fail (connection != NULL);
6178 
6179  CONNECTION_LOCK (connection);
6181  n);
6182  CONNECTION_UNLOCK (connection);
6183 }
6184 
6191 long
6193 {
6194  long res;
6195 
6196  _dbus_return_val_if_fail (connection != NULL, 0);
6197 
6198  CONNECTION_LOCK (connection);
6200  CONNECTION_UNLOCK (connection);
6201  return res;
6202 }
6203 
6214 long
6216 {
6217  long res;
6218 
6219  _dbus_return_val_if_fail (connection != NULL, 0);
6220 
6221  CONNECTION_LOCK (connection);
6222  res = _dbus_counter_get_size_value (connection->outgoing_counter);
6223  CONNECTION_UNLOCK (connection);
6224  return res;
6225 }
6226 
6227 #ifdef DBUS_ENABLE_STATS
6228 void
6229 _dbus_connection_get_stats (DBusConnection *connection,
6230  dbus_uint32_t *in_messages,
6231  dbus_uint32_t *in_bytes,
6232  dbus_uint32_t *in_fds,
6233  dbus_uint32_t *in_peak_bytes,
6234  dbus_uint32_t *in_peak_fds,
6235  dbus_uint32_t *out_messages,
6236  dbus_uint32_t *out_bytes,
6237  dbus_uint32_t *out_fds,
6238  dbus_uint32_t *out_peak_bytes,
6239  dbus_uint32_t *out_peak_fds)
6240 {
6241  CONNECTION_LOCK (connection);
6242 
6243  if (in_messages != NULL)
6244  *in_messages = connection->n_incoming;
6245 
6246  _dbus_transport_get_stats (connection->transport,
6247  in_bytes, in_fds, in_peak_bytes, in_peak_fds);
6248 
6249  if (out_messages != NULL)
6250  *out_messages = connection->n_outgoing;
6251 
6252  if (out_bytes != NULL)
6253  *out_bytes = _dbus_counter_get_size_value (connection->outgoing_counter);
6254 
6255  if (out_fds != NULL)
6256  *out_fds = _dbus_counter_get_unix_fd_value (connection->outgoing_counter);
6257 
6258  if (out_peak_bytes != NULL)
6259  *out_peak_bytes = _dbus_counter_get_peak_size_value (connection->outgoing_counter);
6260 
6261  if (out_peak_fds != NULL)
6262  *out_peak_fds = _dbus_counter_get_peak_unix_fd_value (connection->outgoing_counter);
6263 
6264  CONNECTION_UNLOCK (connection);
6265 }
6266 #endif /* DBUS_ENABLE_STATS */
6267 
6275 long
6277 {
6278  long res;
6279 
6280  _dbus_return_val_if_fail (connection != NULL, 0);
6281 
6282  CONNECTION_LOCK (connection);
6284  CONNECTION_UNLOCK (connection);
6285  return res;
6286 }
6287 
6288 #ifdef DBUS_BUILD_TESTS
6289 
6295 const char*
6296 _dbus_connection_get_address (DBusConnection *connection)
6297 {
6298  return _dbus_transport_get_address (connection->transport);
6299 }
6300 #endif
6301