D-Bus: dbus-connection.c Source File

D-Bus 1.14.6

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
206static void
207_dbus_connection_trace_ref (DBusConnection *connection,
208 int old_refcount,
209 int new_refcount,
210 const char *why)
211{
212#ifdef DBUS_ENABLE_VERBOSE_MODE
213 static int enabled = -1;
214
215 _dbus_trace_ref ("DBusConnection", connection, old_refcount, new_refcount,
216 why, "DBUS_CONNECTION_TRACE", &enabled);
217#endif
218}
219
223 typedef struct DBusMessageFilter DBusMessageFilter;
224
228 struct DBusMessageFilter
229{
230 DBusAtomic refcount;
231 DBusHandleMessageFunction function;
232 void *user_data;
233 DBusFreeFunction free_user_data_function;
234};
235
236
240 struct DBusPreallocatedSend
241{
242 DBusConnection *connection;
243 DBusList *queue_link;
244 DBusList *counter_link;
245};
246
247#if HAVE_DECL_MSG_NOSIGNAL
248static DBusAtomic _dbus_modify_sigpipe = { FALSE };
249#else
250static DBusAtomic _dbus_modify_sigpipe = { TRUE };
251#endif
252
256 struct DBusConnection
257{
258 DBusAtomic refcount;
260 DBusRMutex *mutex;
262 DBusCMutex *dispatch_mutex;
263 DBusCondVar *dispatch_cond;
264 DBusCMutex *io_path_mutex;
265 DBusCondVar *io_path_cond;
267 DBusList *outgoing_messages;
268 DBusList *incoming_messages;
269 DBusList *expired_messages;
271 DBusMessage *message_borrowed;
275 int n_outgoing;
276 int n_incoming;
278 DBusCounter *outgoing_counter;
280 DBusTransport *transport;
281 DBusWatchList *watches;
282 DBusTimeoutList *timeouts;
284 DBusList *filter_list;
286 DBusRMutex *slot_mutex;
287 DBusDataSlotList slot_list;
289 DBusHashTable *pending_replies;
291 dbus_uint32_t client_serial;
292 DBusList *disconnect_message_link;
294 DBusWakeupMainFunction wakeup_main_function;
295 void *wakeup_main_data;
296 DBusFreeFunction free_wakeup_main_data;
298 DBusDispatchStatusFunction dispatch_status_function;
299 void *dispatch_status_data;
300 DBusFreeFunction free_dispatch_status_data;
302 DBusDispatchStatus last_dispatch_status;
304 DBusObjectTree *objects;
306 char *server_guid;
308 /* These two MUST be bools and not bitfields, because they are protected by a separate lock
309 * from connection->mutex and all bitfields in a word have to be read/written together.
310 * So you can't have a different lock for different bitfields in the same word.
311 */
312 dbus_bool_t dispatch_acquired;
313 dbus_bool_t io_path_acquired;
315 unsigned int shareable : 1;
317 unsigned int exit_on_disconnect : 1;
319 unsigned int builtin_filters_enabled : 1;
321 unsigned int route_peer_messages : 1;
323 unsigned int disconnected_message_arrived : 1;
327 unsigned int disconnected_message_processed : 1;
331#ifndef DBUS_DISABLE_CHECKS
332 unsigned int have_connection_lock : 1;
333#endif
334
335#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
336 int generation;
337#endif
338};
339
340static DBusDispatchStatus _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection);
341static void _dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection,
342 DBusDispatchStatus new_status);
343static void _dbus_connection_last_unref (DBusConnection *connection);
344static void _dbus_connection_acquire_dispatch (DBusConnection *connection);
345static void _dbus_connection_release_dispatch (DBusConnection *connection);
346static DBusDispatchStatus _dbus_connection_flush_unlocked (DBusConnection *connection);
347static void _dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection);
348static dbus_bool_t _dbus_connection_get_is_connected_unlocked (DBusConnection *connection);
349static dbus_bool_t _dbus_connection_peek_for_reply_unlocked (DBusConnection *connection,
350 dbus_uint32_t client_serial);
351
352static DBusMessageFilter *
353_dbus_message_filter_ref (DBusMessageFilter *filter)
354{
355#ifdef DBUS_DISABLE_ASSERT
356 _dbus_atomic_inc (&filter->refcount);
357#else
358 dbus_int32_t old_value;
359
360 old_value = _dbus_atomic_inc (&filter->refcount);
361 _dbus_assert (old_value > 0);
362#endif
363
364 return filter;
365}
366
367static void
368_dbus_message_filter_unref (DBusMessageFilter *filter)
369{
370 dbus_int32_t old_value;
371
372 old_value = _dbus_atomic_dec (&filter->refcount);
373 _dbus_assert (old_value > 0);
374
375 if (old_value == 1)
376 {
377 if (filter->free_user_data_function)
378 (* filter->free_user_data_function) (filter->user_data);
379
380 dbus_free (filter);
381 }
382}
383
389void
390_dbus_connection_lock (DBusConnection *connection)
391{
392 CONNECTION_LOCK (connection);
393}
394
400void
401_dbus_connection_unlock (DBusConnection *connection)
402{
403 DBusList *expired_messages;
404 DBusList *iter;
405
406 if (TRACE_LOCKS)
407 {
408 _dbus_verbose ("UNLOCK\n");
409 }
410
411 /* If we had messages that expired (fell off the incoming or outgoing
412 * queues) while we were locked, actually release them now */
413 expired_messages = connection->expired_messages;
414 connection->expired_messages = NULL;
415
416 RELEASING_LOCK_CHECK (connection);
417 _dbus_rmutex_unlock (connection->mutex);
418
419 for (iter = _dbus_list_pop_first_link (&expired_messages);
420 iter != NULL;
421 iter = _dbus_list_pop_first_link (&expired_messages))
422 {
423 DBusMessage *message = iter->data;
424
425 dbus_message_unref (message);
426 _dbus_list_free_link (iter);
427 }
428}
429
437static void
438_dbus_connection_wakeup_mainloop (DBusConnection *connection)
439{
440 if (connection->wakeup_main_function)
441 (*connection->wakeup_main_function) (connection->wakeup_main_data);
442}
443
444#ifdef DBUS_ENABLE_EMBEDDED_TESTS
457void
458_dbus_connection_test_get_locks (DBusConnection *connection,
459 DBusMutex **mutex_loc,
460 DBusMutex **dispatch_mutex_loc,
461 DBusMutex **io_path_mutex_loc,
462 DBusCondVar **dispatch_cond_loc,
463 DBusCondVar **io_path_cond_loc)
464{
465 *mutex_loc = (DBusMutex *) connection->mutex;
466 *dispatch_mutex_loc = (DBusMutex *) connection->dispatch_mutex;
467 *io_path_mutex_loc = (DBusMutex *) connection->io_path_mutex;
468 *dispatch_cond_loc = connection->dispatch_cond;
469 *io_path_cond_loc = connection->io_path_cond;
470}
471#endif
472
481void
482_dbus_connection_queue_received_message_link (DBusConnection *connection,
483 DBusList *link)
484{
485 DBusPendingCall *pending;
486 dbus_uint32_t reply_serial;
487 DBusMessage *message;
488
489 _dbus_assert (_dbus_transport_peek_is_authenticated (connection->transport));
490
491 _dbus_list_append_link (&connection->incoming_messages,
492 link);
493 message = link->data;
494
495 /* If this is a reply we're waiting on, remove timeout for it */
496 reply_serial = dbus_message_get_reply_serial (message);
497 if (reply_serial != 0)
498 {
499 pending = _dbus_hash_table_lookup_int (connection->pending_replies,
500 reply_serial);
501 if (pending != NULL)
502 {
503 if (_dbus_pending_call_is_timeout_added_unlocked (pending))
504 _dbus_connection_remove_timeout_unlocked (connection,
505 _dbus_pending_call_get_timeout_unlocked (pending));
506
507 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
508 }
509 }
510
511
512
513 connection->n_incoming += 1;
514
515 _dbus_connection_wakeup_mainloop (connection);
516
517 _dbus_verbose ("Message %p (%s %s %s %s '%s' reply to %u) added to incoming queue %p, %d incoming\n",
518 message,
519 dbus_message_type_to_string (dbus_message_get_type (message)),
520 dbus_message_get_path (message) ?
521 dbus_message_get_path (message) :
522 "no path",
523 dbus_message_get_interface (message) ?
524 dbus_message_get_interface (message) :
525 "no interface",
526 dbus_message_get_member (message) ?
527 dbus_message_get_member (message) :
528 "no member",
529 dbus_message_get_signature (message),
530 dbus_message_get_reply_serial (message),
531 connection,
532 connection->n_incoming);
533
534 _dbus_message_trace_ref (message, -1, -1,
535 "_dbus_conection_queue_received_message_link");
536}
537
546void
547_dbus_connection_queue_synthesized_message_link (DBusConnection *connection,
548 DBusList *link)
549{
550 HAVE_LOCK_CHECK (connection);
551
552 _dbus_list_append_link (&connection->incoming_messages, link);
553
554 connection->n_incoming += 1;
555
556 _dbus_connection_wakeup_mainloop (connection);
557
558 _dbus_message_trace_ref (link->data, -1, -1,
559 "_dbus_connection_queue_synthesized_message_link");
560
561 _dbus_verbose ("Synthesized message %p added to incoming queue %p, %d incoming\n",
562 link->data, connection, connection->n_incoming);
563}
564
565
573 dbus_bool_t
574_dbus_connection_has_messages_to_send_unlocked (DBusConnection *connection)
575{
576 HAVE_LOCK_CHECK (connection);
577 return connection->outgoing_messages != NULL;
578}
579
589 dbus_bool_t
590dbus_connection_has_messages_to_send (DBusConnection *connection)
591{
592 dbus_bool_t v;
593
594 _dbus_return_val_if_fail (connection != NULL, FALSE);
595
596 CONNECTION_LOCK (connection);
597 v = _dbus_connection_has_messages_to_send_unlocked (connection);
598 CONNECTION_UNLOCK (connection);
599
600 return v;
601}
602
610 DBusMessage*
611_dbus_connection_get_message_to_send (DBusConnection *connection)
612{
613 HAVE_LOCK_CHECK (connection);
614
615 return _dbus_list_get_last (&connection->outgoing_messages);
616}
617
626void
627_dbus_connection_message_sent_unlocked (DBusConnection *connection,
628 DBusMessage *message)
629{
630 DBusList *link;
631
632 HAVE_LOCK_CHECK (connection);
633
634 /* This can be called before we even complete authentication, since
635 * it's called on disconnect to clean up the outgoing queue.
636 * It's also called as we successfully send each message.
637 */
638
639 link = _dbus_list_get_last_link (&connection->outgoing_messages);
640 _dbus_assert (link != NULL);
641 _dbus_assert (link->data == message);
642
643 _dbus_list_unlink (&connection->outgoing_messages,
644 link);
645 _dbus_list_prepend_link (&connection->expired_messages, link);
646
647 connection->n_outgoing -= 1;
648
649 _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from outgoing queue %p, %d left to send\n",
650 message,
651 dbus_message_type_to_string (dbus_message_get_type (message)),
652 dbus_message_get_path (message) ?
653 dbus_message_get_path (message) :
654 "no path",
655 dbus_message_get_interface (message) ?
656 dbus_message_get_interface (message) :
657 "no interface",
658 dbus_message_get_member (message) ?
659 dbus_message_get_member (message) :
660 "no member",
661 dbus_message_get_signature (message),
662 connection, connection->n_outgoing);
663
664 /* It's OK that in principle we call the notify function, because for the
665 * outgoing limit, there isn't one */
666 _dbus_message_remove_counter (message, connection->outgoing_counter);
667
668 /* The message will actually be unreffed when we unlock */
669}
670
672 typedef dbus_bool_t (* DBusWatchAddFunction) (DBusWatchList *list,
673 DBusWatch *watch);
675 typedef void (* DBusWatchRemoveFunction) (DBusWatchList *list,
676 DBusWatch *watch);
678 typedef void (* DBusWatchToggleFunction) (DBusWatchList *list,
679 DBusWatch *watch,
680 dbus_bool_t enabled);
681
682static dbus_bool_t
683protected_change_watch (DBusConnection *connection,
684 DBusWatch *watch,
685 DBusWatchAddFunction add_function,
686 DBusWatchRemoveFunction remove_function,
687 DBusWatchToggleFunction toggle_function,
688 dbus_bool_t enabled)
689{
690 dbus_bool_t retval;
691
692 HAVE_LOCK_CHECK (connection);
693
694 /* The original purpose of protected_change_watch() was to hold a
695 * ref on the connection while dropping the connection lock, then
696 * calling out to the app. This was a broken hack that did not
697 * work, since the connection was in a hosed state (no WatchList
698 * field) while calling out.
699 *
700 * So for now we'll just keep the lock while calling out. This means
701 * apps are not allowed to call DBusConnection methods inside a
702 * watch function or they will deadlock.
703 *
704 * The "real fix" is to use the _and_unlock() pattern found
705 * elsewhere in the code, to defer calling out to the app until
706 * we're about to drop locks and return flow of control to the app
707 * anyway.
708 *
709 * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144
710 */
711
712 if (connection->watches)
713 {
714 if (add_function)
715 retval = (* add_function) (connection->watches, watch);
716 else if (remove_function)
717 {
718 retval = TRUE;
719 (* remove_function) (connection->watches, watch);
720 }
721 else
722 {
723 retval = TRUE;
724 (* toggle_function) (connection->watches, watch, enabled);
725 }
726 return retval;
727 }
728 else
729 return FALSE;
730}
731
732
744 dbus_bool_t
745_dbus_connection_add_watch_unlocked (DBusConnection *connection,
746 DBusWatch *watch)
747{
748 return protected_change_watch (connection, watch,
749 _dbus_watch_list_add_watch,
750 NULL, NULL, FALSE);
751}
752
762void
763_dbus_connection_remove_watch_unlocked (DBusConnection *connection,
764 DBusWatch *watch)
765{
766 protected_change_watch (connection, watch,
767 NULL,
768 _dbus_watch_list_remove_watch,
769 NULL, FALSE);
770}
771
782void
783_dbus_connection_toggle_watch_unlocked (DBusConnection *connection,
784 DBusWatch *watch,
785 dbus_bool_t enabled)
786{
787 _dbus_assert (watch != NULL);
788
789 protected_change_watch (connection, watch,
790 NULL, NULL,
791 _dbus_watch_list_toggle_watch,
792 enabled);
793}
794
796 typedef dbus_bool_t (* DBusTimeoutAddFunction) (DBusTimeoutList *list,
797 DBusTimeout *timeout);
799 typedef void (* DBusTimeoutRemoveFunction) (DBusTimeoutList *list,
800 DBusTimeout *timeout);
802 typedef void (* DBusTimeoutToggleFunction) (DBusTimeoutList *list,
803 DBusTimeout *timeout,
804 dbus_bool_t enabled);
805
806static dbus_bool_t
807protected_change_timeout (DBusConnection *connection,
808 DBusTimeout *timeout,
809 DBusTimeoutAddFunction add_function,
810 DBusTimeoutRemoveFunction remove_function,
811 DBusTimeoutToggleFunction toggle_function,
812 dbus_bool_t enabled)
813{
814 dbus_bool_t retval;
815
816 HAVE_LOCK_CHECK (connection);
817
818 /* The original purpose of protected_change_timeout() was to hold a
819 * ref on the connection while dropping the connection lock, then
820 * calling out to the app. This was a broken hack that did not
821 * work, since the connection was in a hosed state (no TimeoutList
822 * field) while calling out.
823 *
824 * So for now we'll just keep the lock while calling out. This means
825 * apps are not allowed to call DBusConnection methods inside a
826 * timeout function or they will deadlock.
827 *
828 * The "real fix" is to use the _and_unlock() pattern found
829 * elsewhere in the code, to defer calling out to the app until
830 * we're about to drop locks and return flow of control to the app
831 * anyway.
832 *
833 * See http://lists.freedesktop.org/archives/dbus/2007-July/thread.html#8144
834 */
835
836 if (connection->timeouts)
837 {
838 if (add_function)
839 retval = (* add_function) (connection->timeouts, timeout);
840 else if (remove_function)
841 {
842 retval = TRUE;
843 (* remove_function) (connection->timeouts, timeout);
844 }
845 else
846 {
847 retval = TRUE;
848 (* toggle_function) (connection->timeouts, timeout, enabled);
849 }
850 return retval;
851 }
852 else
853 return FALSE;
854}
855
868 dbus_bool_t
869_dbus_connection_add_timeout_unlocked (DBusConnection *connection,
870 DBusTimeout *timeout)
871{
872 return protected_change_timeout (connection, timeout,
873 _dbus_timeout_list_add_timeout,
874 NULL, NULL, FALSE);
875}
876
886void
887_dbus_connection_remove_timeout_unlocked (DBusConnection *connection,
888 DBusTimeout *timeout)
889{
890 protected_change_timeout (connection, timeout,
891 NULL,
892 _dbus_timeout_list_remove_timeout,
893 NULL, FALSE);
894}
895
906void
907_dbus_connection_toggle_timeout_unlocked (DBusConnection *connection,
908 DBusTimeout *timeout,
909 dbus_bool_t enabled)
910{
911 protected_change_timeout (connection, timeout,
912 NULL, NULL,
913 _dbus_timeout_list_toggle_timeout,
914 enabled);
915}
916
917static dbus_bool_t
918_dbus_connection_attach_pending_call_unlocked (DBusConnection *connection,
919 DBusPendingCall *pending)
920{
921 dbus_uint32_t reply_serial;
922 DBusTimeout *timeout;
923
924 HAVE_LOCK_CHECK (connection);
925
926 reply_serial = _dbus_pending_call_get_reply_serial_unlocked (pending);
927
928 _dbus_assert (reply_serial != 0);
929
930 timeout = _dbus_pending_call_get_timeout_unlocked (pending);
931
932 if (timeout)
933 {
934 if (!_dbus_connection_add_timeout_unlocked (connection, timeout))
935 return FALSE;
936
937 if (!_dbus_hash_table_insert_int (connection->pending_replies,
938 reply_serial,
939 pending))
940 {
941 _dbus_connection_remove_timeout_unlocked (connection, timeout);
942
943 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
944 HAVE_LOCK_CHECK (connection);
945 return FALSE;
946 }
947
948 _dbus_pending_call_set_timeout_added_unlocked (pending, TRUE);
949 }
950 else
951 {
952 if (!_dbus_hash_table_insert_int (connection->pending_replies,
953 reply_serial,
954 pending))
955 {
956 HAVE_LOCK_CHECK (connection);
957 return FALSE;
958 }
959 }
960
961 _dbus_pending_call_ref_unlocked (pending);
962
963 HAVE_LOCK_CHECK (connection);
964
965 return TRUE;
966}
967
968static void
969free_pending_call_on_hash_removal (void *data)
970{
971 DBusPendingCall *pending;
972 DBusConnection *connection;
973
974 if (data == NULL)
975 return;
976
977 pending = data;
978
979 connection = _dbus_pending_call_get_connection_unlocked (pending);
980
981 HAVE_LOCK_CHECK (connection);
982
983 if (_dbus_pending_call_is_timeout_added_unlocked (pending))
984 {
985 _dbus_connection_remove_timeout_unlocked (connection,
986 _dbus_pending_call_get_timeout_unlocked (pending));
987
988 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
989 }
990
991 /* FIXME 1.0? this is sort of dangerous and undesirable to drop the lock
992 * here, but the pending call finalizer could in principle call out to
993 * application code so we pretty much have to... some larger code reorg
994 * might be needed.
995 */
996 _dbus_connection_ref_unlocked (connection);
997 _dbus_pending_call_unref_and_unlock (pending);
998 CONNECTION_LOCK (connection);
999 _dbus_connection_unref_unlocked (connection);
1000}
1001
1002static void
1003_dbus_connection_detach_pending_call_unlocked (DBusConnection *connection,
1004 DBusPendingCall *pending)
1005{
1006 /* This ends up unlocking to call the pending call finalizer, which is unexpected to
1007 * say the least.
1008 */
1009 _dbus_hash_table_remove_int (connection->pending_replies,
1010 _dbus_pending_call_get_reply_serial_unlocked (pending));
1011}
1012
1013static void
1014_dbus_connection_detach_pending_call_and_unlock (DBusConnection *connection,
1015 DBusPendingCall *pending)
1016{
1017 /* The idea here is to avoid finalizing the pending call
1018 * with the lock held, since there's a destroy notifier
1019 * in pending call that goes out to application code.
1020 *
1021 * There's an extra unlock inside the hash table
1022 * "free pending call" function FIXME...
1023 */
1024 _dbus_pending_call_ref_unlocked (pending);
1025 _dbus_hash_table_remove_int (connection->pending_replies,
1026 _dbus_pending_call_get_reply_serial_unlocked (pending));
1027
1028 if (_dbus_pending_call_is_timeout_added_unlocked (pending))
1029 _dbus_connection_remove_timeout_unlocked (connection,
1030 _dbus_pending_call_get_timeout_unlocked (pending));
1031
1032 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
1033
1034 _dbus_pending_call_unref_and_unlock (pending);
1035}
1036
1045void
1046_dbus_connection_remove_pending_call (DBusConnection *connection,
1047 DBusPendingCall *pending)
1048{
1049 CONNECTION_LOCK (connection);
1050 _dbus_connection_detach_pending_call_and_unlock (connection, pending);
1051}
1052
1062static dbus_bool_t
1063_dbus_connection_acquire_io_path (DBusConnection *connection,
1064 int timeout_milliseconds)
1065{
1066 dbus_bool_t we_acquired;
1067
1068 HAVE_LOCK_CHECK (connection);
1069
1070 /* We don't want the connection to vanish */
1071 _dbus_connection_ref_unlocked (connection);
1072
1073 /* We will only touch io_path_acquired which is protected by our mutex */
1074 CONNECTION_UNLOCK (connection);
1075
1076 _dbus_verbose ("locking io_path_mutex\n");
1077 _dbus_cmutex_lock (connection->io_path_mutex);
1078
1079 _dbus_verbose ("start connection->io_path_acquired = %d timeout = %d\n",
1080 connection->io_path_acquired, timeout_milliseconds);
1081
1082 we_acquired = FALSE;
1083
1084 if (connection->io_path_acquired)
1085 {
1086 if (timeout_milliseconds != -1)
1087 {
1088 _dbus_verbose ("waiting %d for IO path to be acquirable\n",
1089 timeout_milliseconds);
1090
1091 if (!_dbus_condvar_wait_timeout (connection->io_path_cond,
1092 connection->io_path_mutex,
1093 timeout_milliseconds))
1094 {
1095 /* We timed out before anyone signaled. */
1096 /* (writing the loop to handle the !timedout case by
1097 * waiting longer if needed is a pain since dbus
1098 * wraps pthread_cond_timedwait to take a relative
1099 * time instead of absolute, something kind of stupid
1100 * on our part. for now it doesn't matter, we will just
1101 * end up back here eventually.)
1102 */
1103 }
1104 }
1105 else
1106 {
1107 while (connection->io_path_acquired)
1108 {
1109 _dbus_verbose ("waiting for IO path to be acquirable\n");
1110 _dbus_condvar_wait (connection->io_path_cond,
1111 connection->io_path_mutex);
1112 }
1113 }
1114 }
1115
1116 if (!connection->io_path_acquired)
1117 {
1118 we_acquired = TRUE;
1119 connection->io_path_acquired = TRUE;
1120 }
1121
1122 _dbus_verbose ("end connection->io_path_acquired = %d we_acquired = %d\n",
1123 connection->io_path_acquired, we_acquired);
1124
1125 _dbus_verbose ("unlocking io_path_mutex\n");
1126 _dbus_cmutex_unlock (connection->io_path_mutex);
1127
1128 CONNECTION_LOCK (connection);
1129
1130 HAVE_LOCK_CHECK (connection);
1131
1132 _dbus_connection_unref_unlocked (connection);
1133
1134 return we_acquired;
1135}
1136
1144static void
1145_dbus_connection_release_io_path (DBusConnection *connection)
1146{
1147 HAVE_LOCK_CHECK (connection);
1148
1149 _dbus_verbose ("locking io_path_mutex\n");
1150 _dbus_cmutex_lock (connection->io_path_mutex);
1151
1152 _dbus_assert (connection->io_path_acquired);
1153
1154 _dbus_verbose ("start connection->io_path_acquired = %d\n",
1155 connection->io_path_acquired);
1156
1157 connection->io_path_acquired = FALSE;
1158 _dbus_condvar_wake_one (connection->io_path_cond);
1159
1160 _dbus_verbose ("unlocking io_path_mutex\n");
1161 _dbus_cmutex_unlock (connection->io_path_mutex);
1162}
1163
1199void
1200_dbus_connection_do_iteration_unlocked (DBusConnection *connection,
1201 DBusPendingCall *pending,
1202 unsigned int flags,
1203 int timeout_milliseconds)
1204{
1205 _dbus_verbose ("start\n");
1206
1207 HAVE_LOCK_CHECK (connection);
1208
1209 if (connection->n_outgoing == 0)
1210 flags &= ~DBUS_ITERATION_DO_WRITING;
1211
1212 if (_dbus_connection_acquire_io_path (connection,
1213 (flags & DBUS_ITERATION_BLOCK) ? timeout_milliseconds : 0))
1214 {
1215 HAVE_LOCK_CHECK (connection);
1216
1217 if ( (pending != NULL) && _dbus_pending_call_get_completed_unlocked(pending))
1218 {
1219 _dbus_verbose ("pending call completed while acquiring I/O path");
1220 }
1221 else if ( (pending != NULL) &&
1222 _dbus_connection_peek_for_reply_unlocked (connection,
1223 _dbus_pending_call_get_reply_serial_unlocked (pending)))
1224 {
1225 _dbus_verbose ("pending call completed while acquiring I/O path (reply found in queue)");
1226 }
1227 else
1228 {
1229 _dbus_transport_do_iteration (connection->transport,
1230 flags, timeout_milliseconds);
1231 }
1232
1233 _dbus_connection_release_io_path (connection);
1234 }
1235
1236 HAVE_LOCK_CHECK (connection);
1237
1238 _dbus_verbose ("end\n");
1239}
1240
1250 DBusConnection*
1251_dbus_connection_new_for_transport (DBusTransport *transport)
1252{
1253 DBusConnection *connection;
1254 DBusWatchList *watch_list;
1255 DBusTimeoutList *timeout_list;
1256 DBusHashTable *pending_replies;
1257 DBusList *disconnect_link;
1258 DBusMessage *disconnect_message;
1259 DBusCounter *outgoing_counter;
1260 DBusObjectTree *objects;
1261
1262 watch_list = NULL;
1263 connection = NULL;
1264 pending_replies = NULL;
1265 timeout_list = NULL;
1266 disconnect_link = NULL;
1267 disconnect_message = NULL;
1268 outgoing_counter = NULL;
1269 objects = NULL;
1270
1271 watch_list = _dbus_watch_list_new ();
1272 if (watch_list == NULL)
1273 goto error;
1274
1275 timeout_list = _dbus_timeout_list_new ();
1276 if (timeout_list == NULL)
1277 goto error;
1278
1279 pending_replies =
1280 _dbus_hash_table_new (DBUS_HASH_INT,
1281 NULL,
1282 (DBusFreeFunction)free_pending_call_on_hash_removal);
1283 if (pending_replies == NULL)
1284 goto error;
1285
1286 connection = dbus_new0 (DBusConnection, 1);
1287 if (connection == NULL)
1288 goto error;
1289
1290 _dbus_rmutex_new_at_location (&connection->mutex);
1291 if (connection->mutex == NULL)
1292 goto error;
1293
1294 _dbus_cmutex_new_at_location (&connection->io_path_mutex);
1295 if (connection->io_path_mutex == NULL)
1296 goto error;
1297
1298 _dbus_cmutex_new_at_location (&connection->dispatch_mutex);
1299 if (connection->dispatch_mutex == NULL)
1300 goto error;
1301
1302 _dbus_condvar_new_at_location (&connection->dispatch_cond);
1303 if (connection->dispatch_cond == NULL)
1304 goto error;
1305
1306 _dbus_condvar_new_at_location (&connection->io_path_cond);
1307 if (connection->io_path_cond == NULL)
1308 goto error;
1309
1310 _dbus_rmutex_new_at_location (&connection->slot_mutex);
1311 if (connection->slot_mutex == NULL)
1312 goto error;
1313
1314 disconnect_message = dbus_message_new_signal (DBUS_PATH_LOCAL,
1315 DBUS_INTERFACE_LOCAL,
1316 "Disconnected");
1317
1318 if (disconnect_message == NULL)
1319 goto error;
1320
1321 disconnect_link = _dbus_list_alloc_link (disconnect_message);
1322 if (disconnect_link == NULL)
1323 goto error;
1324
1325 outgoing_counter = _dbus_counter_new ();
1326 if (outgoing_counter == NULL)
1327 goto error;
1328
1329 objects = _dbus_object_tree_new (connection);
1330 if (objects == NULL)
1331 goto error;
1332
1333 if (_dbus_atomic_get (&_dbus_modify_sigpipe) != 0)
1334 _dbus_disable_sigpipe ();
1335
1336 /* initialized to 0: use atomic op to avoid mixing atomic and non-atomic */
1337 _dbus_atomic_inc (&connection->refcount);
1338 connection->transport = transport;
1339 connection->watches = watch_list;
1340 connection->timeouts = timeout_list;
1341 connection->pending_replies = pending_replies;
1342 connection->outgoing_counter = outgoing_counter;
1343 connection->filter_list = NULL;
1344 connection->last_dispatch_status = DBUS_DISPATCH_COMPLETE; /* so we're notified first time there's data */
1345 connection->objects = objects;
1346 connection->exit_on_disconnect = FALSE;
1347 connection->shareable = FALSE;
1348 connection->builtin_filters_enabled = TRUE;
1349 connection->route_peer_messages = FALSE;
1350 connection->disconnected_message_arrived = FALSE;
1351 connection->disconnected_message_processed = FALSE;
1352
1353#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
1354 connection->generation = _dbus_current_generation;
1355#endif
1356
1357 _dbus_data_slot_list_init (&connection->slot_list);
1358
1359 connection->client_serial = 1;
1360
1361 connection->disconnect_message_link = disconnect_link;
1362
1363 CONNECTION_LOCK (connection);
1364
1365 if (!_dbus_transport_set_connection (transport, connection))
1366 {
1367 CONNECTION_UNLOCK (connection);
1368
1369 goto error;
1370 }
1371
1372 _dbus_transport_ref (transport);
1373
1374 CONNECTION_UNLOCK (connection);
1375
1376 _dbus_connection_trace_ref (connection, 0, 1, "new_for_transport");
1377 return connection;
1378
1379 error:
1380 if (disconnect_message != NULL)
1381 dbus_message_unref (disconnect_message);
1382
1383 if (disconnect_link != NULL)
1384 _dbus_list_free_link (disconnect_link);
1385
1386 if (connection != NULL)
1387 {
1388 _dbus_condvar_free_at_location (&connection->io_path_cond);
1389 _dbus_condvar_free_at_location (&connection->dispatch_cond);
1390 _dbus_rmutex_free_at_location (&connection->mutex);
1391 _dbus_cmutex_free_at_location (&connection->io_path_mutex);
1392 _dbus_cmutex_free_at_location (&connection->dispatch_mutex);
1393 _dbus_rmutex_free_at_location (&connection->slot_mutex);
1394 dbus_free (connection);
1395 }
1396 if (pending_replies)
1397 _dbus_hash_table_unref (pending_replies);
1398
1399 if (watch_list)
1400 _dbus_watch_list_free (watch_list);
1401
1402 if (timeout_list)
1403 _dbus_timeout_list_free (timeout_list);
1404
1405 if (outgoing_counter)
1406 _dbus_counter_unref (outgoing_counter);
1407
1408 if (objects)
1409 _dbus_object_tree_unref (objects);
1410
1411 return NULL;
1412}
1413
1421 DBusConnection *
1422_dbus_connection_ref_unlocked (DBusConnection *connection)
1423{
1424 dbus_int32_t old_refcount;
1425
1426 _dbus_assert (connection != NULL);
1427 _dbus_assert (connection->generation == _dbus_current_generation);
1428
1429 HAVE_LOCK_CHECK (connection);
1430
1431 old_refcount = _dbus_atomic_inc (&connection->refcount);
1432 _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
1433 "ref_unlocked");
1434
1435 return connection;
1436}
1437
1444void
1445_dbus_connection_unref_unlocked (DBusConnection *connection)
1446{
1447 dbus_int32_t old_refcount;
1448
1449 HAVE_LOCK_CHECK (connection);
1450
1451 _dbus_assert (connection != NULL);
1452
1453 old_refcount = _dbus_atomic_dec (&connection->refcount);
1454
1455 _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
1456 "unref_unlocked");
1457
1458 if (old_refcount == 1)
1459 _dbus_connection_last_unref (connection);
1460}
1461
1462static dbus_uint32_t
1463_dbus_connection_get_next_client_serial (DBusConnection *connection)
1464{
1465 dbus_uint32_t serial;
1466
1467 serial = connection->client_serial++;
1468
1469 if (connection->client_serial == 0)
1470 connection->client_serial = 1;
1471
1472 return serial;
1473}
1474
1488 dbus_bool_t
1489_dbus_connection_handle_watch (DBusWatch *watch,
1490 unsigned int condition,
1491 void *data)
1492{
1493 DBusConnection *connection;
1494 dbus_bool_t retval;
1495 DBusDispatchStatus status;
1496
1497 connection = data;
1498
1499 _dbus_verbose ("start\n");
1500
1501 CONNECTION_LOCK (connection);
1502
1503 if (!_dbus_connection_acquire_io_path (connection, 1))
1504 {
1505 /* another thread is handling the message */
1506 CONNECTION_UNLOCK (connection);
1507 return TRUE;
1508 }
1509
1510 HAVE_LOCK_CHECK (connection);
1511 retval = _dbus_transport_handle_watch (connection->transport,
1512 watch, condition);
1513
1514 _dbus_connection_release_io_path (connection);
1515
1516 HAVE_LOCK_CHECK (connection);
1517
1518 _dbus_verbose ("middle\n");
1519
1520 status = _dbus_connection_get_dispatch_status_unlocked (connection);
1521
1522 /* this calls out to user code */
1523 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
1524
1525 _dbus_verbose ("end\n");
1526
1527 return retval;
1528}
1529
1530/* Protected by _DBUS_LOCK (shared_connections) */
1531static DBusHashTable *shared_connections = NULL;
1532static DBusList *shared_connections_no_guid = NULL;
1533
1534static void
1535close_connection_on_shutdown (DBusConnection *connection)
1536{
1537 DBusMessage *message;
1538
1539 dbus_connection_ref (connection);
1540 _dbus_connection_close_possibly_shared (connection);
1541
1542 /* Churn through to the Disconnected message */
1543 while ((message = dbus_connection_pop_message (connection)))
1544 {
1545 dbus_message_unref (message);
1546 }
1547 dbus_connection_unref (connection);
1548}
1549
1550static void
1551shared_connections_shutdown (void *data)
1552{
1553 int n_entries;
1554
1555 if (!_DBUS_LOCK (shared_connections))
1556 {
1557 /* We'd have initialized locks before adding anything, so there
1558 * can't be anything there. */
1559 return;
1560 }
1561
1562 /* This is a little bit unpleasant... better ideas? */
1563 while ((n_entries = _dbus_hash_table_get_n_entries (shared_connections)) > 0)
1564 {
1565 DBusConnection *connection;
1566 DBusHashIter iter;
1567
1568 _dbus_hash_iter_init (shared_connections, &iter);
1569 _dbus_hash_iter_next (&iter);
1570
1571 connection = _dbus_hash_iter_get_value (&iter);
1572
1573 _DBUS_UNLOCK (shared_connections);
1574 close_connection_on_shutdown (connection);
1575 if (!_DBUS_LOCK (shared_connections))
1576 _dbus_assert_not_reached ("global locks were already initialized");
1577
1578 /* The connection should now be dead and not in our hash ... */
1579 _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) < n_entries);
1580 }
1581
1582 _dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) == 0);
1583
1584 _dbus_hash_table_unref (shared_connections);
1585 shared_connections = NULL;
1586
1587 if (shared_connections_no_guid != NULL)
1588 {
1589 DBusConnection *connection;
1590 connection = _dbus_list_pop_first (&shared_connections_no_guid);
1591 while (connection != NULL)
1592 {
1593 _DBUS_UNLOCK (shared_connections);
1594 close_connection_on_shutdown (connection);
1595 if (!_DBUS_LOCK (shared_connections))
1596 _dbus_assert_not_reached ("global locks were already initialized");
1597 connection = _dbus_list_pop_first (&shared_connections_no_guid);
1598 }
1599 }
1600
1601 shared_connections_no_guid = NULL;
1602
1603 _DBUS_UNLOCK (shared_connections);
1604}
1605
1606static dbus_bool_t
1607connection_lookup_shared (DBusAddressEntry *entry,
1608 DBusConnection **result)
1609{
1610 _dbus_verbose ("checking for existing connection\n");
1611
1612 *result = NULL;
1613
1614 if (!_DBUS_LOCK (shared_connections))
1615 {
1616 /* If it was shared, we'd have initialized global locks when we put
1617 * it in shared_connections. */
1618 return FALSE;
1619 }
1620
1621 if (shared_connections == NULL)
1622 {
1623 _dbus_verbose ("creating shared_connections hash table\n");
1624
1625 shared_connections = _dbus_hash_table_new (DBUS_HASH_STRING,
1626 dbus_free,
1627 NULL);
1628 if (shared_connections == NULL)
1629 {
1630 _DBUS_UNLOCK (shared_connections);
1631 return FALSE;
1632 }
1633
1634 if (!_dbus_register_shutdown_func (shared_connections_shutdown, NULL))
1635 {
1636 _dbus_hash_table_unref (shared_connections);
1637 shared_connections = NULL;
1638 _DBUS_UNLOCK (shared_connections);
1639 return FALSE;
1640 }
1641
1642 _dbus_verbose (" successfully created shared_connections\n");
1643
1644 _DBUS_UNLOCK (shared_connections);
1645 return TRUE; /* no point looking up in the hash we just made */
1646 }
1647 else
1648 {
1649 const char *guid;
1650
1651 guid = dbus_address_entry_get_value (entry, "guid");
1652
1653 if (guid != NULL)
1654 {
1655 DBusConnection *connection;
1656
1657 connection = _dbus_hash_table_lookup_string (shared_connections,
1658 guid);
1659
1660 if (connection)
1661 {
1662 /* The DBusConnection can't be finalized without taking
1663 * the shared_connections lock to remove it from the
1664 * hash. So it's safe to ref the connection here.
1665 * However, it may be disconnected if the Disconnected
1666 * message hasn't been processed yet, in which case we
1667 * want to pretend it isn't in the hash and avoid
1668 * returning it.
1669 *
1670 * The idea is to avoid ever returning a disconnected connection
1671 * from dbus_connection_open(). We could just synchronously
1672 * drop our shared ref to the connection on connection disconnect,
1673 * and then assert here that the connection is connected, but
1674 * that causes reentrancy headaches.
1675 */
1676 CONNECTION_LOCK (connection);
1677 if (_dbus_connection_get_is_connected_unlocked (connection))
1678 {
1679 _dbus_connection_ref_unlocked (connection);
1680 *result = connection;
1681 _dbus_verbose ("looked up existing connection to server guid %s\n",
1682 guid);
1683 }
1684 else
1685 {
1686 _dbus_verbose ("looked up existing connection to server guid %s but it was disconnected so ignoring it\n",
1687 guid);
1688 }
1689 CONNECTION_UNLOCK (connection);
1690 }
1691 }
1692
1693 _DBUS_UNLOCK (shared_connections);
1694 return TRUE;
1695 }
1696}
1697
1698static dbus_bool_t
1699connection_record_shared_unlocked (DBusConnection *connection,
1700 const char *guid)
1701{
1702 char *guid_key;
1703 char *guid_in_connection;
1704
1705 HAVE_LOCK_CHECK (connection);
1706 _dbus_assert (connection->server_guid == NULL);
1707 _dbus_assert (connection->shareable);
1708
1709 /* get a hard ref on this connection, even if
1710 * we won't in fact store it in the hash, we still
1711 * need to hold a ref on it until it's disconnected.
1712 */
1713 _dbus_connection_ref_unlocked (connection);
1714
1715 if (guid == NULL)
1716 {
1717 if (!_DBUS_LOCK (shared_connections))
1718 return FALSE;
1719
1720 if (!_dbus_list_prepend (&shared_connections_no_guid, connection))
1721 {
1722 _DBUS_UNLOCK (shared_connections);
1723 return FALSE;
1724 }
1725
1726 _DBUS_UNLOCK (shared_connections);
1727 return TRUE; /* don't store in the hash */
1728 }
1729
1730 /* A separate copy of the key is required in the hash table, because
1731 * we don't have a lock on the connection when we are doing a hash
1732 * lookup.
1733 */
1734
1735 guid_key = _dbus_strdup (guid);
1736 if (guid_key == NULL)
1737 return FALSE;
1738
1739 guid_in_connection = _dbus_strdup (guid);
1740 if (guid_in_connection == NULL)
1741 {
1742 dbus_free (guid_key);
1743 return FALSE;
1744 }
1745
1746 if (!_DBUS_LOCK (shared_connections))
1747 {
1748 dbus_free (guid_in_connection);
1749 dbus_free (guid_key);
1750 return FALSE;
1751 }
1752
1753 _dbus_assert (shared_connections != NULL);
1754
1755 if (!_dbus_hash_table_insert_string (shared_connections,
1756 guid_key, connection))
1757 {
1758 dbus_free (guid_key);
1759 dbus_free (guid_in_connection);
1760 _DBUS_UNLOCK (shared_connections);
1761 return FALSE;
1762 }
1763
1764 connection->server_guid = guid_in_connection;
1765
1766 _dbus_verbose ("stored connection to %s to be shared\n",
1767 connection->server_guid);
1768
1769 _DBUS_UNLOCK (shared_connections);
1770
1771 _dbus_assert (connection->server_guid != NULL);
1772
1773 return TRUE;
1774}
1775
1776static void
1777connection_forget_shared_unlocked (DBusConnection *connection)
1778{
1779 HAVE_LOCK_CHECK (connection);
1780
1781 if (!connection->shareable)
1782 return;
1783
1784 if (!_DBUS_LOCK (shared_connections))
1785 {
1786 /* If it was shared, we'd have initialized global locks when we put
1787 * it in the table; so it can't be there. */
1788 return;
1789 }
1790
1791 if (connection->server_guid != NULL)
1792 {
1793 _dbus_verbose ("dropping connection to %s out of the shared table\n",
1794 connection->server_guid);
1795
1796 if (!_dbus_hash_table_remove_string (shared_connections,
1797 connection->server_guid))
1798 _dbus_assert_not_reached ("connection was not in the shared table");
1799
1800 dbus_free (connection->server_guid);
1801 connection->server_guid = NULL;
1802 }
1803 else
1804 {
1805 _dbus_list_remove (&shared_connections_no_guid, connection);
1806 }
1807
1808 _DBUS_UNLOCK (shared_connections);
1809
1810 /* remove our reference held on all shareable connections */
1811 _dbus_connection_unref_unlocked (connection);
1812}
1813
1814static DBusConnection*
1815connection_try_from_address_entry (DBusAddressEntry *entry,
1816 DBusError *error)
1817{
1818 DBusTransport *transport;
1819 DBusConnection *connection;
1820
1821 transport = _dbus_transport_open (entry, error);
1822
1823 if (transport == NULL)
1824 {
1825 _DBUS_ASSERT_ERROR_IS_SET (error);
1826 return NULL;
1827 }
1828
1829 connection = _dbus_connection_new_for_transport (transport);
1830
1831 _dbus_transport_unref (transport);
1832
1833 if (connection == NULL)
1834 {
1835 _DBUS_SET_OOM (error);
1836 return NULL;
1837 }
1838
1839#ifndef DBUS_DISABLE_CHECKS
1840 _dbus_assert (!connection->have_connection_lock);
1841#endif
1842 return connection;
1843}
1844
1845/*
1846 * If the shared parameter is true, then any existing connection will
1847 * be used (and if a new connection is created, it will be available
1848 * for use by others). If the shared parameter is false, a new
1849 * connection will always be created, and the new connection will
1850 * never be returned to other callers.
1851 *
1852 * @param address the address
1853 * @param shared whether the connection is shared or private
1854 * @param error error return
1855 * @returns the connection or #NULL on error
1856 */
1857static DBusConnection*
1858_dbus_connection_open_internal (const char *address,
1859 dbus_bool_t shared,
1860 DBusError *error)
1861{
1862 DBusConnection *connection;
1863 DBusAddressEntry **entries;
1864 DBusError tmp_error = DBUS_ERROR_INIT;
1865 DBusError first_error = DBUS_ERROR_INIT;
1866 int len, i;
1867
1868 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1869
1870 _dbus_verbose ("opening %s connection to: %s\n",
1871 shared ? "shared" : "private", address);
1872
1873 if (!dbus_parse_address (address, &entries, &len, error))
1874 return NULL;
1875
1876 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1877
1878 connection = NULL;
1879
1880 for (i = 0; i < len; i++)
1881 {
1882 if (shared)
1883 {
1884 if (!connection_lookup_shared (entries[i], &connection))
1885 _DBUS_SET_OOM (&tmp_error);
1886 }
1887
1888 if (connection == NULL)
1889 {
1890 connection = connection_try_from_address_entry (entries[i],
1891 &tmp_error);
1892
1893 if (connection != NULL && shared)
1894 {
1895 const char *guid;
1896
1897 connection->shareable = TRUE;
1898
1899 /* guid may be NULL */
1900 guid = dbus_address_entry_get_value (entries[i], "guid");
1901
1902 CONNECTION_LOCK (connection);
1903
1904 if (!connection_record_shared_unlocked (connection, guid))
1905 {
1906 _DBUS_SET_OOM (&tmp_error);
1907 _dbus_connection_close_possibly_shared_and_unlock (connection);
1908 dbus_connection_unref (connection);
1909 connection = NULL;
1910 }
1911 else
1912 CONNECTION_UNLOCK (connection);
1913 }
1914 }
1915
1916 if (connection)
1917 break;
1918
1919 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
1920
1921 if (i == 0)
1922 dbus_move_error (&tmp_error, &first_error);
1923 else
1924 dbus_error_free (&tmp_error);
1925 }
1926
1927 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1928 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
1929
1930 if (connection == NULL)
1931 {
1932 _DBUS_ASSERT_ERROR_IS_SET (&first_error);
1933 dbus_move_error (&first_error, error);
1934 }
1935 else
1936 dbus_error_free (&first_error);
1937
1938 dbus_address_entries_free (entries);
1939 return connection;
1940}
1941
1950void
1951_dbus_connection_close_possibly_shared (DBusConnection *connection)
1952{
1953 _dbus_assert (connection != NULL);
1954 _dbus_assert (connection->generation == _dbus_current_generation);
1955
1956 CONNECTION_LOCK (connection);
1957 _dbus_connection_close_possibly_shared_and_unlock (connection);
1958}
1959
1960static DBusPreallocatedSend*
1961_dbus_connection_preallocate_send_unlocked (DBusConnection *connection)
1962{
1963 DBusPreallocatedSend *preallocated;
1964
1965 HAVE_LOCK_CHECK (connection);
1966
1967 _dbus_assert (connection != NULL);
1968
1969 preallocated = dbus_new (DBusPreallocatedSend, 1);
1970 if (preallocated == NULL)
1971 return NULL;
1972
1973 preallocated->queue_link = _dbus_list_alloc_link (NULL);
1974 if (preallocated->queue_link == NULL)
1975 goto failed_0;
1976
1977 preallocated->counter_link = _dbus_list_alloc_link (connection->outgoing_counter);
1978 if (preallocated->counter_link == NULL)
1979 goto failed_1;
1980
1981 _dbus_counter_ref (preallocated->counter_link->data);
1982
1983 preallocated->connection = connection;
1984
1985 return preallocated;
1986
1987 failed_1:
1988 _dbus_list_free_link (preallocated->queue_link);
1989 failed_0:
1990 dbus_free (preallocated);
1991
1992 return NULL;
1993}
1994
1995/* Called with lock held, does not update dispatch status */
1996static void
1997_dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *connection,
1998 DBusPreallocatedSend *preallocated,
1999 DBusMessage *message,
2000 dbus_uint32_t *client_serial)
2001{
2002 dbus_uint32_t serial;
2003
2004 preallocated->queue_link->data = message;
2005 _dbus_list_prepend_link (&connection->outgoing_messages,
2006 preallocated->queue_link);
2007
2008 /* It's OK that we'll never call the notify function, because for the
2009 * outgoing limit, there isn't one */
2010 _dbus_message_add_counter_link (message,
2011 preallocated->counter_link);
2012
2013 dbus_free (preallocated);
2014 preallocated = NULL;
2015
2016 dbus_message_ref (message);
2017
2018 connection->n_outgoing += 1;
2019
2020 _dbus_verbose ("Message %p (%s %s %s %s '%s') for %s added to outgoing queue %p, %d pending to send\n",
2021 message,
2022 dbus_message_type_to_string (dbus_message_get_type (message)),
2023 dbus_message_get_path (message) ?
2024 dbus_message_get_path (message) :
2025 "no path",
2026 dbus_message_get_interface (message) ?
2027 dbus_message_get_interface (message) :
2028 "no interface",
2029 dbus_message_get_member (message) ?
2030 dbus_message_get_member (message) :
2031 "no member",
2032 dbus_message_get_signature (message),
2033 dbus_message_get_destination (message) ?
2034 dbus_message_get_destination (message) :
2035 "null",
2036 connection,
2037 connection->n_outgoing);
2038
2039 if (dbus_message_get_serial (message) == 0)
2040 {
2041 serial = _dbus_connection_get_next_client_serial (connection);
2042 dbus_message_set_serial (message, serial);
2043 if (client_serial)
2044 *client_serial = serial;
2045 }
2046 else
2047 {
2048 if (client_serial)
2049 *client_serial = dbus_message_get_serial (message);
2050 }
2051
2052 _dbus_verbose ("Message %p serial is %u\n",
2053 message, dbus_message_get_serial (message));
2054
2055 dbus_message_lock (message);
2056
2057 /* Now we need to run an iteration to hopefully just write the messages
2058 * out immediately, and otherwise get them queued up
2059 */
2060 _dbus_connection_do_iteration_unlocked (connection,
2061 NULL,
2062 DBUS_ITERATION_DO_WRITING,
2063 -1);
2064
2065 /* If stuff is still queued up, be sure we wake up the main loop */
2066 if (connection->n_outgoing > 0)
2067 _dbus_connection_wakeup_mainloop (connection);
2068}
2069
2070static void
2071_dbus_connection_send_preallocated_and_unlock (DBusConnection *connection,
2072 DBusPreallocatedSend *preallocated,
2073 DBusMessage *message,
2074 dbus_uint32_t *client_serial)
2075{
2076 DBusDispatchStatus status;
2077
2078 HAVE_LOCK_CHECK (connection);
2079
2080 _dbus_connection_send_preallocated_unlocked_no_update (connection,
2081 preallocated,
2082 message, client_serial);
2083
2084 _dbus_verbose ("middle\n");
2085 status = _dbus_connection_get_dispatch_status_unlocked (connection);
2086
2087 /* this calls out to user code */
2088 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2089}
2090
2100 dbus_bool_t
2101_dbus_connection_send_and_unlock (DBusConnection *connection,
2102 DBusMessage *message,
2103 dbus_uint32_t *client_serial)
2104{
2105 DBusPreallocatedSend *preallocated;
2106
2107 _dbus_assert (connection != NULL);
2108 _dbus_assert (message != NULL);
2109
2110 preallocated = _dbus_connection_preallocate_send_unlocked (connection);
2111 if (preallocated == NULL)
2112 {
2113 CONNECTION_UNLOCK (connection);
2114 return FALSE;
2115 }
2116
2117 _dbus_connection_send_preallocated_and_unlock (connection,
2118 preallocated,
2119 message,
2120 client_serial);
2121 return TRUE;
2122}
2123
2148void
2149_dbus_connection_close_if_only_one_ref (DBusConnection *connection)
2150{
2151 dbus_int32_t refcount;
2152
2153 CONNECTION_LOCK (connection);
2154
2155 refcount = _dbus_atomic_get (&connection->refcount);
2156 /* The caller should have at least one ref */
2157 _dbus_assert (refcount >= 1);
2158
2159 if (refcount == 1)
2160 _dbus_connection_close_possibly_shared_and_unlock (connection);
2161 else
2162 CONNECTION_UNLOCK (connection);
2163}
2164
2165
2175static void
2176_dbus_memory_pause_based_on_timeout (int timeout_milliseconds)
2177{
2178 if (timeout_milliseconds == -1)
2179 _dbus_sleep_milliseconds (1000);
2180 else if (timeout_milliseconds < 100)
2181 ; /* just busy loop */
2182 else if (timeout_milliseconds <= 1000)
2183 _dbus_sleep_milliseconds (timeout_milliseconds / 3);
2184 else
2185 _dbus_sleep_milliseconds (1000);
2186}
2187
2188static DBusMessage *
2189generate_local_error_message (dbus_uint32_t serial,
2190 const char *error_name,
2191 const char *error_msg)
2192{
2193 DBusMessage *message;
2194 message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
2195 if (!message)
2196 goto out;
2197
2198 if (!dbus_message_set_error_name (message, error_name))
2199 {
2200 dbus_message_unref (message);
2201 message = NULL;
2202 goto out;
2203 }
2204
2205 dbus_message_set_no_reply (message, TRUE);
2206
2207 if (!dbus_message_set_reply_serial (message,
2208 serial))
2209 {
2210 dbus_message_unref (message);
2211 message = NULL;
2212 goto out;
2213 }
2214
2215 if (error_msg != NULL)
2216 {
2217 DBusMessageIter iter;
2218
2219 dbus_message_iter_init_append (message, &iter);
2220 if (!dbus_message_iter_append_basic (&iter,
2221 DBUS_TYPE_STRING,
2222 &error_msg))
2223 {
2224 dbus_message_unref (message);
2225 message = NULL;
2226 goto out;
2227 }
2228 }
2229
2230 out:
2231 return message;
2232}
2233
2234/*
2235 * Peek the incoming queue to see if we got reply for a specific serial
2236 */
2237static dbus_bool_t
2238_dbus_connection_peek_for_reply_unlocked (DBusConnection *connection,
2239 dbus_uint32_t client_serial)
2240{
2241 DBusList *link;
2242 HAVE_LOCK_CHECK (connection);
2243
2244 link = _dbus_list_get_first_link (&connection->incoming_messages);
2245
2246 while (link != NULL)
2247 {
2248 DBusMessage *reply = link->data;
2249
2250 if (dbus_message_get_reply_serial (reply) == client_serial)
2251 {
2252 _dbus_verbose ("%s reply to %d found in queue\n", _DBUS_FUNCTION_NAME, client_serial);
2253 return TRUE;
2254 }
2255 link = _dbus_list_get_next_link (&connection->incoming_messages, link);
2256 }
2257
2258 return FALSE;
2259}
2260
2261/* This is slightly strange since we can pop a message here without
2262 * the dispatch lock.
2263 */
2264static DBusMessage*
2265check_for_reply_unlocked (DBusConnection *connection,
2266 dbus_uint32_t client_serial)
2267{
2268 DBusList *link;
2269
2270 HAVE_LOCK_CHECK (connection);
2271
2272 link = _dbus_list_get_first_link (&connection->incoming_messages);
2273
2274 while (link != NULL)
2275 {
2276 DBusMessage *reply = link->data;
2277
2278 if (dbus_message_get_reply_serial (reply) == client_serial)
2279 {
2280 _dbus_list_remove_link (&connection->incoming_messages, link);
2281 connection->n_incoming -= 1;
2282 return reply;
2283 }
2284 link = _dbus_list_get_next_link (&connection->incoming_messages, link);
2285 }
2286
2287 return NULL;
2288}
2289
2290static void
2291connection_timeout_and_complete_all_pending_calls_unlocked (DBusConnection *connection)
2292{
2293 /* We can't iterate over the hash in the normal way since we'll be
2294 * dropping the lock for each item. So we restart the
2295 * iter each time as we drain the hash table.
2296 */
2297
2298 while (_dbus_hash_table_get_n_entries (connection->pending_replies) > 0)
2299 {
2300 DBusPendingCall *pending;
2301 DBusHashIter iter;
2302
2303 _dbus_hash_iter_init (connection->pending_replies, &iter);
2304 _dbus_hash_iter_next (&iter);
2305
2306 pending = _dbus_hash_iter_get_value (&iter);
2307 _dbus_pending_call_ref_unlocked (pending);
2308
2309 _dbus_pending_call_queue_timeout_error_unlocked (pending,
2310 connection);
2311
2312 if (_dbus_pending_call_is_timeout_added_unlocked (pending))
2313 _dbus_connection_remove_timeout_unlocked (connection,
2314 _dbus_pending_call_get_timeout_unlocked (pending));
2315 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
2316 _dbus_hash_iter_remove_entry (&iter);
2317
2318 _dbus_pending_call_unref_and_unlock (pending);
2319 CONNECTION_LOCK (connection);
2320 }
2321 HAVE_LOCK_CHECK (connection);
2322}
2323
2324static void
2325complete_pending_call_and_unlock (DBusConnection *connection,
2326 DBusPendingCall *pending,
2327 DBusMessage *message)
2328{
2329 _dbus_pending_call_set_reply_unlocked (pending, message);
2330 _dbus_pending_call_ref_unlocked (pending); /* in case there's no app with a ref held */
2331 _dbus_pending_call_start_completion_unlocked(pending);
2332 _dbus_connection_detach_pending_call_and_unlock (connection, pending);
2333
2334 /* Must be called unlocked since it invokes app callback */
2335 _dbus_pending_call_finish_completion (pending);
2336 dbus_pending_call_unref (pending);
2337}
2338
2339static dbus_bool_t
2340check_for_reply_and_update_dispatch_unlocked (DBusConnection *connection,
2341 DBusPendingCall *pending)
2342{
2343 DBusMessage *reply;
2344 DBusDispatchStatus status;
2345
2346 reply = check_for_reply_unlocked (connection,
2347 _dbus_pending_call_get_reply_serial_unlocked (pending));
2348 if (reply != NULL)
2349 {
2350 _dbus_verbose ("checked for reply\n");
2351
2352 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): got reply\n");
2353
2354 complete_pending_call_and_unlock (connection, pending, reply);
2355 dbus_message_unref (reply);
2356
2357 CONNECTION_LOCK (connection);
2358 status = _dbus_connection_get_dispatch_status_unlocked (connection);
2359 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2360 dbus_pending_call_unref (pending);
2361
2362 return TRUE;
2363 }
2364
2365 return FALSE;
2366}
2367
2382void
2383_dbus_connection_block_pending_call (DBusPendingCall *pending)
2384{
2385 long start_tv_sec, start_tv_usec;
2386 long tv_sec, tv_usec;
2387 DBusDispatchStatus status;
2388 DBusConnection *connection;
2389 dbus_uint32_t client_serial;
2390 DBusTimeout *timeout;
2391 int timeout_milliseconds, elapsed_milliseconds;
2392
2393 _dbus_assert (pending != NULL);
2394
2395 if (dbus_pending_call_get_completed (pending))
2396 return;
2397
2398 dbus_pending_call_ref (pending); /* necessary because the call could be canceled */
2399
2400 connection = _dbus_pending_call_get_connection_and_lock (pending);
2401
2402 /* Flush message queue - note, can affect dispatch status */
2403 _dbus_connection_flush_unlocked (connection);
2404
2405 client_serial = _dbus_pending_call_get_reply_serial_unlocked (pending);
2406
2407 /* note that timeout_milliseconds is limited to a smallish value
2408 * in _dbus_pending_call_new() so overflows aren't possible
2409 * below
2410 */
2411 timeout = _dbus_pending_call_get_timeout_unlocked (pending);
2412 _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
2413 if (timeout)
2414 {
2415 timeout_milliseconds = dbus_timeout_get_interval (timeout);
2416
2417 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block %d milliseconds for reply serial %u from %ld sec %ld usec\n",
2418 timeout_milliseconds,
2419 client_serial,
2420 start_tv_sec, start_tv_usec);
2421 }
2422 else
2423 {
2424 timeout_milliseconds = -1;
2425
2426 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): will block for reply serial %u\n", client_serial);
2427 }
2428
2429 /* check to see if we already got the data off the socket */
2430 /* from another blocked pending call */
2431 if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
2432 return;
2433
2434 /* Now we wait... */
2435 /* always block at least once as we know we don't have the reply yet */
2436 _dbus_connection_do_iteration_unlocked (connection,
2437 pending,
2438 DBUS_ITERATION_DO_READING |
2439 DBUS_ITERATION_BLOCK,
2440 timeout_milliseconds);
2441
2442 recheck_status:
2443
2444 _dbus_verbose ("top of recheck\n");
2445
2446 HAVE_LOCK_CHECK (connection);
2447
2448 /* queue messages and get status */
2449
2450 status = _dbus_connection_get_dispatch_status_unlocked (connection);
2451
2452 /* the get_completed() is in case a dispatch() while we were blocking
2453 * got the reply instead of us.
2454 */
2455 if (_dbus_pending_call_get_completed_unlocked (pending))
2456 {
2457 _dbus_verbose ("Pending call completed by dispatch\n");
2458 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2459 dbus_pending_call_unref (pending);
2460 return;
2461 }
2462
2463 if (status == DBUS_DISPATCH_DATA_REMAINS)
2464 {
2465 if (check_for_reply_and_update_dispatch_unlocked (connection, pending))
2466 return;
2467 }
2468
2469 _dbus_get_monotonic_time (&tv_sec, &tv_usec);
2470 elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 +
2471 (tv_usec - start_tv_usec) / 1000;
2472
2473 if (!_dbus_connection_get_is_connected_unlocked (connection))
2474 {
2475 DBusMessage *error_msg;
2476
2477 error_msg = generate_local_error_message (client_serial,
2478 DBUS_ERROR_DISCONNECTED,
2479 "Connection was disconnected before a reply was received");
2480
2481 /* on OOM error_msg is set to NULL */
2482 complete_pending_call_and_unlock (connection, pending, error_msg);
2483 if (error_msg != NULL)
2484 dbus_message_unref (error_msg);
2485 dbus_pending_call_unref (pending);
2486 return;
2487 }
2488 else if (connection->disconnect_message_link == NULL)
2489 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): disconnected\n");
2490 else if (timeout == NULL)
2491 {
2492 if (status == DBUS_DISPATCH_NEED_MEMORY)
2493 {
2494 /* Try sleeping a bit, as we aren't sure we need to block for reading,
2495 * we may already have a reply in the buffer and just can't process
2496 * it.
2497 */
2498 _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n");
2499
2500 _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
2501 }
2502 else
2503 {
2504 /* block again, we don't have the reply buffered yet. */
2505 _dbus_connection_do_iteration_unlocked (connection,
2506 pending,
2507 DBUS_ITERATION_DO_READING |
2508 DBUS_ITERATION_BLOCK,
2509 timeout_milliseconds - elapsed_milliseconds);
2510 }
2511
2512 goto recheck_status;
2513 }
2514 else if (tv_sec < start_tv_sec)
2515 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): clock set backward\n");
2516 else if (elapsed_milliseconds < timeout_milliseconds)
2517 {
2518 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): %d milliseconds remain\n", timeout_milliseconds - elapsed_milliseconds);
2519
2520 if (status == DBUS_DISPATCH_NEED_MEMORY)
2521 {
2522 /* Try sleeping a bit, as we aren't sure we need to block for reading,
2523 * we may already have a reply in the buffer and just can't process
2524 * it.
2525 */
2526 _dbus_verbose ("dbus_connection_send_with_reply_and_block() waiting for more memory\n");
2527
2528 _dbus_memory_pause_based_on_timeout (timeout_milliseconds - elapsed_milliseconds);
2529 }
2530 else
2531 {
2532 /* block again, we don't have the reply buffered yet. */
2533 _dbus_connection_do_iteration_unlocked (connection,
2534 pending,
2535 DBUS_ITERATION_DO_READING |
2536 DBUS_ITERATION_BLOCK,
2537 timeout_milliseconds - elapsed_milliseconds);
2538 }
2539
2540 goto recheck_status;
2541 }
2542
2543 _dbus_verbose ("dbus_connection_send_with_reply_and_block(): Waited %d milliseconds and got no reply\n",
2544 elapsed_milliseconds);
2545
2546 _dbus_assert (!_dbus_pending_call_get_completed_unlocked (pending));
2547
2548 /* unlock and call user code */
2549 complete_pending_call_and_unlock (connection, pending, NULL);
2550
2551 /* update user code on dispatch status */
2552 CONNECTION_LOCK (connection);
2553 status = _dbus_connection_get_dispatch_status_unlocked (connection);
2554 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2555 dbus_pending_call_unref (pending);
2556}
2557
2563int
2564_dbus_connection_get_pending_fds_count (DBusConnection *connection)
2565{
2566 return _dbus_transport_get_pending_fds_count (connection->transport);
2567}
2568
2576void
2577_dbus_connection_set_pending_fds_function (DBusConnection *connection,
2578 DBusPendingFdsChangeFunction callback,
2579 void *data)
2580{
2581 _dbus_transport_set_pending_fds_function (connection->transport,
2582 callback, data);
2583}
2584
2621 DBusConnection*
2622dbus_connection_open (const char *address,
2623 DBusError *error)
2624{
2625 DBusConnection *connection;
2626
2627 _dbus_return_val_if_fail (address != NULL, NULL);
2628 _dbus_return_val_if_error_is_set (error, NULL);
2629
2630 connection = _dbus_connection_open_internal (address,
2631 TRUE,
2632 error);
2633
2634 return connection;
2635}
2636
2664 DBusConnection*
2665dbus_connection_open_private (const char *address,
2666 DBusError *error)
2667{
2668 DBusConnection *connection;
2669
2670 _dbus_return_val_if_fail (address != NULL, NULL);
2671 _dbus_return_val_if_error_is_set (error, NULL);
2672
2673 connection = _dbus_connection_open_internal (address,
2674 FALSE,
2675 error);
2676
2677 return connection;
2678}
2679
2686 DBusConnection *
2687dbus_connection_ref (DBusConnection *connection)
2688{
2689 dbus_int32_t old_refcount;
2690
2691 _dbus_return_val_if_fail (connection != NULL, NULL);
2692 _dbus_return_val_if_fail (connection->generation == _dbus_current_generation, NULL);
2693 old_refcount = _dbus_atomic_inc (&connection->refcount);
2694 _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
2695 "ref");
2696
2697 return connection;
2698}
2699
2700static void
2701free_outgoing_message (void *element,
2702 void *data)
2703{
2704 DBusMessage *message = element;
2705 DBusConnection *connection = data;
2706
2707 _dbus_message_remove_counter (message, connection->outgoing_counter);
2708 dbus_message_unref (message);
2709}
2710
2711/* This is run without the mutex held, but after the last reference
2712 * to the connection has been dropped we should have no thread-related
2713 * problems
2714 */
2715static void
2716_dbus_connection_last_unref (DBusConnection *connection)
2717{
2718 DBusList *link;
2719
2720 _dbus_verbose ("Finalizing connection %p\n", connection);
2721
2722 _dbus_assert (_dbus_atomic_get (&connection->refcount) == 0);
2723
2724 /* You have to disconnect the connection before unref:ing it. Otherwise
2725 * you won't get the disconnected message.
2726 */
2727 _dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
2728 _dbus_assert (connection->server_guid == NULL);
2729
2730 /* ---- We're going to call various application callbacks here, hope it doesn't break anything... */
2731 _dbus_object_tree_free_all_unlocked (connection->objects);
2732
2733 dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
2734 dbus_connection_set_wakeup_main_function (connection, NULL, NULL, NULL);
2735 dbus_connection_set_unix_user_function (connection, NULL, NULL, NULL);
2736 dbus_connection_set_windows_user_function (connection, NULL, NULL, NULL);
2737
2738 _dbus_watch_list_free (connection->watches);
2739 connection->watches = NULL;
2740
2741 _dbus_timeout_list_free (connection->timeouts);
2742 connection->timeouts = NULL;
2743
2744 _dbus_data_slot_list_free (&connection->slot_list);
2745
2746 link = _dbus_list_get_first_link (&connection->filter_list);
2747 while (link != NULL)
2748 {
2749 DBusMessageFilter *filter = link->data;
2750 DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link);
2751
2752 filter->function = NULL;
2753 _dbus_message_filter_unref (filter); /* calls app callback */
2754 link->data = NULL;
2755
2756 link = next;
2757 }
2758 _dbus_list_clear (&connection->filter_list);
2759
2760 /* ---- Done with stuff that invokes application callbacks */
2761
2762 _dbus_object_tree_unref (connection->objects);
2763
2764 _dbus_hash_table_unref (connection->pending_replies);
2765 connection->pending_replies = NULL;
2766
2767 _dbus_list_foreach (&connection->outgoing_messages,
2768 free_outgoing_message,
2769 connection);
2770 _dbus_list_clear (&connection->outgoing_messages);
2771
2772 _dbus_list_clear_full (&connection->incoming_messages,
2773 (DBusFreeFunction) dbus_message_unref);
2774
2775 _dbus_counter_unref (connection->outgoing_counter);
2776
2777 _dbus_transport_unref (connection->transport);
2778
2779 if (connection->disconnect_message_link)
2780 {
2781 DBusMessage *message = connection->disconnect_message_link->data;
2782 dbus_message_unref (message);
2783 _dbus_list_free_link (connection->disconnect_message_link);
2784 }
2785
2786 _dbus_condvar_free_at_location (&connection->dispatch_cond);
2787 _dbus_condvar_free_at_location (&connection->io_path_cond);
2788
2789 _dbus_cmutex_free_at_location (&connection->io_path_mutex);
2790 _dbus_cmutex_free_at_location (&connection->dispatch_mutex);
2791
2792 _dbus_rmutex_free_at_location (&connection->slot_mutex);
2793
2794 _dbus_rmutex_free_at_location (&connection->mutex);
2795
2796 dbus_free (connection);
2797}
2798
2818void
2819dbus_connection_unref (DBusConnection *connection)
2820{
2821 dbus_int32_t old_refcount;
2822
2823 _dbus_return_if_fail (connection != NULL);
2824 _dbus_return_if_fail (connection->generation == _dbus_current_generation);
2825
2826 old_refcount = _dbus_atomic_dec (&connection->refcount);
2827
2828 _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
2829 "unref");
2830
2831 if (old_refcount == 1)
2832 {
2833#ifndef DBUS_DISABLE_CHECKS
2834 if (_dbus_transport_get_is_connected (connection->transport))
2835 {
2836 _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",
2837 connection->shareable ?
2838 "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection." :
2839 "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.");
2840 return;
2841 }
2842#endif
2843 _dbus_connection_last_unref (connection);
2844 }
2845}
2846
2847/*
2848 * Note that the transport can disconnect itself (other end drops us)
2849 * and in that case this function never runs. So this function must
2850 * not do anything more than disconnect the transport and update the
2851 * dispatch status.
2852 *
2853 * If the transport self-disconnects, then we assume someone will
2854 * dispatch the connection to cause the dispatch status update.
2855 */
2856static void
2857_dbus_connection_close_possibly_shared_and_unlock (DBusConnection *connection)
2858{
2859 DBusDispatchStatus status;
2860
2861 HAVE_LOCK_CHECK (connection);
2862
2863 _dbus_verbose ("Disconnecting %p\n", connection);
2864
2865 /* We need to ref because update_dispatch_status_and_unlock will unref
2866 * the connection if it was shared and libdbus was the only remaining
2867 * refcount holder.
2868 */
2869 _dbus_connection_ref_unlocked (connection);
2870
2871 _dbus_transport_disconnect (connection->transport);
2872
2873 /* This has the side effect of queuing the disconnect message link
2874 * (unless we don't have enough memory, possibly, so don't assert it).
2875 * After the disconnect message link is queued, dbus_bus_get/dbus_connection_open
2876 * should never again return the newly-disconnected connection.
2877 *
2878 * However, we only unref the shared connection and exit_on_disconnect when
2879 * the disconnect message reaches the head of the message queue,
2880 * NOT when it's first queued.
2881 */
2882 status = _dbus_connection_get_dispatch_status_unlocked (connection);
2883
2884 /* This calls out to user code */
2885 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
2886
2887 /* Could also call out to user code */
2888 dbus_connection_unref (connection);
2889}
2890
2933void
2934dbus_connection_close (DBusConnection *connection)
2935{
2936 _dbus_return_if_fail (connection != NULL);
2937 _dbus_return_if_fail (connection->generation == _dbus_current_generation);
2938
2939 CONNECTION_LOCK (connection);
2940
2941#ifndef DBUS_DISABLE_CHECKS
2942 if (connection->shareable)
2943 {
2944 CONNECTION_UNLOCK (connection);
2945
2946 _dbus_warn_check_failed ("Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.");
2947 return;
2948 }
2949#endif
2950
2951 _dbus_connection_close_possibly_shared_and_unlock (connection);
2952}
2953
2954static dbus_bool_t
2955_dbus_connection_get_is_connected_unlocked (DBusConnection *connection)
2956{
2957 HAVE_LOCK_CHECK (connection);
2958 return _dbus_transport_get_is_connected (connection->transport);
2959}
2960
2974 dbus_bool_t
2975dbus_connection_get_is_connected (DBusConnection *connection)
2976{
2977 dbus_bool_t res;
2978
2979 _dbus_return_val_if_fail (connection != NULL, FALSE);
2980
2981 CONNECTION_LOCK (connection);
2982 res = _dbus_connection_get_is_connected_unlocked (connection);
2983 CONNECTION_UNLOCK (connection);
2984
2985 return res;
2986}
2987
2996 dbus_bool_t
2997dbus_connection_get_is_authenticated (DBusConnection *connection)
2998{
2999 dbus_bool_t res;
3000
3001 _dbus_return_val_if_fail (connection != NULL, FALSE);
3002
3003 CONNECTION_LOCK (connection);
3004 res = _dbus_transport_try_to_authenticate (connection->transport);
3005 CONNECTION_UNLOCK (connection);
3006
3007 return res;
3008}
3009
3030 dbus_bool_t
3031dbus_connection_get_is_anonymous (DBusConnection *connection)
3032{
3033 dbus_bool_t res;
3034
3035 _dbus_return_val_if_fail (connection != NULL, FALSE);
3036
3037 CONNECTION_LOCK (connection);
3038 res = _dbus_transport_get_is_anonymous (connection->transport);
3039 CONNECTION_UNLOCK (connection);
3040
3041 return res;
3042}
3043
3075char*
3076dbus_connection_get_server_id (DBusConnection *connection)
3077{
3078 char *id;
3079
3080 _dbus_return_val_if_fail (connection != NULL, NULL);
3081
3082 CONNECTION_LOCK (connection);
3083 id = _dbus_strdup (_dbus_transport_get_server_id (connection->transport));
3084 CONNECTION_UNLOCK (connection);
3085
3086 return id;
3087}
3088
3106 dbus_bool_t
3107dbus_connection_can_send_type(DBusConnection *connection,
3108 int type)
3109{
3110 _dbus_return_val_if_fail (connection != NULL, FALSE);
3111
3112 if (!dbus_type_is_valid (type))
3113 return FALSE;
3114
3115 if (type != DBUS_TYPE_UNIX_FD)
3116 return TRUE;
3117
3118#ifdef HAVE_UNIX_FD_PASSING
3119 {
3120 dbus_bool_t b;
3121
3122 CONNECTION_LOCK(connection);
3123 b = _dbus_transport_can_pass_unix_fd(connection->transport);
3124 CONNECTION_UNLOCK(connection);
3125
3126 return b;
3127 }
3128#endif
3129
3130 return FALSE;
3131}
3132
3146void
3147dbus_connection_set_exit_on_disconnect (DBusConnection *connection,
3148 dbus_bool_t exit_on_disconnect)
3149{
3150 _dbus_return_if_fail (connection != NULL);
3151
3152 CONNECTION_LOCK (connection);
3153 connection->exit_on_disconnect = exit_on_disconnect != FALSE;
3154 CONNECTION_UNLOCK (connection);
3155}
3156
3166 DBusPreallocatedSend*
3167dbus_connection_preallocate_send (DBusConnection *connection)
3168{
3169 DBusPreallocatedSend *preallocated;
3170
3171 _dbus_return_val_if_fail (connection != NULL, NULL);
3172
3173 CONNECTION_LOCK (connection);
3174
3175 preallocated =
3176 _dbus_connection_preallocate_send_unlocked (connection);
3177
3178 CONNECTION_UNLOCK (connection);
3179
3180 return preallocated;
3181}
3182
3192void
3193dbus_connection_free_preallocated_send (DBusConnection *connection,
3194 DBusPreallocatedSend *preallocated)
3195{
3196 _dbus_return_if_fail (connection != NULL);
3197 _dbus_return_if_fail (preallocated != NULL);
3198 _dbus_return_if_fail (connection == preallocated->connection);
3199
3200 _dbus_list_free_link (preallocated->queue_link);
3201 _dbus_counter_unref (preallocated->counter_link->data);
3202 _dbus_list_free_link (preallocated->counter_link);
3203 dbus_free (preallocated);
3204}
3205
3218void
3219dbus_connection_send_preallocated (DBusConnection *connection,
3220 DBusPreallocatedSend *preallocated,
3221 DBusMessage *message,
3222 dbus_uint32_t *client_serial)
3223{
3224 _dbus_return_if_fail (connection != NULL);
3225 _dbus_return_if_fail (preallocated != NULL);
3226 _dbus_return_if_fail (message != NULL);
3227 _dbus_return_if_fail (preallocated->connection == connection);
3228 _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL ||
3229 dbus_message_get_member (message) != NULL);
3230 _dbus_return_if_fail (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL ||
3231 (dbus_message_get_interface (message) != NULL &&
3232 dbus_message_get_member (message) != NULL));
3233
3234 CONNECTION_LOCK (connection);
3235
3236#ifdef HAVE_UNIX_FD_PASSING
3237
3238 if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3239 message->n_unix_fds > 0)
3240 {
3241 /* Refuse to send fds on a connection that cannot handle
3242 them. Unfortunately we cannot return a proper error here, so
3243 the best we can is just return. */
3244 CONNECTION_UNLOCK (connection);
3245 return;
3246 }
3247
3248#endif
3249
3250 _dbus_connection_send_preallocated_and_unlock (connection,
3251 preallocated,
3252 message, client_serial);
3253}
3254
3255static dbus_bool_t
3256_dbus_connection_send_unlocked_no_update (DBusConnection *connection,
3257 DBusMessage *message,
3258 dbus_uint32_t *client_serial)
3259{
3260 DBusPreallocatedSend *preallocated;
3261
3262 _dbus_assert (connection != NULL);
3263 _dbus_assert (message != NULL);
3264
3265 preallocated = _dbus_connection_preallocate_send_unlocked (connection);
3266 if (preallocated == NULL)
3267 return FALSE;
3268
3269 _dbus_connection_send_preallocated_unlocked_no_update (connection,
3270 preallocated,
3271 message,
3272 client_serial);
3273 return TRUE;
3274}
3275
3303 dbus_bool_t
3304dbus_connection_send (DBusConnection *connection,
3305 DBusMessage *message,
3306 dbus_uint32_t *serial)
3307{
3308 _dbus_return_val_if_fail (connection != NULL, FALSE);
3309 _dbus_return_val_if_fail (message != NULL, FALSE);
3310
3311 CONNECTION_LOCK (connection);
3312
3313#ifdef HAVE_UNIX_FD_PASSING
3314
3315 if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3316 message->n_unix_fds > 0)
3317 {
3318 /* Refuse to send fds on a connection that cannot handle
3319 them. Unfortunately we cannot return a proper error here, so
3320 the best we can is just return. */
3321 CONNECTION_UNLOCK (connection);
3322 return FALSE;
3323 }
3324
3325#endif
3326
3327 return _dbus_connection_send_and_unlock (connection,
3328 message,
3329 serial);
3330}
3331
3332static dbus_bool_t
3333reply_handler_timeout (void *data)
3334{
3335 DBusConnection *connection;
3336 DBusDispatchStatus status;
3337 DBusPendingCall *pending = data;
3338
3339 connection = _dbus_pending_call_get_connection_and_lock (pending);
3340 _dbus_connection_ref_unlocked (connection);
3341
3342 _dbus_pending_call_queue_timeout_error_unlocked (pending,
3343 connection);
3344 _dbus_connection_remove_timeout_unlocked (connection,
3345 _dbus_pending_call_get_timeout_unlocked (pending));
3346 _dbus_pending_call_set_timeout_added_unlocked (pending, FALSE);
3347
3348 _dbus_verbose ("middle\n");
3349 status = _dbus_connection_get_dispatch_status_unlocked (connection);
3350
3351 /* Unlocks, and calls out to user code */
3352 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3353 dbus_connection_unref (connection);
3354
3355 return TRUE;
3356}
3357
3400 dbus_bool_t
3401dbus_connection_send_with_reply (DBusConnection *connection,
3402 DBusMessage *message,
3403 DBusPendingCall **pending_return,
3404 int timeout_milliseconds)
3405{
3406 DBusPendingCall *pending;
3407 dbus_int32_t serial = -1;
3408 DBusDispatchStatus status;
3409
3410 _dbus_return_val_if_fail (connection != NULL, FALSE);
3411 _dbus_return_val_if_fail (message != NULL, FALSE);
3412 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3413
3414 if (pending_return)
3415 *pending_return = NULL;
3416
3417 CONNECTION_LOCK (connection);
3418
3419#ifdef HAVE_UNIX_FD_PASSING
3420
3421 if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3422 message->n_unix_fds > 0)
3423 {
3424 /* Refuse to send fds on a connection that cannot handle
3425 them. Unfortunately we cannot return a proper error here, so
3426 the best we can do is return TRUE but leave *pending_return
3427 as NULL. */
3428 CONNECTION_UNLOCK (connection);
3429 return TRUE;
3430 }
3431
3432#endif
3433
3434 if (!_dbus_connection_get_is_connected_unlocked (connection))
3435 {
3436 CONNECTION_UNLOCK (connection);
3437
3438 return TRUE;
3439 }
3440
3441 pending = _dbus_pending_call_new_unlocked (connection,
3442 timeout_milliseconds,
3443 reply_handler_timeout);
3444
3445 if (pending == NULL)
3446 {
3447 CONNECTION_UNLOCK (connection);
3448 return FALSE;
3449 }
3450
3451 /* Assign a serial to the message */
3452 serial = dbus_message_get_serial (message);
3453 if (serial == 0)
3454 {
3455 serial = _dbus_connection_get_next_client_serial (connection);
3456 dbus_message_set_serial (message, serial);
3457 }
3458
3459 if (!_dbus_pending_call_set_timeout_error_unlocked (pending, message, serial))
3460 goto error;
3461
3462 /* Insert the serial in the pending replies hash;
3463 * hash takes a refcount on DBusPendingCall.
3464 * Also, add the timeout.
3465 */
3466 if (!_dbus_connection_attach_pending_call_unlocked (connection,
3467 pending))
3468 goto error;
3469
3470 if (!_dbus_connection_send_unlocked_no_update (connection, message, NULL))
3471 {
3472 _dbus_connection_detach_pending_call_and_unlock (connection,
3473 pending);
3474 goto error_unlocked;
3475 }
3476
3477 if (pending_return)
3478 *pending_return = pending; /* hand off refcount */
3479 else
3480 {
3481 _dbus_connection_detach_pending_call_unlocked (connection, pending);
3482 /* we still have a ref to the pending call in this case, we unref
3483 * after unlocking, below
3484 */
3485 }
3486
3487 status = _dbus_connection_get_dispatch_status_unlocked (connection);
3488
3489 /* this calls out to user code */
3490 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3491
3492 if (pending_return == NULL)
3493 dbus_pending_call_unref (pending);
3494
3495 return TRUE;
3496
3497 error:
3498 CONNECTION_UNLOCK (connection);
3499 error_unlocked:
3500 dbus_pending_call_unref (pending);
3501 return FALSE;
3502}
3503
3536 DBusMessage*
3537dbus_connection_send_with_reply_and_block (DBusConnection *connection,
3538 DBusMessage *message,
3539 int timeout_milliseconds,
3540 DBusError *error)
3541{
3542 DBusMessage *reply;
3543 DBusPendingCall *pending;
3544
3545 _dbus_return_val_if_fail (connection != NULL, NULL);
3546 _dbus_return_val_if_fail (message != NULL, NULL);
3547 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, NULL);
3548 _dbus_return_val_if_error_is_set (error, NULL);
3549
3550#ifdef HAVE_UNIX_FD_PASSING
3551
3552 CONNECTION_LOCK (connection);
3553 if (!_dbus_transport_can_pass_unix_fd(connection->transport) &&
3554 message->n_unix_fds > 0)
3555 {
3556 CONNECTION_UNLOCK (connection);
3557 dbus_set_error(error, DBUS_ERROR_FAILED, "Cannot send file descriptors on this connection.");
3558 return NULL;
3559 }
3560 CONNECTION_UNLOCK (connection);
3561
3562#endif
3563
3564 if (!dbus_connection_send_with_reply (connection, message,
3565 &pending, timeout_milliseconds))
3566 {
3567 _DBUS_SET_OOM (error);
3568 return NULL;
3569 }
3570
3571 if (pending == NULL)
3572 {
3573 dbus_set_error (error, DBUS_ERROR_DISCONNECTED, "Connection is closed");
3574 return NULL;
3575 }
3576
3577 dbus_pending_call_block (pending);
3578
3579 reply = dbus_pending_call_steal_reply (pending);
3580 dbus_pending_call_unref (pending);
3581
3582 /* call_complete_and_unlock() called from pending_call_block() should
3583 * always fill this in.
3584 */
3585 _dbus_assert (reply != NULL);
3586
3587 if (dbus_set_error_from_message (error, reply))
3588 {
3589 dbus_message_unref (reply);
3590 return NULL;
3591 }
3592 else
3593 return reply;
3594}
3595
3604static DBusDispatchStatus
3605_dbus_connection_flush_unlocked (DBusConnection *connection)
3606{
3607 /* We have to specify DBUS_ITERATION_DO_READING here because
3608 * otherwise we could have two apps deadlock if they are both doing
3609 * a flush(), and the kernel buffers fill up. This could change the
3610 * dispatch status.
3611 */
3612 DBusDispatchStatus status;
3613
3614 HAVE_LOCK_CHECK (connection);
3615
3616 while (connection->n_outgoing > 0 &&
3617 _dbus_connection_get_is_connected_unlocked (connection))
3618 {
3619 _dbus_verbose ("doing iteration in\n");
3620 HAVE_LOCK_CHECK (connection);
3621 _dbus_connection_do_iteration_unlocked (connection,
3622 NULL,
3623 DBUS_ITERATION_DO_READING |
3624 DBUS_ITERATION_DO_WRITING |
3625 DBUS_ITERATION_BLOCK,
3626 -1);
3627 }
3628
3629 HAVE_LOCK_CHECK (connection);
3630 _dbus_verbose ("middle\n");
3631 status = _dbus_connection_get_dispatch_status_unlocked (connection);
3632
3633 HAVE_LOCK_CHECK (connection);
3634 return status;
3635}
3636
3642void
3643dbus_connection_flush (DBusConnection *connection)
3644{
3645 /* We have to specify DBUS_ITERATION_DO_READING here because
3646 * otherwise we could have two apps deadlock if they are both doing
3647 * a flush(), and the kernel buffers fill up. This could change the
3648 * dispatch status.
3649 */
3650 DBusDispatchStatus status;
3651
3652 _dbus_return_if_fail (connection != NULL);
3653
3654 CONNECTION_LOCK (connection);
3655
3656 status = _dbus_connection_flush_unlocked (connection);
3657
3658 HAVE_LOCK_CHECK (connection);
3659 /* Unlocks and calls out to user code */
3660 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3661
3662 _dbus_verbose ("end\n");
3663}
3664
3675static dbus_bool_t
3676_dbus_connection_read_write_dispatch (DBusConnection *connection,
3677 int timeout_milliseconds,
3678 dbus_bool_t dispatch)
3679{
3680 DBusDispatchStatus dstatus;
3681 dbus_bool_t progress_possible;
3682
3683 /* Need to grab a ref here in case we're a private connection and
3684 * the user drops the last ref in a handler we call; see bug
3685 * https://bugs.freedesktop.org/show_bug.cgi?id=15635
3686 */
3687 dbus_connection_ref (connection);
3688 dstatus = dbus_connection_get_dispatch_status (connection);
3689
3690 if (dispatch && dstatus == DBUS_DISPATCH_DATA_REMAINS)
3691 {
3692 _dbus_verbose ("doing dispatch\n");
3693 dbus_connection_dispatch (connection);
3694 CONNECTION_LOCK (connection);
3695 }
3696 else if (dstatus == DBUS_DISPATCH_NEED_MEMORY)
3697 {
3698 _dbus_verbose ("pausing for memory\n");
3699 _dbus_memory_pause_based_on_timeout (timeout_milliseconds);
3700 CONNECTION_LOCK (connection);
3701 }
3702 else
3703 {
3704 CONNECTION_LOCK (connection);
3705 if (_dbus_connection_get_is_connected_unlocked (connection))
3706 {
3707 _dbus_verbose ("doing iteration\n");
3708 _dbus_connection_do_iteration_unlocked (connection,
3709 NULL,
3710 DBUS_ITERATION_DO_READING |
3711 DBUS_ITERATION_DO_WRITING |
3712 DBUS_ITERATION_BLOCK,
3713 timeout_milliseconds);
3714 }
3715 }
3716
3717 HAVE_LOCK_CHECK (connection);
3718 /* If we can dispatch, we can make progress until the Disconnected message
3719 * has been processed; if we can only read/write, we can make progress
3720 * as long as the transport is open.
3721 */
3722 if (dispatch)
3723 progress_possible = connection->n_incoming != 0 ||
3724 connection->disconnect_message_link != NULL;
3725 else
3726 progress_possible = _dbus_connection_get_is_connected_unlocked (connection);
3727
3728 CONNECTION_UNLOCK (connection);
3729
3730 dbus_connection_unref (connection);
3731
3732 return progress_possible; /* TRUE if we can make more progress */
3733}
3734
3735
3770 dbus_bool_t
3771dbus_connection_read_write_dispatch (DBusConnection *connection,
3772 int timeout_milliseconds)
3773{
3774 _dbus_return_val_if_fail (connection != NULL, FALSE);
3775 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3776 return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, TRUE);
3777}
3778
3802 dbus_bool_t
3803dbus_connection_read_write (DBusConnection *connection,
3804 int timeout_milliseconds)
3805{
3806 _dbus_return_val_if_fail (connection != NULL, FALSE);
3807 _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE);
3808 return _dbus_connection_read_write_dispatch(connection, timeout_milliseconds, FALSE);
3809}
3810
3811/* We need to call this anytime we pop the head of the queue, and then
3812 * update_dispatch_status_and_unlock needs to be called afterward
3813 * which will "process" the disconnected message and set
3814 * disconnected_message_processed.
3815 */
3816static void
3817check_disconnected_message_arrived_unlocked (DBusConnection *connection,
3818 DBusMessage *head_of_queue)
3819{
3820 HAVE_LOCK_CHECK (connection);
3821
3822 /* checking that the link is NULL is an optimization to avoid the is_signal call */
3823 if (connection->disconnect_message_link == NULL &&
3824 dbus_message_is_signal (head_of_queue,
3825 DBUS_INTERFACE_LOCAL,
3826 "Disconnected"))
3827 {
3828 connection->disconnected_message_arrived = TRUE;
3829 }
3830}
3831
3851 DBusMessage*
3852dbus_connection_borrow_message (DBusConnection *connection)
3853{
3854 DBusDispatchStatus status;
3855 DBusMessage *message;
3856
3857 _dbus_return_val_if_fail (connection != NULL, NULL);
3858
3859 _dbus_verbose ("start\n");
3860
3861 /* this is called for the side effect that it queues
3862 * up any messages from the transport
3863 */
3864 status = dbus_connection_get_dispatch_status (connection);
3865 if (status != DBUS_DISPATCH_DATA_REMAINS)
3866 return NULL;
3867
3868 CONNECTION_LOCK (connection);
3869
3870 _dbus_connection_acquire_dispatch (connection);
3871
3872 /* While a message is outstanding, the dispatch lock is held */
3873 _dbus_assert (connection->message_borrowed == NULL);
3874
3875 connection->message_borrowed = _dbus_list_get_first (&connection->incoming_messages);
3876
3877 message = connection->message_borrowed;
3878
3879 check_disconnected_message_arrived_unlocked (connection, message);
3880
3881 /* Note that we KEEP the dispatch lock until the message is returned */
3882 if (message == NULL)
3883 _dbus_connection_release_dispatch (connection);
3884
3885 CONNECTION_UNLOCK (connection);
3886
3887 _dbus_message_trace_ref (message, -1, -1, "dbus_connection_borrow_message");
3888
3889 /* We don't update dispatch status until it's returned or stolen */
3890
3891 return message;
3892}
3893
3902void
3903dbus_connection_return_message (DBusConnection *connection,
3904 DBusMessage *message)
3905{
3906 DBusDispatchStatus status;
3907
3908 _dbus_return_if_fail (connection != NULL);
3909 _dbus_return_if_fail (message != NULL);
3910 _dbus_return_if_fail (message == connection->message_borrowed);
3911 _dbus_return_if_fail (connection->dispatch_acquired);
3912
3913 CONNECTION_LOCK (connection);
3914
3915 _dbus_assert (message == connection->message_borrowed);
3916
3917 connection->message_borrowed = NULL;
3918
3919 _dbus_connection_release_dispatch (connection);
3920
3921 status = _dbus_connection_get_dispatch_status_unlocked (connection);
3922 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3923
3924 _dbus_message_trace_ref (message, -1, -1, "dbus_connection_return_message");
3925}
3926
3936void
3937dbus_connection_steal_borrowed_message (DBusConnection *connection,
3938 DBusMessage *message)
3939{
3940 DBusMessage *pop_message;
3941 DBusDispatchStatus status;
3942
3943 _dbus_return_if_fail (connection != NULL);
3944 _dbus_return_if_fail (message != NULL);
3945 _dbus_return_if_fail (message == connection->message_borrowed);
3946 _dbus_return_if_fail (connection->dispatch_acquired);
3947
3948 CONNECTION_LOCK (connection);
3949
3950 _dbus_assert (message == connection->message_borrowed);
3951
3952 pop_message = _dbus_list_pop_first (&connection->incoming_messages);
3953 _dbus_assert (message == pop_message);
3954 (void) pop_message; /* unused unless asserting */
3955
3956 connection->n_incoming -= 1;
3957
3958 _dbus_verbose ("Incoming message %p stolen from queue, %d incoming\n",
3959 message, connection->n_incoming);
3960
3961 connection->message_borrowed = NULL;
3962
3963 _dbus_connection_release_dispatch (connection);
3964
3965 status = _dbus_connection_get_dispatch_status_unlocked (connection);
3966 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
3967 _dbus_message_trace_ref (message, -1, -1,
3968 "dbus_connection_steal_borrowed_message");
3969}
3970
3971/* See dbus_connection_pop_message, but requires the caller to own
3972 * the lock before calling. May drop the lock while running.
3973 */
3974static DBusList*
3975_dbus_connection_pop_message_link_unlocked (DBusConnection *connection)
3976{
3977 HAVE_LOCK_CHECK (connection);
3978
3979 _dbus_assert (connection->message_borrowed == NULL);
3980
3981 if (connection->n_incoming > 0)
3982 {
3983 DBusList *link;
3984
3985 link = _dbus_list_pop_first_link (&connection->incoming_messages);
3986 connection->n_incoming -= 1;
3987
3988 _dbus_verbose ("Message %p (%s %s %s %s sig:'%s' serial:%u) removed from incoming queue %p, %d incoming\n",
3989 link->data,
3990 dbus_message_type_to_string (dbus_message_get_type (link->data)),
3991 dbus_message_get_path (link->data) ?
3992 dbus_message_get_path (link->data) :
3993 "no path",
3994 dbus_message_get_interface (link->data) ?
3995 dbus_message_get_interface (link->data) :
3996 "no interface",
3997 dbus_message_get_member (link->data) ?
3998 dbus_message_get_member (link->data) :
3999 "no member",
4000 dbus_message_get_signature (link->data),
4001 dbus_message_get_serial (link->data),
4002 connection, connection->n_incoming);
4003
4004 _dbus_message_trace_ref (link->data, -1, -1,
4005 "_dbus_connection_pop_message_link_unlocked");
4006
4007 check_disconnected_message_arrived_unlocked (connection, link->data);
4008
4009 return link;
4010 }
4011 else
4012 return NULL;
4013}
4014
4015/* See dbus_connection_pop_message, but requires the caller to own
4016 * the lock before calling. May drop the lock while running.
4017 */
4018static DBusMessage*
4019_dbus_connection_pop_message_unlocked (DBusConnection *connection)
4020{
4021 DBusList *link;
4022
4023 HAVE_LOCK_CHECK (connection);
4024
4025 link = _dbus_connection_pop_message_link_unlocked (connection);
4026
4027 if (link != NULL)
4028 {
4029 DBusMessage *message;
4030
4031 message = link->data;
4032
4033 _dbus_list_free_link (link);
4034
4035 return message;
4036 }
4037 else
4038 return NULL;
4039}
4040
4041static void
4042_dbus_connection_putback_message_link_unlocked (DBusConnection *connection,
4043 DBusList *message_link)
4044{
4045 HAVE_LOCK_CHECK (connection);
4046
4047 _dbus_assert (message_link != NULL);
4048 /* You can't borrow a message while a link is outstanding */
4049 _dbus_assert (connection->message_borrowed == NULL);
4050 /* We had to have the dispatch lock across the pop/putback */
4051 _dbus_assert (connection->dispatch_acquired);
4052
4053 _dbus_list_prepend_link (&connection->incoming_messages,
4054 message_link);
4055 connection->n_incoming += 1;
4056
4057 _dbus_verbose ("Message %p (%s %s %s '%s') put back into queue %p, %d incoming\n",
4058 message_link->data,
4059 dbus_message_type_to_string (dbus_message_get_type (message_link->data)),
4060 dbus_message_get_interface (message_link->data) ?
4061 dbus_message_get_interface (message_link->data) :
4062 "no interface",
4063 dbus_message_get_member (message_link->data) ?
4064 dbus_message_get_member (message_link->data) :
4065 "no member",
4066 dbus_message_get_signature (message_link->data),
4067 connection, connection->n_incoming);
4068
4069 _dbus_message_trace_ref (message_link->data, -1, -1,
4070 "_dbus_connection_putback_message_link_unlocked");
4071}
4072
4092 DBusMessage*
4093dbus_connection_pop_message (DBusConnection *connection)
4094{
4095 DBusMessage *message;
4096 DBusDispatchStatus status;
4097
4098 _dbus_verbose ("start\n");
4099
4100 /* this is called for the side effect that it queues
4101 * up any messages from the transport
4102 */
4103 status = dbus_connection_get_dispatch_status (connection);
4104 if (status != DBUS_DISPATCH_DATA_REMAINS)
4105 return NULL;
4106
4107 CONNECTION_LOCK (connection);
4108 _dbus_connection_acquire_dispatch (connection);
4109 HAVE_LOCK_CHECK (connection);
4110
4111 message = _dbus_connection_pop_message_unlocked (connection);
4112
4113 _dbus_verbose ("Returning popped message %p\n", message);
4114
4115 _dbus_connection_release_dispatch (connection);
4116
4117 status = _dbus_connection_get_dispatch_status_unlocked (connection);
4118 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4119
4120 return message;
4121}
4122
4130static void
4131_dbus_connection_acquire_dispatch (DBusConnection *connection)
4132{
4133 HAVE_LOCK_CHECK (connection);
4134
4135 _dbus_connection_ref_unlocked (connection);
4136 CONNECTION_UNLOCK (connection);
4137
4138 _dbus_verbose ("locking dispatch_mutex\n");
4139 _dbus_cmutex_lock (connection->dispatch_mutex);
4140
4141 while (connection->dispatch_acquired)
4142 {
4143 _dbus_verbose ("waiting for dispatch to be acquirable\n");
4144 _dbus_condvar_wait (connection->dispatch_cond,
4145 connection->dispatch_mutex);
4146 }
4147
4148 _dbus_assert (!connection->dispatch_acquired);
4149
4150 connection->dispatch_acquired = TRUE;
4151
4152 _dbus_verbose ("unlocking dispatch_mutex\n");
4153 _dbus_cmutex_unlock (connection->dispatch_mutex);
4154
4155 CONNECTION_LOCK (connection);
4156 _dbus_connection_unref_unlocked (connection);
4157}
4158
4166static void
4167_dbus_connection_release_dispatch (DBusConnection *connection)
4168{
4169 HAVE_LOCK_CHECK (connection);
4170
4171 _dbus_verbose ("locking dispatch_mutex\n");
4172 _dbus_cmutex_lock (connection->dispatch_mutex);
4173
4174 _dbus_assert (connection->dispatch_acquired);
4175
4176 connection->dispatch_acquired = FALSE;
4177 _dbus_condvar_wake_one (connection->dispatch_cond);
4178
4179 _dbus_verbose ("unlocking dispatch_mutex\n");
4180 _dbus_cmutex_unlock (connection->dispatch_mutex);
4181}
4182
4183static void
4184_dbus_connection_failed_pop (DBusConnection *connection,
4185 DBusList *message_link)
4186{
4187 _dbus_list_prepend_link (&connection->incoming_messages,
4188 message_link);
4189 connection->n_incoming += 1;
4190}
4191
4192/* Note this may be called multiple times since we don't track whether we already did it */
4193static void
4194notify_disconnected_unlocked (DBusConnection *connection)
4195{
4196 HAVE_LOCK_CHECK (connection);
4197
4198 /* Set the weakref in dbus-bus.c to NULL, so nobody will get a disconnected
4199 * connection from dbus_bus_get(). We make the same guarantee for
4200 * dbus_connection_open() but in a different way since we don't want to
4201 * unref right here; we instead check for connectedness before returning
4202 * the connection from the hash.
4203 */
4204 _dbus_bus_notify_shared_connection_disconnected_unlocked (connection);
4205
4206 /* Dump the outgoing queue, we aren't going to be able to
4207 * send it now, and we'd like accessors like
4208 * dbus_connection_get_outgoing_size() to be accurate.
4209 */
4210 if (connection->n_outgoing > 0)
4211 {
4212 DBusList *link;
4213
4214 _dbus_verbose ("Dropping %d outgoing messages since we're disconnected\n",
4215 connection->n_outgoing);
4216
4217 while ((link = _dbus_list_get_last_link (&connection->outgoing_messages)))
4218 {
4219 _dbus_connection_message_sent_unlocked (connection, link->data);
4220 }
4221 }
4222}
4223
4224/* Note this may be called multiple times since we don't track whether we already did it */
4225static DBusDispatchStatus
4226notify_disconnected_and_dispatch_complete_unlocked (DBusConnection *connection)
4227{
4228 HAVE_LOCK_CHECK (connection);
4229
4230 if (connection->disconnect_message_link != NULL)
4231 {
4232 _dbus_verbose ("Sending disconnect message\n");
4233
4234 /* If we have pending calls, queue their timeouts - we want the Disconnected
4235 * to be the last message, after these timeouts.
4236 */
4237 connection_timeout_and_complete_all_pending_calls_unlocked (connection);
4238
4239 /* We haven't sent the disconnect message already,
4240 * and all real messages have been queued up.
4241 */
4242 _dbus_connection_queue_synthesized_message_link (connection,
4243 connection->disconnect_message_link);
4244 connection->disconnect_message_link = NULL;
4245
4246 return DBUS_DISPATCH_DATA_REMAINS;
4247 }
4248
4249 return DBUS_DISPATCH_COMPLETE;
4250}
4251
4252static DBusDispatchStatus
4253_dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection)
4254{
4255 HAVE_LOCK_CHECK (connection);
4256
4257 if (connection->n_incoming > 0)
4258 return DBUS_DISPATCH_DATA_REMAINS;
4259 else if (!_dbus_transport_queue_messages (connection->transport))
4260 return DBUS_DISPATCH_NEED_MEMORY;
4261 else
4262 {
4263 DBusDispatchStatus status;
4264 dbus_bool_t is_connected;
4265
4266 status = _dbus_transport_get_dispatch_status (connection->transport);
4267 is_connected = _dbus_transport_get_is_connected (connection->transport);
4268
4269 _dbus_verbose ("dispatch status = %s is_connected = %d\n",
4270 DISPATCH_STATUS_NAME (status), is_connected);
4271
4272 if (!is_connected)
4273 {
4274 /* It's possible this would be better done by having an explicit
4275 * notification from _dbus_transport_disconnect() that would
4276 * synchronously do this, instead of waiting for the next dispatch
4277 * status check. However, probably not good to change until it causes
4278 * a problem.
4279 */
4280 notify_disconnected_unlocked (connection);
4281
4282 /* I'm not sure this is needed; the idea is that we want to
4283 * queue the Disconnected only after we've read all the
4284 * messages, but if we're disconnected maybe we are guaranteed
4285 * to have read them all ?
4286 */
4287 if (status == DBUS_DISPATCH_COMPLETE)
4288 status = notify_disconnected_and_dispatch_complete_unlocked (connection);
4289 }
4290
4291 if (status != DBUS_DISPATCH_COMPLETE)
4292 return status;
4293 else if (connection->n_incoming > 0)
4294 return DBUS_DISPATCH_DATA_REMAINS;
4295 else
4296 return DBUS_DISPATCH_COMPLETE;
4297 }
4298}
4299
4300static void
4301_dbus_connection_update_dispatch_status_and_unlock (DBusConnection *connection,
4302 DBusDispatchStatus new_status)
4303{
4304 dbus_bool_t changed;
4305 DBusDispatchStatusFunction function;
4306 void *data;
4307
4308 HAVE_LOCK_CHECK (connection);
4309
4310 _dbus_connection_ref_unlocked (connection);
4311
4312 changed = new_status != connection->last_dispatch_status;
4313
4314 connection->last_dispatch_status = new_status;
4315
4316 function = connection->dispatch_status_function;
4317 data = connection->dispatch_status_data;
4318
4319 if (connection->disconnected_message_arrived &&
4320 !connection->disconnected_message_processed)
4321 {
4322 connection->disconnected_message_processed = TRUE;
4323
4324 /* this does an unref, but we have a ref
4325 * so we should not run the finalizer here
4326 * inside the lock.
4327 */
4328 connection_forget_shared_unlocked (connection);
4329
4330 if (connection->exit_on_disconnect)
4331 {
4332 CONNECTION_UNLOCK (connection);
4333
4334 _dbus_verbose ("Exiting on Disconnected signal\n");
4335 _dbus_exit (1);
4336 _dbus_assert_not_reached ("Call to exit() returned");
4337 }
4338 }
4339
4340 /* We drop the lock */
4341 CONNECTION_UNLOCK (connection);
4342
4343 if (changed && function)
4344 {
4345 _dbus_verbose ("Notifying of change to dispatch status of %p now %d (%s)\n",
4346 connection, new_status,
4347 DISPATCH_STATUS_NAME (new_status));
4348 (* function) (connection, new_status, data);
4349 }
4350
4351 dbus_connection_unref (connection);
4352}
4353
4379 DBusDispatchStatus
4380dbus_connection_get_dispatch_status (DBusConnection *connection)
4381{
4382 DBusDispatchStatus status;
4383
4384 _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
4385
4386 _dbus_verbose ("start\n");
4387
4388 CONNECTION_LOCK (connection);
4389
4390 status = _dbus_connection_get_dispatch_status_unlocked (connection);
4391
4392 CONNECTION_UNLOCK (connection);
4393
4394 return status;
4395}
4396
4400static DBusHandlerResult
4401_dbus_connection_peer_filter_unlocked_no_update (DBusConnection *connection,
4402 DBusMessage *message)
4403{
4404 dbus_bool_t sent = FALSE;
4405 DBusMessage *ret = NULL;
4406 DBusList *expire_link;
4407
4408 if (connection->route_peer_messages && dbus_message_get_destination (message) != NULL)
4409 {
4410 /* This means we're letting the bus route this message */
4411 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
4412 }
4413
4414 if (!dbus_message_has_interface (message, DBUS_INTERFACE_PEER))
4415 {
4416 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
4417 }
4418
4419 /* Preallocate a linked-list link, so that if we need to dispose of a
4420 * message, we can attach it to the expired list */
4421 expire_link = _dbus_list_alloc_link (NULL);
4422
4423 if (!expire_link)
4424 return DBUS_HANDLER_RESULT_NEED_MEMORY;
4425
4426 if (dbus_message_is_method_call (message,
4427 DBUS_INTERFACE_PEER,
4428 "Ping"))
4429 {
4430 ret = dbus_message_new_method_return (message);
4431 if (ret == NULL)
4432 goto out;
4433
4434 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4435 }
4436 else if (dbus_message_is_method_call (message,
4437 DBUS_INTERFACE_PEER,
4438 "GetMachineId"))
4439 {
4440 DBusString uuid;
4441 DBusError error = DBUS_ERROR_INIT;
4442
4443 if (!_dbus_string_init (&uuid))
4444 goto out;
4445
4446 if (_dbus_get_local_machine_uuid_encoded (&uuid, &error))
4447 {
4448 const char *v_STRING;
4449
4450 ret = dbus_message_new_method_return (message);
4451
4452 if (ret == NULL)
4453 {
4454 _dbus_string_free (&uuid);
4455 goto out;
4456 }
4457
4458 v_STRING = _dbus_string_get_const_data (&uuid);
4459 if (dbus_message_append_args (ret,
4460 DBUS_TYPE_STRING, &v_STRING,
4461 DBUS_TYPE_INVALID))
4462 {
4463 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4464 }
4465 }
4466 else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
4467 {
4468 dbus_error_free (&error);
4469 goto out;
4470 }
4471 else
4472 {
4473 ret = dbus_message_new_error (message, error.name, error.message);
4474 dbus_error_free (&error);
4475
4476 if (ret == NULL)
4477 goto out;
4478
4479 sent = _dbus_connection_send_unlocked_no_update (connection, ret,
4480 NULL);
4481 }
4482
4483 _dbus_string_free (&uuid);
4484 }
4485 else
4486 {
4487 /* We need to bounce anything else with this interface, otherwise apps
4488 * could start extending the interface and when we added extensions
4489 * here to DBusConnection we'd break those apps.
4490 */
4491 ret = dbus_message_new_error (message,
4492 DBUS_ERROR_UNKNOWN_METHOD,
4493 "Unknown method invoked on org.freedesktop.DBus.Peer interface");
4494 if (ret == NULL)
4495 goto out;
4496
4497 sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
4498 }
4499
4500out:
4501 if (ret == NULL)
4502 {
4503 _dbus_list_free_link (expire_link);
4504 }
4505 else
4506 {
4507 /* It'll be safe to unref the reply when we unlock */
4508 expire_link->data = ret;
4509 _dbus_list_prepend_link (&connection->expired_messages, expire_link);
4510 }
4511
4512 if (!sent)
4513 return DBUS_HANDLER_RESULT_NEED_MEMORY;
4514
4515 return DBUS_HANDLER_RESULT_HANDLED;
4516}
4517
4524static DBusHandlerResult
4525_dbus_connection_run_builtin_filters_unlocked_no_update (DBusConnection *connection,
4526 DBusMessage *message)
4527{
4528 /* We just run one filter for now but have the option to run more
4529 if the spec calls for it in the future */
4530
4531 return _dbus_connection_peer_filter_unlocked_no_update (connection, message);
4532}
4533
4576 DBusDispatchStatus
4577dbus_connection_dispatch (DBusConnection *connection)
4578{
4579 DBusMessage *message;
4580 DBusList *link, *filter_list_copy, *message_link;
4581 DBusHandlerResult result;
4582 DBusPendingCall *pending;
4583 dbus_int32_t reply_serial;
4584 DBusDispatchStatus status;
4585 dbus_bool_t found_object;
4586
4587 _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
4588
4589 _dbus_verbose ("\n");
4590
4591 CONNECTION_LOCK (connection);
4592 status = _dbus_connection_get_dispatch_status_unlocked (connection);
4593 if (status != DBUS_DISPATCH_DATA_REMAINS)
4594 {
4595 /* unlocks and calls out to user code */
4596 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4597 return status;
4598 }
4599
4600 /* We need to ref the connection since the callback could potentially
4601 * drop the last ref to it
4602 */
4603 _dbus_connection_ref_unlocked (connection);
4604
4605 _dbus_connection_acquire_dispatch (connection);
4606 HAVE_LOCK_CHECK (connection);
4607
4608 message_link = _dbus_connection_pop_message_link_unlocked (connection);
4609 if (message_link == NULL)
4610 {
4611 /* another thread dispatched our stuff */
4612
4613 _dbus_verbose ("another thread dispatched message (during acquire_dispatch above)\n");
4614
4615 _dbus_connection_release_dispatch (connection);
4616
4617 status = _dbus_connection_get_dispatch_status_unlocked (connection);
4618
4619 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4620
4621 dbus_connection_unref (connection);
4622
4623 return status;
4624 }
4625
4626 message = message_link->data;
4627
4628 _dbus_verbose (" dispatching message %p (%s %s %s '%s')\n",
4629 message,
4630 dbus_message_type_to_string (dbus_message_get_type (message)),
4631 dbus_message_get_interface (message) ?
4632 dbus_message_get_interface (message) :
4633 "no interface",
4634 dbus_message_get_member (message) ?
4635 dbus_message_get_member (message) :
4636 "no member",
4637 dbus_message_get_signature (message));
4638
4639 result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
4640
4641 /* Pending call handling must be first, because if you do
4642 * dbus_connection_send_with_reply_and_block() or
4643 * dbus_pending_call_block() then no handlers/filters will be run on
4644 * the reply. We want consistent semantics in the case where we
4645 * dbus_connection_dispatch() the reply.
4646 */
4647
4648 reply_serial = dbus_message_get_reply_serial (message);
4649 pending = _dbus_hash_table_lookup_int (connection->pending_replies,
4650 reply_serial);
4651 if (pending)
4652 {
4653 _dbus_verbose ("Dispatching a pending reply\n");
4654 complete_pending_call_and_unlock (connection, pending, message);
4655 pending = NULL; /* it's probably unref'd */
4656
4657 CONNECTION_LOCK (connection);
4658 _dbus_verbose ("pending call completed in dispatch\n");
4659 result = DBUS_HANDLER_RESULT_HANDLED;
4660 goto out;
4661 }
4662
4663 /* If skipping builtin filters, we are probably a monitor. */
4664 if (connection->builtin_filters_enabled)
4665 {
4666 result = _dbus_connection_run_builtin_filters_unlocked_no_update (connection, message);
4667 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
4668 goto out;
4669 }
4670
4671 if (!_dbus_list_copy (&connection->filter_list, &filter_list_copy))
4672 {
4673 _dbus_connection_release_dispatch (connection);
4674 HAVE_LOCK_CHECK (connection);
4675
4676 _dbus_connection_failed_pop (connection, message_link);
4677
4678 /* unlocks and calls user code */
4679 _dbus_connection_update_dispatch_status_and_unlock (connection,
4680 DBUS_DISPATCH_NEED_MEMORY);
4681 dbus_connection_unref (connection);
4682
4683 return DBUS_DISPATCH_NEED_MEMORY;
4684 }
4685
4686 for (link = _dbus_list_get_first_link (&filter_list_copy);
4687 link != NULL;
4688 link = _dbus_list_get_next_link (&filter_list_copy, link))
4689 _dbus_message_filter_ref (link->data);
4690
4691 /* We're still protected from dispatch() reentrancy here
4692 * since we acquired the dispatcher
4693 */
4694 CONNECTION_UNLOCK (connection);
4695
4696 link = _dbus_list_get_first_link (&filter_list_copy);
4697 while (link != NULL)
4698 {
4699 DBusMessageFilter *filter = link->data;
4700 DBusList *next = _dbus_list_get_next_link (&filter_list_copy, link);
4701
4702 if (filter->function == NULL)
4703 {
4704 _dbus_verbose (" filter was removed in a callback function\n");
4705 link = next;
4706 continue;
4707 }
4708
4709 _dbus_verbose (" running filter on message %p\n", message);
4710 result = (* filter->function) (connection, message, filter->user_data);
4711
4712 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
4713 break;
4714
4715 link = next;
4716 }
4717
4718 _dbus_list_clear_full (&filter_list_copy,
4719 (DBusFreeFunction) _dbus_message_filter_unref);
4720
4721 CONNECTION_LOCK (connection);
4722
4723 if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
4724 {
4725 _dbus_verbose ("No memory\n");
4726 goto out;
4727 }
4728 else if (result == DBUS_HANDLER_RESULT_HANDLED)
4729 {
4730 _dbus_verbose ("filter handled message in dispatch\n");
4731 goto out;
4732 }
4733
4734 /* We're still protected from dispatch() reentrancy here
4735 * since we acquired the dispatcher
4736 */
4737 _dbus_verbose (" running object path dispatch on message %p (%s %s %s '%s')\n",
4738 message,
4739 dbus_message_type_to_string (dbus_message_get_type (message)),
4740 dbus_message_get_interface (message) ?
4741 dbus_message_get_interface (message) :
4742 "no interface",
4743 dbus_message_get_member (message) ?
4744 dbus_message_get_member (message) :
4745 "no member",
4746 dbus_message_get_signature (message));
4747
4748 HAVE_LOCK_CHECK (connection);
4749 result = _dbus_object_tree_dispatch_and_unlock (connection->objects,
4750 message,
4751 &found_object);
4752
4753 CONNECTION_LOCK (connection);
4754
4755 if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
4756 {
4757 _dbus_verbose ("object tree handled message in dispatch\n");
4758 goto out;
4759 }
4760
4761 if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
4762 {
4763 DBusMessage *reply;
4764 DBusString str;
4765 DBusPreallocatedSend *preallocated;
4766 DBusList *expire_link;
4767
4768 _dbus_verbose (" sending error %s\n",
4769 DBUS_ERROR_UNKNOWN_METHOD);
4770
4771 if (!_dbus_string_init (&str))
4772 {
4773 result = DBUS_HANDLER_RESULT_NEED_MEMORY;
4774 _dbus_verbose ("no memory for error string in dispatch\n");
4775 goto out;
4776 }
4777
4778 if (!_dbus_string_append_printf (&str,
4779 "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
4780 dbus_message_get_member (message),
4781 dbus_message_get_signature (message),
4782 dbus_message_get_interface (message)))
4783 {
4784 _dbus_string_free (&str);
4785 result = DBUS_HANDLER_RESULT_NEED_MEMORY;
4786 _dbus_verbose ("no memory for error string in dispatch\n");
4787 goto out;
4788 }
4789
4790 reply = dbus_message_new_error (message,
4791 found_object ? DBUS_ERROR_UNKNOWN_METHOD : DBUS_ERROR_UNKNOWN_OBJECT,
4792 _dbus_string_get_const_data (&str));
4793 _dbus_string_free (&str);
4794
4795 if (reply == NULL)
4796 {
4797 result = DBUS_HANDLER_RESULT_NEED_MEMORY;
4798 _dbus_verbose ("no memory for error reply in dispatch\n");
4799 goto out;
4800 }
4801
4802 expire_link = _dbus_list_alloc_link (reply);
4803
4804 if (expire_link == NULL)
4805 {
4806 dbus_message_unref (reply);
4807 result = DBUS_HANDLER_RESULT_NEED_MEMORY;
4808 _dbus_verbose ("no memory for error send in dispatch\n");
4809 goto out;
4810 }
4811
4812 preallocated = _dbus_connection_preallocate_send_unlocked (connection);
4813
4814 if (preallocated == NULL)
4815 {
4816 _dbus_list_free_link (expire_link);
4817 /* It's OK that this is finalized, because it hasn't been seen by
4818 * anything that could attach user callbacks */
4819 dbus_message_unref (reply);
4820 result = DBUS_HANDLER_RESULT_NEED_MEMORY;
4821 _dbus_verbose ("no memory for error send in dispatch\n");
4822 goto out;
4823 }
4824
4825 _dbus_connection_send_preallocated_unlocked_no_update (connection, preallocated,
4826 reply, NULL);
4827 /* reply will be freed when we release the lock */
4828 _dbus_list_prepend_link (&connection->expired_messages, expire_link);
4829
4830 result = DBUS_HANDLER_RESULT_HANDLED;
4831 }
4832
4833 _dbus_verbose (" done dispatching %p (%s %s %s '%s') on connection %p\n", message,
4834 dbus_message_type_to_string (dbus_message_get_type (message)),
4835 dbus_message_get_interface (message) ?
4836 dbus_message_get_interface (message) :
4837 "no interface",
4838 dbus_message_get_member (message) ?
4839 dbus_message_get_member (message) :
4840 "no member",
4841 dbus_message_get_signature (message),
4842 connection);
4843
4844 out:
4845 if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
4846 {
4847 _dbus_verbose ("out of memory\n");
4848
4849 /* Put message back, and we'll start over.
4850 * Yes this means handlers must be idempotent if they
4851 * don't return HANDLED; c'est la vie.
4852 */
4853 _dbus_connection_putback_message_link_unlocked (connection,
4854 message_link);
4855 /* now we don't want to free them */
4856 message_link = NULL;
4857 message = NULL;
4858 }
4859 else
4860 {
4861 _dbus_verbose (" ... done dispatching\n");
4862 }
4863
4864 _dbus_connection_release_dispatch (connection);
4865 HAVE_LOCK_CHECK (connection);
4866
4867 if (message != NULL)
4868 {
4869 /* We don't want this message to count in maximum message limits when
4870 * computing the dispatch status, below. We have to drop the lock
4871 * temporarily, because finalizing a message can trigger callbacks.
4872 *
4873 * We have a reference to the connection, and we don't use any cached
4874 * pointers to the connection's internals below this point, so it should
4875 * be safe to drop the lock and take it back. */
4876 CONNECTION_UNLOCK (connection);
4877 dbus_message_unref (message);
4878 CONNECTION_LOCK (connection);
4879 }
4880
4881 if (message_link != NULL)
4882 _dbus_list_free_link (message_link);
4883
4884 _dbus_verbose ("before final status update\n");
4885 status = _dbus_connection_get_dispatch_status_unlocked (connection);
4886
4887 /* unlocks and calls user code */
4888 _dbus_connection_update_dispatch_status_and_unlock (connection, status);
4889
4890 dbus_connection_unref (connection);
4891
4892 return status;
4893}
4894
4956 dbus_bool_t
4957dbus_connection_set_watch_functions (DBusConnection *connection,
4958 DBusAddWatchFunction add_function,
4959 DBusRemoveWatchFunction remove_function,
4960 DBusWatchToggledFunction toggled_function,
4961 void *data,
4962 DBusFreeFunction free_data_function)
4963{
4964 dbus_bool_t retval;
4965
4966 _dbus_return_val_if_fail (connection != NULL, FALSE);
4967
4968 CONNECTION_LOCK (connection);
4969
4970 retval = _dbus_watch_list_set_functions (connection->watches,
4971 add_function, remove_function,
4972 toggled_function,
4973 data, free_data_function);
4974
4975 CONNECTION_UNLOCK (connection);
4976
4977 return retval;
4978}
4979
5019 dbus_bool_t
5020dbus_connection_set_timeout_functions (DBusConnection *connection,
5021 DBusAddTimeoutFunction add_function,
5022 DBusRemoveTimeoutFunction remove_function,
5023 DBusTimeoutToggledFunction toggled_function,
5024 void *data,
5025 DBusFreeFunction free_data_function)
5026{
5027 dbus_bool_t retval;
5028
5029 _dbus_return_val_if_fail (connection != NULL, FALSE);
5030
5031 CONNECTION_LOCK (connection);
5032
5033 retval = _dbus_timeout_list_set_functions (connection->timeouts,
5034 add_function, remove_function,
5035 toggled_function,
5036 data, free_data_function);
5037
5038 CONNECTION_UNLOCK (connection);
5039
5040 return retval;
5041}
5042
5057void
5058dbus_connection_set_wakeup_main_function (DBusConnection *connection,
5059 DBusWakeupMainFunction wakeup_main_function,
5060 void *data,
5061 DBusFreeFunction free_data_function)
5062{
5063 void *old_data;
5064 DBusFreeFunction old_free_data;
5065
5066 _dbus_return_if_fail (connection != NULL);
5067
5068 CONNECTION_LOCK (connection);
5069 old_data = connection->wakeup_main_data;
5070 old_free_data = connection->free_wakeup_main_data;
5071
5072 connection->wakeup_main_function = wakeup_main_function;
5073 connection->wakeup_main_data = data;
5074 connection->free_wakeup_main_data = free_data_function;
5075
5076 CONNECTION_UNLOCK (connection);
5077
5078 /* Callback outside the lock */
5079 if (old_free_data)
5080 (*old_free_data) (old_data);
5081}
5082
5103void
5104dbus_connection_set_dispatch_status_function (DBusConnection *connection,
5105 DBusDispatchStatusFunction function,
5106 void *data,
5107 DBusFreeFunction free_data_function)
5108{
5109 void *old_data;
5110 DBusFreeFunction old_free_data;
5111
5112 _dbus_return_if_fail (connection != NULL);
5113
5114 CONNECTION_LOCK (connection);
5115 old_data = connection->dispatch_status_data;
5116 old_free_data = connection->free_dispatch_status_data;
5117
5118 connection->dispatch_status_function = function;
5119 connection->dispatch_status_data = data;
5120 connection->free_dispatch_status_data = free_data_function;
5121
5122 CONNECTION_UNLOCK (connection);
5123
5124 /* Callback outside the lock */
5125 if (old_free_data)
5126 (*old_free_data) (old_data);
5127}
5128
5148 dbus_bool_t
5149dbus_connection_get_unix_fd (DBusConnection *connection,
5150 int *fd)
5151{
5152 _dbus_return_val_if_fail (connection != NULL, FALSE);
5153 _dbus_return_val_if_fail (connection->transport != NULL, FALSE);
5154
5155#ifdef DBUS_WIN
5156 /* FIXME do this on a lower level */
5157 return FALSE;
5158#endif
5159
5160 return dbus_connection_get_socket(connection, fd);
5161}
5162
5178 dbus_bool_t
5179dbus_connection_get_socket(DBusConnection *connection,
5180 int *fd)
5181{
5182 dbus_bool_t retval;
5183 DBusSocket s = DBUS_SOCKET_INIT;
5184
5185 _dbus_return_val_if_fail (connection != NULL, FALSE);
5186 _dbus_return_val_if_fail (connection->transport != NULL, FALSE);
5187
5188 CONNECTION_LOCK (connection);
5189
5190 retval = _dbus_transport_get_socket_fd (connection->transport, &s);
5191
5192 if (retval)
5193 {
5194 *fd = _dbus_socket_get_int (s);
5195 }
5196
5197 CONNECTION_UNLOCK (connection);
5198
5199 return retval;
5200}
5201
5202
5225 dbus_bool_t
5226dbus_connection_get_unix_user (DBusConnection *connection,
5227 unsigned long *uid)
5228{
5229 dbus_bool_t result;
5230
5231 _dbus_return_val_if_fail (connection != NULL, FALSE);
5232 _dbus_return_val_if_fail (uid != NULL, FALSE);
5233
5234 CONNECTION_LOCK (connection);
5235
5236 if (!_dbus_transport_try_to_authenticate (connection->transport))
5237 result = FALSE;
5238 else
5239 result = _dbus_transport_get_unix_user (connection->transport,
5240 uid);
5241
5242#ifdef DBUS_WIN
5243 _dbus_assert (!result);
5244#endif
5245
5246 CONNECTION_UNLOCK (connection);
5247
5248 return result;
5249}
5250
5261 dbus_bool_t
5262dbus_connection_get_unix_process_id (DBusConnection *connection,
5263 unsigned long *pid)
5264{
5265 dbus_bool_t result;
5266
5267 _dbus_return_val_if_fail (connection != NULL, FALSE);
5268 _dbus_return_val_if_fail (pid != NULL, FALSE);
5269
5270 CONNECTION_LOCK (connection);
5271
5272 if (!_dbus_transport_try_to_authenticate (connection->transport))
5273 result = FALSE;
5274 else
5275 result = _dbus_transport_get_unix_process_id (connection->transport,
5276 pid);
5277
5278 CONNECTION_UNLOCK (connection);
5279
5280 return result;
5281}
5282
5294 dbus_bool_t
5295dbus_connection_get_adt_audit_session_data (DBusConnection *connection,
5296 void **data,
5297 dbus_int32_t *data_size)
5298{
5299 dbus_bool_t result;
5300
5301 _dbus_return_val_if_fail (connection != NULL, FALSE);
5302 _dbus_return_val_if_fail (data != NULL, FALSE);
5303 _dbus_return_val_if_fail (data_size != NULL, FALSE);
5304
5305 CONNECTION_LOCK (connection);
5306
5307 if (!_dbus_transport_try_to_authenticate (connection->transport))
5308 result = FALSE;
5309 else
5310 result = _dbus_transport_get_adt_audit_session_data (connection->transport,
5311 data,
5312 data_size);
5313 CONNECTION_UNLOCK (connection);
5314
5315 return result;
5316}
5317
5340void
5341dbus_connection_set_unix_user_function (DBusConnection *connection,
5342 DBusAllowUnixUserFunction function,
5343 void *data,
5344 DBusFreeFunction free_data_function)
5345{
5346 void *old_data = NULL;
5347 DBusFreeFunction old_free_function = NULL;
5348
5349 _dbus_return_if_fail (connection != NULL);
5350
5351 CONNECTION_LOCK (connection);
5352 _dbus_transport_set_unix_user_function (connection->transport,
5353 function, data, free_data_function,
5354 &old_data, &old_free_function);
5355 CONNECTION_UNLOCK (connection);
5356
5357 if (old_free_function != NULL)
5358 (* old_free_function) (old_data);
5359}
5360
5361/* Same calling convention as dbus_connection_get_windows_user */
5362 dbus_bool_t
5363_dbus_connection_get_linux_security_label (DBusConnection *connection,
5364 char **label_p)
5365{
5366 dbus_bool_t result;
5367
5368 _dbus_assert (connection != NULL);
5369 _dbus_assert (label_p != NULL);
5370
5371 CONNECTION_LOCK (connection);
5372
5373 if (!_dbus_transport_try_to_authenticate (connection->transport))
5374 result = FALSE;
5375 else
5376 result = _dbus_transport_get_linux_security_label (connection->transport,
5377 label_p);
5378#ifndef __linux__
5379 _dbus_assert (!result);
5380#endif
5381
5382 CONNECTION_UNLOCK (connection);
5383
5384 return result;
5385}
5386
5387 DBusCredentials *
5388_dbus_connection_get_credentials (DBusConnection *connection)
5389{
5390 DBusCredentials *result;
5391
5392 _dbus_assert (connection != NULL);
5393
5394 CONNECTION_LOCK (connection);
5395
5396 if (!_dbus_transport_try_to_authenticate (connection->transport))
5397 result = NULL;
5398 else
5399 result = _dbus_transport_get_credentials (connection->transport);
5400
5401 CONNECTION_UNLOCK (connection);
5402
5403 return result;
5404}
5405
5437 dbus_bool_t
5438dbus_connection_get_windows_user (DBusConnection *connection,
5439 char **windows_sid_p)
5440{
5441 dbus_bool_t result;
5442
5443 _dbus_return_val_if_fail (connection != NULL, FALSE);
5444 _dbus_return_val_if_fail (windows_sid_p != NULL, FALSE);
5445
5446 CONNECTION_LOCK (connection);
5447
5448 if (!_dbus_transport_try_to_authenticate (connection->transport))
5449 result = FALSE;
5450 else
5451 result = _dbus_transport_get_windows_user (connection->transport,
5452 windows_sid_p);
5453
5454#ifdef DBUS_UNIX
5455 _dbus_assert (!result);
5456#endif
5457
5458 CONNECTION_UNLOCK (connection);
5459
5460 return result;
5461}
5462
5484void
5485dbus_connection_set_windows_user_function (DBusConnection *connection,
5486 DBusAllowWindowsUserFunction function,
5487 void *data,
5488 DBusFreeFunction free_data_function)
5489{
5490 void *old_data = NULL;
5491 DBusFreeFunction old_free_function = NULL;
5492
5493 _dbus_return_if_fail (connection != NULL);
5494
5495 CONNECTION_LOCK (connection);
5496 _dbus_transport_set_windows_user_function (connection->transport,
5497 function, data, free_data_function,
5498 &old_data, &old_free_function);
5499 CONNECTION_UNLOCK (connection);
5500
5501 if (old_free_function != NULL)
5502 (* old_free_function) (old_data);
5503}
5504
5531void
5532dbus_connection_set_allow_anonymous (DBusConnection *connection,
5533 dbus_bool_t value)
5534{
5535 _dbus_return_if_fail (connection != NULL);
5536
5537 CONNECTION_LOCK (connection);
5538 _dbus_transport_set_allow_anonymous (connection->transport, value);
5539 CONNECTION_UNLOCK (connection);
5540}
5541
5563void
5564_dbus_connection_set_builtin_filters_enabled (DBusConnection *connection,
5565 dbus_bool_t value)
5566{
5567 _dbus_assert (connection != NULL);
5568
5569 CONNECTION_LOCK (connection);
5570 connection->builtin_filters_enabled = value;
5571 CONNECTION_UNLOCK (connection);
5572}
5573
5591void
5592dbus_connection_set_route_peer_messages (DBusConnection *connection,
5593 dbus_bool_t value)
5594{
5595 _dbus_return_if_fail (connection != NULL);
5596
5597 CONNECTION_LOCK (connection);
5598 connection->route_peer_messages = value;
5599 CONNECTION_UNLOCK (connection);
5600}
5601
5623 dbus_bool_t
5624dbus_connection_add_filter (DBusConnection *connection,
5625 DBusHandleMessageFunction function,
5626 void *user_data,
5627 DBusFreeFunction free_data_function)
5628{
5629 DBusMessageFilter *filter;
5630
5631 _dbus_return_val_if_fail (connection != NULL, FALSE);
5632 _dbus_return_val_if_fail (function != NULL, FALSE);
5633
5634 filter = dbus_new0 (DBusMessageFilter, 1);
5635 if (filter == NULL)
5636 return FALSE;
5637
5638 _dbus_atomic_inc (&filter->refcount);
5639
5640 CONNECTION_LOCK (connection);
5641
5642 if (!_dbus_list_append (&connection->filter_list,
5643 filter))
5644 {
5645 _dbus_message_filter_unref (filter);
5646 CONNECTION_UNLOCK (connection);
5647 return FALSE;
5648 }
5649
5650 /* Fill in filter after all memory allocated,
5651 * so we don't run the free_user_data_function
5652 * if the add_filter() fails
5653 */
5654
5655 filter->function = function;
5656 filter->user_data = user_data;
5657 filter->free_user_data_function = free_data_function;
5658
5659 CONNECTION_UNLOCK (connection);
5660 return TRUE;
5661}
5662
5675void
5676dbus_connection_remove_filter (DBusConnection *connection,
5677 DBusHandleMessageFunction function,
5678 void *user_data)
5679{
5680 DBusList *link;
5681 DBusMessageFilter *filter;
5682
5683 _dbus_return_if_fail (connection != NULL);
5684 _dbus_return_if_fail (function != NULL);
5685
5686 CONNECTION_LOCK (connection);
5687
5688 filter = NULL;
5689
5690 link = _dbus_list_get_last_link (&connection->filter_list);
5691 while (link != NULL)
5692 {
5693 filter = link->data;
5694
5695 if (filter->function == function &&
5696 filter->user_data == user_data)
5697 {
5698 _dbus_list_remove_link (&connection->filter_list, link);
5699 filter->function = NULL;
5700
5701 break;
5702 }
5703
5704 link = _dbus_list_get_prev_link (&connection->filter_list, link);
5705 filter = NULL;
5706 }
5707
5708 CONNECTION_UNLOCK (connection);
5709
5710#ifndef DBUS_DISABLE_CHECKS
5711 if (filter == NULL)
5712 {
5713 _dbus_warn_check_failed ("Attempt to remove filter function %p user data %p, but no such filter has been added",
5714 function, user_data);
5715 return;
5716 }
5717#endif
5718
5719 /* Call application code */
5720 if (filter->free_user_data_function)
5721 (* filter->free_user_data_function) (filter->user_data);
5722
5723 filter->free_user_data_function = NULL;
5724 filter->user_data = NULL;
5725
5726 _dbus_message_filter_unref (filter);
5727}
5728
5744static dbus_bool_t
5745_dbus_connection_register_object_path (DBusConnection *connection,
5746 dbus_bool_t fallback,
5747 const char *path,
5748 const DBusObjectPathVTable *vtable,
5749 void *user_data,
5750 DBusError *error)
5751{
5752 char **decomposed_path;
5753 dbus_bool_t retval;
5754
5755 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5756 return FALSE;
5757
5758 CONNECTION_LOCK (connection);
5759
5760 retval = _dbus_object_tree_register (connection->objects,
5761 fallback,
5762 (const char **) decomposed_path, vtable,
5763 user_data, error);
5764
5765 CONNECTION_UNLOCK (connection);
5766
5767 dbus_free_string_array (decomposed_path);
5768
5769 return retval;
5770}
5771
5784 dbus_bool_t
5785dbus_connection_try_register_object_path (DBusConnection *connection,
5786 const char *path,
5787 const DBusObjectPathVTable *vtable,
5788 void *user_data,
5789 DBusError *error)
5790{
5791 _dbus_return_val_if_fail (connection != NULL, FALSE);
5792 _dbus_return_val_if_fail (path != NULL, FALSE);
5793 _dbus_return_val_if_fail (path[0] == '/', FALSE);
5794 _dbus_return_val_if_fail (vtable != NULL, FALSE);
5795
5796 return _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, error);
5797}
5798
5814 dbus_bool_t
5815dbus_connection_register_object_path (DBusConnection *connection,
5816 const char *path,
5817 const DBusObjectPathVTable *vtable,
5818 void *user_data)
5819{
5820 dbus_bool_t retval;
5821 DBusError error = DBUS_ERROR_INIT;
5822
5823 _dbus_return_val_if_fail (connection != NULL, FALSE);
5824 _dbus_return_val_if_fail (path != NULL, FALSE);
5825 _dbus_return_val_if_fail (path[0] == '/', FALSE);
5826 _dbus_return_val_if_fail (vtable != NULL, FALSE);
5827
5828 retval = _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, &error);
5829
5830 if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
5831 {
5832 _dbus_warn ("%s", error.message);
5833 dbus_error_free (&error);
5834 return FALSE;
5835 }
5836
5837 return retval;
5838}
5839
5854 dbus_bool_t
5855dbus_connection_try_register_fallback (DBusConnection *connection,
5856 const char *path,
5857 const DBusObjectPathVTable *vtable,
5858 void *user_data,
5859 DBusError *error)
5860{
5861 _dbus_return_val_if_fail (connection != NULL, FALSE);
5862 _dbus_return_val_if_fail (path != NULL, FALSE);
5863 _dbus_return_val_if_fail (path[0] == '/', FALSE);
5864 _dbus_return_val_if_fail (vtable != NULL, FALSE);
5865
5866 return _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, error);
5867}
5868
5886 dbus_bool_t
5887dbus_connection_register_fallback (DBusConnection *connection,
5888 const char *path,
5889 const DBusObjectPathVTable *vtable,
5890 void *user_data)
5891{
5892 dbus_bool_t retval;
5893 DBusError error = DBUS_ERROR_INIT;
5894
5895 _dbus_return_val_if_fail (connection != NULL, FALSE);
5896 _dbus_return_val_if_fail (path != NULL, FALSE);
5897 _dbus_return_val_if_fail (path[0] == '/', FALSE);
5898 _dbus_return_val_if_fail (vtable != NULL, FALSE);
5899
5900 retval = _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, &error);
5901
5902 if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
5903 {
5904 _dbus_warn ("%s", error.message);
5905 dbus_error_free (&error);
5906 return FALSE;
5907 }
5908
5909 return retval;
5910}
5911
5921 dbus_bool_t
5922dbus_connection_unregister_object_path (DBusConnection *connection,
5923 const char *path)
5924{
5925 char **decomposed_path;
5926
5927 _dbus_return_val_if_fail (connection != NULL, FALSE);
5928 _dbus_return_val_if_fail (path != NULL, FALSE);
5929 _dbus_return_val_if_fail (path[0] == '/', FALSE);
5930
5931 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5932 return FALSE;
5933
5934 CONNECTION_LOCK (connection);
5935
5936 _dbus_object_tree_unregister_and_unlock (connection->objects, (const char **) decomposed_path);
5937
5938 dbus_free_string_array (decomposed_path);
5939
5940 return TRUE;
5941}
5942
5953 dbus_bool_t
5954dbus_connection_get_object_path_data (DBusConnection *connection,
5955 const char *path,
5956 void **data_p)
5957{
5958 char **decomposed_path;
5959
5960 _dbus_return_val_if_fail (connection != NULL, FALSE);
5961 _dbus_return_val_if_fail (path != NULL, FALSE);
5962 _dbus_return_val_if_fail (data_p != NULL, FALSE);
5963
5964 *data_p = NULL;
5965
5966 if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
5967 return FALSE;
5968
5969 CONNECTION_LOCK (connection);
5970
5971 *data_p = _dbus_object_tree_get_user_data_unlocked (connection->objects, (const char**) decomposed_path);
5972
5973 CONNECTION_UNLOCK (connection);
5974
5975 dbus_free_string_array (decomposed_path);
5976
5977 return TRUE;
5978}
5979
5990 dbus_bool_t
5991dbus_connection_list_registered (DBusConnection *connection,
5992 const char *parent_path,
5993 char ***child_entries)
5994{
5995 char **decomposed_path;
5996 dbus_bool_t retval;
5997 _dbus_return_val_if_fail (connection != NULL, FALSE);
5998 _dbus_return_val_if_fail (parent_path != NULL, FALSE);
5999 _dbus_return_val_if_fail (parent_path[0] == '/', FALSE);
6000 _dbus_return_val_if_fail (child_entries != NULL, FALSE);
6001
6002 if (!_dbus_decompose_path (parent_path, strlen (parent_path), &decomposed_path, NULL))
6003 return FALSE;
6004
6005 CONNECTION_LOCK (connection);
6006
6007 retval = _dbus_object_tree_list_registered_and_unlock (connection->objects,
6008 (const char **) decomposed_path,
6009 child_entries);
6010 dbus_free_string_array (decomposed_path);
6011
6012 return retval;
6013}
6014
6015static DBusDataSlotAllocator slot_allocator =
6016 _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (connection_slots));
6017
6032 dbus_bool_t
6033dbus_connection_allocate_data_slot (dbus_int32_t *slot_p)
6034{
6035 return _dbus_data_slot_allocator_alloc (&slot_allocator,
6036 slot_p);
6037}
6038
6050void
6051dbus_connection_free_data_slot (dbus_int32_t *slot_p)
6052{
6053 _dbus_return_if_fail (*slot_p >= 0);
6054
6055 _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
6056}
6057
6080 dbus_bool_t
6081dbus_connection_set_data (DBusConnection *connection,
6082 dbus_int32_t slot,
6083 void *data,
6084 DBusFreeFunction free_data_func)
6085{
6086 DBusFreeFunction old_free_func;
6087 void *old_data;
6088 dbus_bool_t retval;
6089
6090 _dbus_return_val_if_fail (connection != NULL, FALSE);
6091 _dbus_return_val_if_fail (slot >= 0, FALSE);
6092
6093 SLOTS_LOCK (connection);
6094
6095 retval = _dbus_data_slot_list_set (&slot_allocator,
6096 &connection->slot_list,
6097 slot, data, free_data_func,
6098 &old_free_func, &old_data);
6099
6100 SLOTS_UNLOCK (connection);
6101
6102 if (retval)
6103 {
6104 /* Do the actual free outside the connection lock */
6105 if (old_free_func)
6106 (* old_free_func) (old_data);
6107 }
6108
6109 return retval;
6110}
6111
6129void*
6130dbus_connection_get_data (DBusConnection *connection,
6131 dbus_int32_t slot)
6132{
6133 void *res;
6134
6135 _dbus_return_val_if_fail (connection != NULL, NULL);
6136 _dbus_return_val_if_fail (slot >= 0, NULL);
6137
6138 SLOTS_LOCK (connection);
6139
6140 res = _dbus_data_slot_list_get (&slot_allocator,
6141 &connection->slot_list,
6142 slot);
6143
6144 SLOTS_UNLOCK (connection);
6145
6146 return res;
6147}
6148
6155void
6156dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe)
6157{
6158 if (will_modify_sigpipe)
6159 _dbus_atomic_set_nonzero (&_dbus_modify_sigpipe);
6160 else
6161 _dbus_atomic_set_zero (&_dbus_modify_sigpipe);
6162}
6163
6172void
6173dbus_connection_set_max_message_size (DBusConnection *connection,
6174 long size)
6175{
6176 _dbus_return_if_fail (connection != NULL);
6177
6178 CONNECTION_LOCK (connection);
6179 _dbus_transport_set_max_message_size (connection->transport,
6180 size);
6181 CONNECTION_UNLOCK (connection);
6182}
6183
6190long
6191dbus_connection_get_max_message_size (DBusConnection *connection)
6192{
6193 long res;
6194
6195 _dbus_return_val_if_fail (connection != NULL, 0);
6196
6197 CONNECTION_LOCK (connection);
6198 res = _dbus_transport_get_max_message_size (connection->transport);
6199 CONNECTION_UNLOCK (connection);
6200 return res;
6201}
6202
6211void
6212dbus_connection_set_max_message_unix_fds (DBusConnection *connection,
6213 long n)
6214{
6215 _dbus_return_if_fail (connection != NULL);
6216
6217 CONNECTION_LOCK (connection);
6218 _dbus_transport_set_max_message_unix_fds (connection->transport,
6219 n);
6220 CONNECTION_UNLOCK (connection);
6221}
6222
6229long
6230dbus_connection_get_max_message_unix_fds (DBusConnection *connection)
6231{
6232 long res;
6233
6234 _dbus_return_val_if_fail (connection != NULL, 0);
6235
6236 CONNECTION_LOCK (connection);
6237 res = _dbus_transport_get_max_message_unix_fds (connection->transport);
6238 CONNECTION_UNLOCK (connection);
6239 return res;
6240}
6241
6267void
6268dbus_connection_set_max_received_size (DBusConnection *connection,
6269 long size)
6270{
6271 _dbus_return_if_fail (connection != NULL);
6272
6273 CONNECTION_LOCK (connection);
6274 _dbus_transport_set_max_received_size (connection->transport,
6275 size);
6276 CONNECTION_UNLOCK (connection);
6277}
6278
6285long
6286dbus_connection_get_max_received_size (DBusConnection *connection)
6287{
6288 long res;
6289
6290 _dbus_return_val_if_fail (connection != NULL, 0);
6291
6292 CONNECTION_LOCK (connection);
6293 res = _dbus_transport_get_max_received_size (connection->transport);
6294 CONNECTION_UNLOCK (connection);
6295 return res;
6296}
6297
6309void
6310dbus_connection_set_max_received_unix_fds (DBusConnection *connection,
6311 long n)
6312{
6313 _dbus_return_if_fail (connection != NULL);
6314
6315 CONNECTION_LOCK (connection);
6316 _dbus_transport_set_max_received_unix_fds (connection->transport,
6317 n);
6318 CONNECTION_UNLOCK (connection);
6319}
6320
6327long
6328dbus_connection_get_max_received_unix_fds (DBusConnection *connection)
6329{
6330 long res;
6331
6332 _dbus_return_val_if_fail (connection != NULL, 0);
6333
6334 CONNECTION_LOCK (connection);
6335 res = _dbus_transport_get_max_received_unix_fds (connection->transport);
6336 CONNECTION_UNLOCK (connection);
6337 return res;
6338}
6339
6350long
6351dbus_connection_get_outgoing_size (DBusConnection *connection)
6352{
6353 long res;
6354
6355 _dbus_return_val_if_fail (connection != NULL, 0);
6356
6357 CONNECTION_LOCK (connection);
6358 res = _dbus_counter_get_size_value (connection->outgoing_counter);
6359 CONNECTION_UNLOCK (connection);
6360 return res;
6361}
6362
6363#ifdef DBUS_ENABLE_STATS
6364void
6365_dbus_connection_get_stats (DBusConnection *connection,
6366 dbus_uint32_t *in_messages,
6367 dbus_uint32_t *in_bytes,
6368 dbus_uint32_t *in_fds,
6369 dbus_uint32_t *in_peak_bytes,
6370 dbus_uint32_t *in_peak_fds,
6371 dbus_uint32_t *out_messages,
6372 dbus_uint32_t *out_bytes,
6373 dbus_uint32_t *out_fds,
6374 dbus_uint32_t *out_peak_bytes,
6375 dbus_uint32_t *out_peak_fds)
6376{
6377 CONNECTION_LOCK (connection);
6378
6379 if (in_messages != NULL)
6380 *in_messages = connection->n_incoming;
6381
6382 _dbus_transport_get_stats (connection->transport,
6383 in_bytes, in_fds, in_peak_bytes, in_peak_fds);
6384
6385 if (out_messages != NULL)
6386 *out_messages = connection->n_outgoing;
6387
6388 if (out_bytes != NULL)
6389 *out_bytes = _dbus_counter_get_size_value (connection->outgoing_counter);
6390
6391 if (out_fds != NULL)
6392 *out_fds = _dbus_counter_get_unix_fd_value (connection->outgoing_counter);
6393
6394 if (out_peak_bytes != NULL)
6395 *out_peak_bytes = _dbus_counter_get_peak_size_value (connection->outgoing_counter);
6396
6397 if (out_peak_fds != NULL)
6398 *out_peak_fds = _dbus_counter_get_peak_unix_fd_value (connection->outgoing_counter);
6399
6400 CONNECTION_UNLOCK (connection);
6401}
6402#endif /* DBUS_ENABLE_STATS */
6403
6411long
6412dbus_connection_get_outgoing_unix_fds (DBusConnection *connection)
6413{
6414 long res;
6415
6416 _dbus_return_val_if_fail (connection != NULL, 0);
6417
6418 CONNECTION_LOCK (connection);
6419 res = _dbus_counter_get_unix_fd_value (connection->outgoing_counter);
6420 CONNECTION_UNLOCK (connection);
6421 return res;
6422}
6423
6424#ifdef DBUS_ENABLE_EMBEDDED_TESTS
6431const char*
6432_dbus_connection_get_address (DBusConnection *connection)
6433{
6434 return _dbus_transport_get_address (connection->transport);
6435}
6436#endif
6437
dbus_address_entries_free
void dbus_address_entries_free(DBusAddressEntry **entries)
Frees a NULL-terminated array of address entries.
Definition: dbus-address.c:192
dbus_parse_address
dbus_bool_t dbus_parse_address(const char *address, DBusAddressEntry ***entry_result, int *array_len, DBusError *error)
Parses an address string of the form:
Definition: dbus-address.c:366
dbus_address_entry_get_value
const char * dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
Returns a value from a key of an entry.
Definition: dbus-address.c:247
_dbus_bus_notify_shared_connection_disconnected_unlocked
void _dbus_bus_notify_shared_connection_disconnected_unlocked(DBusConnection *connection)
Internal function that checks to see if this is a shared connection owned by the bus and if it is unr...
Definition: dbus-bus.c:388
_dbus_connection_handle_watch
dbus_bool_t _dbus_connection_handle_watch(DBusWatch *watch, unsigned int condition, void *data)
A callback for use with dbus_watch_new() to create a DBusWatch.
Definition: dbus-connection.c:1489
_dbus_connection_toggle_timeout_unlocked
void _dbus_connection_toggle_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout, dbus_bool_t enabled)
Toggles a timeout and notifies app via connection's DBusTimeoutToggledFunction if available.
Definition: dbus-connection.c:907
dbus_connection_has_messages_to_send
dbus_bool_t dbus_connection_has_messages_to_send(DBusConnection *connection)
Checks whether there are messages in the outgoing message queue.
Definition: dbus-connection.c:590
_dbus_connection_do_iteration_unlocked
void _dbus_connection_do_iteration_unlocked(DBusConnection *connection, DBusPendingCall *pending, unsigned int flags, int timeout_milliseconds)
Queues incoming messages and sends outgoing messages for this connection, optionally blocking in the ...
Definition: dbus-connection.c:1200
_dbus_connection_send_and_unlock
dbus_bool_t _dbus_connection_send_and_unlock(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *client_serial)
Like dbus_connection_send(), but assumes the connection is already locked on function entry,...
Definition: dbus-connection.c:2101
_dbus_connection_new_for_transport
DBusConnection * _dbus_connection_new_for_transport(DBusTransport *transport)
Creates a new connection for the given transport.
Definition: dbus-connection.c:1251
_dbus_connection_has_messages_to_send_unlocked
dbus_bool_t _dbus_connection_has_messages_to_send_unlocked(DBusConnection *connection)
Checks whether there are messages in the outgoing message queue.
Definition: dbus-connection.c:574
DBusWatchRemoveFunction
void(* DBusWatchRemoveFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-connection.c:675
_dbus_connection_unlock
void _dbus_connection_unlock(DBusConnection *connection)
Releases the connection lock.
Definition: dbus-connection.c:401
_dbus_connection_lock
void _dbus_connection_lock(DBusConnection *connection)
Acquires the connection lock.
Definition: dbus-connection.c:390
_dbus_connection_remove_watch_unlocked
void _dbus_connection_remove_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Removes a watch using the connection's DBusRemoveWatchFunction if available.
Definition: dbus-connection.c:763
_dbus_connection_add_timeout_unlocked
dbus_bool_t _dbus_connection_add_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout)
Adds a timeout using the connection's DBusAddTimeoutFunction if available.
Definition: dbus-connection.c:869
_dbus_connection_toggle_watch_unlocked
void _dbus_connection_toggle_watch_unlocked(DBusConnection *connection, DBusWatch *watch, dbus_bool_t enabled)
Toggles a watch and notifies app via connection's DBusWatchToggledFunction if available.
Definition: dbus-connection.c:783
DBusTimeoutToggleFunction
void(* DBusTimeoutToggleFunction)(DBusTimeoutList *list, DBusTimeout *timeout, dbus_bool_t enabled)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-connection.c:802
DBusTimeoutRemoveFunction
void(* DBusTimeoutRemoveFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-connection.c:799
_dbus_connection_add_watch_unlocked
dbus_bool_t _dbus_connection_add_watch_unlocked(DBusConnection *connection, DBusWatch *watch)
Adds a watch using the connection's DBusAddWatchFunction if available.
Definition: dbus-connection.c:745
_dbus_connection_remove_pending_call
void _dbus_connection_remove_pending_call(DBusConnection *connection, DBusPendingCall *pending)
Removes a pending call from the connection, such that the pending reply will be ignored.
Definition: dbus-connection.c:1046
_dbus_connection_close_if_only_one_ref
void _dbus_connection_close_if_only_one_ref(DBusConnection *connection)
Used internally to handle the semantics of dbus_server_set_new_connection_function().
Definition: dbus-connection.c:2149
_dbus_connection_unref_unlocked
void _dbus_connection_unref_unlocked(DBusConnection *connection)
Decrements the reference count of a DBusConnection.
Definition: dbus-connection.c:1445
_dbus_connection_get_message_to_send
DBusMessage * _dbus_connection_get_message_to_send(DBusConnection *connection)
Gets the next outgoing message.
Definition: dbus-connection.c:611
DBusTimeoutAddFunction
dbus_bool_t(* DBusTimeoutAddFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-connection.c:796
_dbus_connection_message_sent_unlocked
void _dbus_connection_message_sent_unlocked(DBusConnection *connection, DBusMessage *message)
Notifies the connection that a message has been sent, so the message can be removed from the outgoing...
Definition: dbus-connection.c:627
_dbus_connection_remove_timeout_unlocked
void _dbus_connection_remove_timeout_unlocked(DBusConnection *connection, DBusTimeout *timeout)
Removes a timeout using the connection's DBusRemoveTimeoutFunction if available.
Definition: dbus-connection.c:887
DBusWatchToggleFunction
void(* DBusWatchToggleFunction)(DBusWatchList *list, DBusWatch *watch, dbus_bool_t enabled)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-connection.c:678
_dbus_connection_queue_received_message_link
void _dbus_connection_queue_received_message_link(DBusConnection *connection, DBusList *link)
Adds a message-containing list link to the incoming message queue, taking ownership of the link and t...
Definition: dbus-connection.c:482
_dbus_connection_get_pending_fds_count
int _dbus_connection_get_pending_fds_count(DBusConnection *connection)
Return how many file descriptors are pending in the loader.
Definition: dbus-connection.c:2564
_dbus_connection_set_pending_fds_function
void _dbus_connection_set_pending_fds_function(DBusConnection *connection, DBusPendingFdsChangeFunction callback, void *data)
Register a function to be called whenever the number of pending file descriptors in the loader change...
Definition: dbus-connection.c:2577
DBusWatchAddFunction
dbus_bool_t(* DBusWatchAddFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-connection.c:672
_dbus_connection_block_pending_call
void _dbus_connection_block_pending_call(DBusPendingCall *pending)
Blocks until a pending call times out or gets a reply.
Definition: dbus-connection.c:2383
_dbus_connection_queue_synthesized_message_link
void _dbus_connection_queue_synthesized_message_link(DBusConnection *connection, DBusList *link)
Adds a link + message to the incoming message queue.
Definition: dbus-connection.c:547
_dbus_connection_close_possibly_shared
void _dbus_connection_close_possibly_shared(DBusConnection *connection)
Closes a shared OR private connection, while dbus_connection_close() can only be used on private conn...
Definition: dbus-connection.c:1951
_dbus_connection_ref_unlocked
DBusConnection * _dbus_connection_ref_unlocked(DBusConnection *connection)
Increments the reference count of a DBusConnection.
Definition: dbus-connection.c:1422
dbus_connection_return_message
void dbus_connection_return_message(DBusConnection *connection, DBusMessage *message)
Used to return a message after peeking at it using dbus_connection_borrow_message().
Definition: dbus-connection.c:3903
DBusWatchToggledFunction
void(* DBusWatchToggledFunction)(DBusWatch *watch, void *data)
Called when dbus_watch_get_enabled() may return a different value than it did before.
Definition: dbus-connection.h:98
dbus_connection_get_object_path_data
dbus_bool_t dbus_connection_get_object_path_data(DBusConnection *connection, const char *path, void **data_p)
Gets the user data passed to dbus_connection_register_object_path() or dbus_connection_register_fallb...
Definition: dbus-connection.c:5954
dbus_connection_set_max_message_size
void dbus_connection_set_max_message_size(DBusConnection *connection, long size)
Specifies the maximum size message this connection is allowed to receive.
Definition: dbus-connection.c:6173
dbus_connection_flush
void dbus_connection_flush(DBusConnection *connection)
Blocks until the outgoing message queue is empty.
Definition: dbus-connection.c:3643
dbus_connection_get_max_message_unix_fds
long dbus_connection_get_max_message_unix_fds(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_message_unix_fds().
Definition: dbus-connection.c:6230
dbus_connection_set_exit_on_disconnect
void dbus_connection_set_exit_on_disconnect(DBusConnection *connection, dbus_bool_t exit_on_disconnect)
Set whether _exit() should be called when the connection receives a disconnect signal.
Definition: dbus-connection.c:3147
dbus_connection_get_socket
dbus_bool_t dbus_connection_get_socket(DBusConnection *connection, int *fd)
Gets the underlying Windows or UNIX socket file descriptor of the connection, if any.
Definition: dbus-connection.c:5179
dbus_connection_pop_message
DBusMessage * dbus_connection_pop_message(DBusConnection *connection)
Returns the first-received message from the incoming message queue, removing it from the queue.
Definition: dbus-connection.c:4093
dbus_connection_get_max_received_unix_fds
long dbus_connection_get_max_received_unix_fds(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_received_unix_fds().
Definition: dbus-connection.c:6328
dbus_connection_register_object_path
dbus_bool_t dbus_connection_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
Registers a handler for a given path in the object hierarchy.
Definition: dbus-connection.c:5815
dbus_connection_close
void dbus_connection_close(DBusConnection *connection)
Closes a private connection, so no further data can be sent or received.
Definition: dbus-connection.c:2934
dbus_connection_set_max_message_unix_fds
void dbus_connection_set_max_message_unix_fds(DBusConnection *connection, long n)
Specifies the maximum number of unix fds a message on this connection is allowed to receive.
Definition: dbus-connection.c:6212
dbus_connection_set_wakeup_main_function
void dbus_connection_set_wakeup_main_function(DBusConnection *connection, DBusWakeupMainFunction wakeup_main_function, void *data, DBusFreeFunction free_data_function)
Sets the mainloop wakeup function for the connection.
Definition: dbus-connection.c:5058
dbus_connection_get_windows_user
dbus_bool_t dbus_connection_get_windows_user(DBusConnection *connection, char **windows_sid_p)
Gets the Windows user SID of the connection if known.
Definition: dbus-connection.c:5438
dbus_connection_get_is_authenticated
dbus_bool_t dbus_connection_get_is_authenticated(DBusConnection *connection)
Gets whether the connection was authenticated.
Definition: dbus-connection.c:2997
dbus_connection_send_preallocated
void dbus_connection_send_preallocated(DBusConnection *connection, DBusPreallocatedSend *preallocated, DBusMessage *message, dbus_uint32_t *client_serial)
Sends a message using preallocated resources.
Definition: dbus-connection.c:3219
dbus_connection_read_write
dbus_bool_t dbus_connection_read_write(DBusConnection *connection, int timeout_milliseconds)
This function is intended for use with applications that don't want to write a main loop and deal wit...
Definition: dbus-connection.c:3803
dbus_connection_get_max_received_size
long dbus_connection_get_max_received_size(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_received_size().
Definition: dbus-connection.c:6286
dbus_connection_get_unix_fd
dbus_bool_t dbus_connection_get_unix_fd(DBusConnection *connection, int *fd)
Get the UNIX file descriptor of the connection, if any.
Definition: dbus-connection.c:5149
DBusDispatchStatusFunction
void(* DBusDispatchStatusFunction)(DBusConnection *connection, DBusDispatchStatus new_status, void *data)
Called when the return value of dbus_connection_get_dispatch_status() may have changed.
Definition: dbus-connection.h:129
dbus_connection_can_send_type
dbus_bool_t dbus_connection_can_send_type(DBusConnection *connection, int type)
Tests whether a certain type can be send via the connection.
Definition: dbus-connection.c:3107
dbus_connection_list_registered
dbus_bool_t dbus_connection_list_registered(DBusConnection *connection, const char *parent_path, char ***child_entries)
Lists the registered fallback handlers and object path handlers at the given parent_path.
Definition: dbus-connection.c:5991
dbus_connection_get_data
void * dbus_connection_get_data(DBusConnection *connection, dbus_int32_t slot)
Retrieves data previously set with dbus_connection_set_data().
Definition: dbus-connection.c:6130
dbus_connection_open_private
DBusConnection * dbus_connection_open_private(const char *address, DBusError *error)
Opens a new, dedicated connection to a remote address.
Definition: dbus-connection.c:2665
dbus_connection_get_outgoing_size
long dbus_connection_get_outgoing_size(DBusConnection *connection)
Gets the approximate size in bytes of all messages in the outgoing message queue.
Definition: dbus-connection.c:6351
dbus_connection_set_dispatch_status_function
void dbus_connection_set_dispatch_status_function(DBusConnection *connection, DBusDispatchStatusFunction function, void *data, DBusFreeFunction free_data_function)
Set a function to be invoked when the dispatch status changes.
Definition: dbus-connection.c:5104
dbus_connection_read_write_dispatch
dbus_bool_t dbus_connection_read_write_dispatch(DBusConnection *connection, int timeout_milliseconds)
This function is intended for use with applications that don't want to write a main loop and deal wit...
Definition: dbus-connection.c:3771
DBusHandleMessageFunction
DBusHandlerResult(* DBusHandleMessageFunction)(DBusConnection *connection, DBusMessage *message, void *user_data)
Called when a message needs to be handled.
Definition: dbus-connection.h:170
dbus_connection_remove_filter
void dbus_connection_remove_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data)
Removes a previously-added message filter.
Definition: dbus-connection.c:5676
dbus_connection_get_is_connected
dbus_bool_t dbus_connection_get_is_connected(DBusConnection *connection)
Gets whether the connection is currently open.
Definition: dbus-connection.c:2975
dbus_connection_preallocate_send
DBusPreallocatedSend * dbus_connection_preallocate_send(DBusConnection *connection)
Preallocates resources needed to send a message, allowing the message to be sent without the possibil...
Definition: dbus-connection.c:3167
DBusAddWatchFunction
dbus_bool_t(* DBusAddWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus needs a new watch to be monitored by the main loop.
Definition: dbus-connection.h:92
dbus_connection_unref
void dbus_connection_unref(DBusConnection *connection)
Decrements the reference count of a DBusConnection, and finalizes it if the count reaches zero.
Definition: dbus-connection.c:2819
dbus_connection_set_max_received_size
void dbus_connection_set_max_received_size(DBusConnection *connection, long size)
Sets the maximum total number of bytes that can be used for all messages received on this connection.
Definition: dbus-connection.c:6268
DBusTimeoutToggledFunction
void(* DBusTimeoutToggledFunction)(DBusTimeout *timeout, void *data)
Called when dbus_timeout_get_enabled() may return a different value than it did before.
Definition: dbus-connection.h:118
dbus_connection_dispatch
DBusDispatchStatus dbus_connection_dispatch(DBusConnection *connection)
Processes any incoming data.
Definition: dbus-connection.c:4577
dbus_connection_unregister_object_path
dbus_bool_t dbus_connection_unregister_object_path(DBusConnection *connection, const char *path)
Unregisters the handler registered with exactly the given path.
Definition: dbus-connection.c:5922
dbus_connection_set_unix_user_function
void dbus_connection_set_unix_user_function(DBusConnection *connection, DBusAllowUnixUserFunction function, void *data, DBusFreeFunction free_data_function)
Sets a predicate function used to determine whether a given user ID is allowed to connect.
Definition: dbus-connection.c:5341
dbus_connection_try_register_object_path
dbus_bool_t dbus_connection_try_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a handler for a given path in the object hierarchy.
Definition: dbus-connection.c:5785
dbus_connection_steal_borrowed_message
void dbus_connection_steal_borrowed_message(DBusConnection *connection, DBusMessage *message)
Used to keep a message after peeking at it using dbus_connection_borrow_message().
Definition: dbus-connection.c:3937
dbus_connection_allocate_data_slot
dbus_bool_t dbus_connection_allocate_data_slot(dbus_int32_t *slot_p)
Allocates an integer ID to be used for storing application-specific data on any DBusConnection.
Definition: dbus-connection.c:6033
dbus_connection_set_change_sigpipe
void dbus_connection_set_change_sigpipe(dbus_bool_t will_modify_sigpipe)
This function sets a global flag for whether dbus_connection_new() will set SIGPIPE behavior to SIG_I...
Definition: dbus-connection.c:6156
dbus_connection_get_max_message_size
long dbus_connection_get_max_message_size(DBusConnection *connection)
Gets the value set by dbus_connection_set_max_message_size().
Definition: dbus-connection.c:6191
dbus_connection_free_data_slot
void dbus_connection_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for connection data slots.
Definition: dbus-connection.c:6051
DBusAddTimeoutFunction
dbus_bool_t(* DBusAddTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus needs a new timeout to be monitored by the main loop.
Definition: dbus-connection.h:111
dbus_connection_set_max_received_unix_fds
void dbus_connection_set_max_received_unix_fds(DBusConnection *connection, long n)
Sets the maximum total number of unix fds that can be used for all messages received on this connecti...
Definition: dbus-connection.c:6310
dbus_connection_set_data
dbus_bool_t dbus_connection_set_data(DBusConnection *connection, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
Stores a pointer on a DBusConnection, along with an optional function to be used for freeing the data...
Definition: dbus-connection.c:6081
dbus_connection_get_dispatch_status
DBusDispatchStatus dbus_connection_get_dispatch_status(DBusConnection *connection)
Gets the current state of the incoming message queue.
Definition: dbus-connection.c:4380
dbus_connection_send_with_reply_and_block
DBusMessage * dbus_connection_send_with_reply_and_block(DBusConnection *connection, DBusMessage *message, int timeout_milliseconds, DBusError *error)
Sends a message and blocks a certain time period while waiting for a reply.
Definition: dbus-connection.c:3537
dbus_connection_try_register_fallback
dbus_bool_t dbus_connection_try_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a fallback handler for a given subsection of the object hierarchy.
Definition: dbus-connection.c:5855
dbus_connection_get_adt_audit_session_data
dbus_bool_t dbus_connection_get_adt_audit_session_data(DBusConnection *connection, void **data, dbus_int32_t *data_size)
Gets the ADT audit data of the connection if any.
Definition: dbus-connection.c:5295
dbus_connection_borrow_message
DBusMessage * dbus_connection_borrow_message(DBusConnection *connection)
Returns the first-received message from the incoming message queue, leaving it in the queue.
Definition: dbus-connection.c:3852
dbus_connection_send_with_reply
dbus_bool_t dbus_connection_send_with_reply(DBusConnection *connection, DBusMessage *message, DBusPendingCall **pending_return, int timeout_milliseconds)
Queues a message to send, as with dbus_connection_send(), but also returns a DBusPendingCall used to ...
Definition: dbus-connection.c:3401
dbus_connection_set_windows_user_function
void dbus_connection_set_windows_user_function(DBusConnection *connection, DBusAllowWindowsUserFunction function, void *data, DBusFreeFunction free_data_function)
Sets a predicate function used to determine whether a given user ID is allowed to connect.
Definition: dbus-connection.c:5485
dbus_connection_get_is_anonymous
dbus_bool_t dbus_connection_get_is_anonymous(DBusConnection *connection)
Gets whether the connection is not authenticated as a specific user.
Definition: dbus-connection.c:3031
dbus_connection_set_timeout_functions
dbus_bool_t dbus_connection_set_timeout_functions(DBusConnection *connection, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the timeout functions for the connection.
Definition: dbus-connection.c:5020
DBusRemoveWatchFunction
void(* DBusRemoveWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus no longer needs a watch to be monitored by the main loop.
Definition: dbus-connection.h:104
DBusAllowUnixUserFunction
dbus_bool_t(* DBusAllowUnixUserFunction)(DBusConnection *connection, unsigned long uid, void *data)
Called during authentication to check whether the given UNIX user ID is allowed to connect,...
Definition: dbus-connection.h:144
DBusDispatchStatus
DBusDispatchStatus
Indicates the status of incoming data on a DBusConnection.
Definition: dbus-connection.h:81
dbus_connection_register_fallback
dbus_bool_t dbus_connection_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
Registers a fallback handler for a given subsection of the object hierarchy.
Definition: dbus-connection.c:5887
dbus_connection_open
DBusConnection * dbus_connection_open(const char *address, DBusError *error)
Gets a connection to a remote address.
Definition: dbus-connection.c:2622
dbus_connection_free_preallocated_send
void dbus_connection_free_preallocated_send(DBusConnection *connection, DBusPreallocatedSend *preallocated)
Frees preallocated message-sending resources from dbus_connection_preallocate_send().
Definition: dbus-connection.c:3193
dbus_connection_get_outgoing_unix_fds
long dbus_connection_get_outgoing_unix_fds(DBusConnection *connection)
Gets the approximate number of uni fds of all messages in the outgoing message queue.
Definition: dbus-connection.c:6412
DBusWakeupMainFunction
void(* DBusWakeupMainFunction)(void *data)
Called when the main loop's thread should be notified that there's now work to do.
Definition: dbus-connection.h:136
dbus_connection_set_allow_anonymous
void dbus_connection_set_allow_anonymous(DBusConnection *connection, dbus_bool_t value)
This function must be called on the server side of a connection when the connection is first seen in ...
Definition: dbus-connection.c:5532
dbus_connection_add_filter
dbus_bool_t dbus_connection_add_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data, DBusFreeFunction free_data_function)
Adds a message filter.
Definition: dbus-connection.c:5624
dbus_connection_send
dbus_bool_t dbus_connection_send(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *serial)
Adds a message to the outgoing message queue.
Definition: dbus-connection.c:3304
dbus_connection_ref
DBusConnection * dbus_connection_ref(DBusConnection *connection)
Increments the reference count of a DBusConnection.
Definition: dbus-connection.c:2687
dbus_connection_get_server_id
char * dbus_connection_get_server_id(DBusConnection *connection)
Gets the ID of the server address we are authenticated to, if this connection is on the client side.
Definition: dbus-connection.c:3076
DBusAllowWindowsUserFunction
dbus_bool_t(* DBusAllowWindowsUserFunction)(DBusConnection *connection, const char *user_sid, void *data)
Called during authentication to check whether the given Windows user ID is allowed to connect,...
Definition: dbus-connection.h:154
dbus_connection_set_watch_functions
dbus_bool_t dbus_connection_set_watch_functions(DBusConnection *connection, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the watch functions for the connection.
Definition: dbus-connection.c:4957
DBusRemoveTimeoutFunction
void(* DBusRemoveTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus no longer needs a timeout to be monitored by the main loop.
Definition: dbus-connection.h:124
dbus_connection_get_unix_process_id
dbus_bool_t dbus_connection_get_unix_process_id(DBusConnection *connection, unsigned long *pid)
Gets the process ID of the connection if any.
Definition: dbus-connection.c:5262
dbus_connection_get_unix_user
dbus_bool_t dbus_connection_get_unix_user(DBusConnection *connection, unsigned long *uid)
Gets the UNIX user ID of the connection if known.
Definition: dbus-connection.c:5226
_dbus_connection_set_builtin_filters_enabled
void _dbus_connection_set_builtin_filters_enabled(DBusConnection *connection, dbus_bool_t value)
Enables the builtin filtering of messages.
Definition: dbus-connection.c:5564
dbus_connection_set_route_peer_messages
void dbus_connection_set_route_peer_messages(DBusConnection *connection, dbus_bool_t value)
Normally DBusConnection automatically handles all messages to the org.freedesktop....
Definition: dbus-connection.c:5592
DBUS_DISPATCH_NEED_MEMORY
@ DBUS_DISPATCH_NEED_MEMORY
More memory is needed to continue.
Definition: dbus-connection.h:84
DBUS_DISPATCH_COMPLETE
@ DBUS_DISPATCH_COMPLETE
All currently available data has been processed.
Definition: dbus-connection.h:83
DBUS_DISPATCH_DATA_REMAINS
@ DBUS_DISPATCH_DATA_REMAINS
There is more data to potentially convert to messages.
Definition: dbus-connection.h:82
_dbus_data_slot_allocator_free
void _dbus_data_slot_allocator_free(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Deallocates an ID previously allocated with _dbus_data_slot_allocator_alloc().
Definition: dbus-dataslot.c:155
_dbus_data_slot_list_init
void _dbus_data_slot_list_init(DBusDataSlotList *list)
Initializes a slot list.
Definition: dbus-dataslot.c:198
_dbus_data_slot_list_free
void _dbus_data_slot_list_free(DBusDataSlotList *list)
Frees the data slot list and all data slots contained in it, calling application-provided free functi...
Definition: dbus-dataslot.c:341
_dbus_data_slot_list_get
void * _dbus_data_slot_list_get(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot)
Retrieves data previously set with _dbus_data_slot_list_set_data().
Definition: dbus-dataslot.c:286
_dbus_data_slot_list_set
dbus_bool_t _dbus_data_slot_list_set(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot, void *data, DBusFreeFunction free_data_func, DBusFreeFunction *old_free_func, void **old_data)
Stores a pointer in the data slot list, along with an optional function to be used for freeing the da...
Definition: dbus-dataslot.c:222
_dbus_data_slot_allocator_alloc
dbus_bool_t _dbus_data_slot_allocator_alloc(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Allocates an integer ID to be used for storing data in a DBusDataSlotList.
Definition: dbus-dataslot.c:70
DBUS_ERROR_INIT
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
dbus_move_error
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
Definition: dbus-errors.c:279
dbus_error_has_name
dbus_bool_t dbus_error_has_name(const DBusError *error, const char *name)
Checks whether the error is set and has the given name.
Definition: dbus-errors.c:302
dbus_set_error
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
Definition: dbus-errors.c:354
dbus_error_free
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
_dbus_hash_table_get_n_entries
int _dbus_hash_table_get_n_entries(DBusHashTable *table)
Gets the number of hash entries in a hash table.
Definition: dbus-hash.c:1460
_dbus_hash_iter_get_value
void * _dbus_hash_iter_get_value(DBusHashIter *iter)
Gets the value of the current entry.
Definition: dbus-hash.c:619
_dbus_hash_table_insert_int
dbus_bool_t _dbus_hash_table_insert_int(DBusHashTable *table, int key, void *value)
Creates a hash entry with the given key and value.
Definition: dbus-hash.c:1311
_dbus_hash_table_insert_string
dbus_bool_t _dbus_hash_table_insert_string(DBusHashTable *table, char *key, void *value)
Creates a hash entry with the given key and value.
Definition: dbus-hash.c:1277
_dbus_hash_table_unref
void _dbus_hash_table_unref(DBusHashTable *table)
Decrements the reference count for a hash table, freeing the hash table if the count reaches zero.
Definition: dbus-hash.c:367
_dbus_hash_iter_next
dbus_bool_t _dbus_hash_iter_next(DBusHashIter *iter)
Move the hash iterator forward one step, to the next hash entry.
Definition: dbus-hash.c:549
_dbus_hash_iter_init
void _dbus_hash_iter_init(DBusHashTable *table, DBusHashIter *iter)
Initializes a hash table iterator.
Definition: dbus-hash.c:523
_dbus_hash_table_new
DBusHashTable * _dbus_hash_table_new(DBusHashType type, DBusFreeFunction key_free_function, DBusFreeFunction value_free_function)
Constructs a new hash table.
Definition: dbus-hash.c:291
_dbus_hash_table_remove_int
dbus_bool_t _dbus_hash_table_remove_int(DBusHashTable *table, int key)
Removes the hash entry for the given key.
Definition: dbus-hash.c:1214
_dbus_hash_table_remove_string
dbus_bool_t _dbus_hash_table_remove_string(DBusHashTable *table, const char *key)
Removes the hash entry for the given key.
Definition: dbus-hash.c:1186
_dbus_hash_table_lookup_string
void * _dbus_hash_table_lookup_string(DBusHashTable *table, const char *key)
Looks up the value for a given string in a hash table of type DBUS_HASH_STRING.
Definition: dbus-hash.c:1112
_dbus_hash_iter_remove_entry
void _dbus_hash_iter_remove_entry(DBusHashIter *iter)
Removes the current entry from the hash table.
Definition: dbus-hash.c:598
_dbus_hash_table_lookup_int
void * _dbus_hash_table_lookup_int(DBusHashTable *table, int key)
Looks up the value for a given integer in a hash table of type DBUS_HASH_INT.
Definition: dbus-hash.c:1137
DBUS_HASH_INT
@ DBUS_HASH_INT
Hash keys are integers.
Definition: dbus-hash.h:70
DBUS_HASH_STRING
@ DBUS_HASH_STRING
Hash keys are strings.
Definition: dbus-hash.h:69
_dbus_assert_not_reached
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
Definition: dbus-internals.h:164
_dbus_assert
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
Definition: dbus-internals.h:153
_DBUS_UNLOCK
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
Definition: dbus-internals.h:422
_DBUS_LOCK
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
Definition: dbus-internals.h:421
_dbus_warn_check_failed
void _dbus_warn_check_failed(const char *format,...)
Prints a "critical" warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
Definition: dbus-internals.c:270
_dbus_strdup
char * _dbus_strdup(const char *str)
Duplicates a string.
Definition: dbus-internals.c:589
_dbus_get_local_machine_uuid_encoded
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on.
Definition: dbus-internals.c:951
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition: dbus-internals.c:238
_DBUS_LOCK_NAME
#define _DBUS_LOCK_NAME(name)
Expands to name of a global lock variable.
Definition: dbus-internals.h:420
_dbus_list_get_first_link
DBusList * _dbus_list_get_first_link(DBusList **list)
Gets the first link in the list.
Definition: dbus-list.c:595
_dbus_list_copy
dbus_bool_t _dbus_list_copy(DBusList **list, DBusList **dest)
Copies a list.
Definition: dbus-list.c:725
_dbus_list_pop_first_link
DBusList * _dbus_list_pop_first_link(DBusList **list)
Removes the first link in the list and returns it.
Definition: dbus-list.c:656
_dbus_list_get_last
void * _dbus_list_get_last(DBusList **list)
Gets the last data in the list.
Definition: dbus-list.c:624
_dbus_list_remove
dbus_bool_t _dbus_list_remove(DBusList **list, void *data)
Removes a value from the list.
Definition: dbus-list.c:416
_dbus_list_append_link
void _dbus_list_append_link(DBusList **list, DBusList *link)
Appends a link to the list.
Definition: dbus-list.c:316
_dbus_list_clear_full
void _dbus_list_clear_full(DBusList **list, DBusFreeFunction function)
Free every link and every element in the list.
Definition: dbus-list.c:568
_dbus_list_remove_link
void _dbus_list_remove_link(DBusList **list, DBusList *link)
Removes a link from the list.
Definition: dbus-list.c:528
_dbus_list_get_first
void * _dbus_list_get_first(DBusList **list)
Gets the first data in the list.
Definition: dbus-list.c:640
_dbus_list_get_last_link
DBusList * _dbus_list_get_last_link(DBusList **list)
Gets the last link in the list.
Definition: dbus-list.c:608
_dbus_list_unlink
void _dbus_list_unlink(DBusList **list, DBusList *link)
Removes the given link from the list, but doesn't free it.
Definition: dbus-list.c:500
_dbus_list_get_prev_link
#define _dbus_list_get_prev_link(list, link)
Gets the previous link in the list, or NULL if there are no more links.
Definition: dbus-list.h:120
_dbus_list_free_link
void _dbus_list_free_link(DBusList *link)
Frees a linked list node allocated with _dbus_list_alloc_link.
Definition: dbus-list.c:255
_dbus_list_pop_first
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it.
Definition: dbus-list.c:677
_dbus_list_foreach
void _dbus_list_foreach(DBusList **list, DBusForeachFunction function, void *data)
Calls the given function for each element in the list.
Definition: dbus-list.c:787
_dbus_list_clear
void _dbus_list_clear(DBusList **list)
Frees all links in the list and sets the list head to NULL.
Definition: dbus-list.c:543
_dbus_list_prepend_link
void _dbus_list_prepend_link(DBusList **list, DBusList *link)
Prepends a link to the list.
Definition: dbus-list.c:334
_dbus_list_prepend
dbus_bool_t _dbus_list_prepend(DBusList **list, void *data)
Prepends a value to the list.
Definition: dbus-list.c:293
_dbus_list_alloc_link
DBusList * _dbus_list_alloc_link(void *data)
Allocates a linked list node.
Definition: dbus-list.c:243
_dbus_list_append
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
Definition: dbus-list.c:271
_dbus_list_get_next_link
#define _dbus_list_get_next_link(list, link)
Gets the next link in the list, or NULL if there are no more links.
Definition: dbus-list.h:119
NULL
#define NULL
A null pointer, defined appropriately for C or C++.
TRUE
#define TRUE
Expands to "1".
FALSE
#define FALSE
Expands to "0".
_dbus_current_generation
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called,...
Definition: dbus-memory.c:772
_dbus_register_shutdown_func
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_register_shutdown_func(DBusShutdownFunction function, void *data)
Register a cleanup function to be called exactly once the next time dbus_shutdown() is called.
Definition: dbus-memory.c:801
DBusFreeFunction
void(* DBusFreeFunction)(void *memory)
The type of a function which frees a block of memory.
Definition: dbus-memory.h:63
dbus_free
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:692
dbus_new
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
Definition: dbus-memory.h:57
dbus_new0
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:58
dbus_free_string_array
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:740
dbus_message_set_serial
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.
Definition: dbus-message.c:289
dbus_message_lock
void dbus_message_lock(DBusMessage *message)
Locks a message.
Definition: dbus-message.c:419
dbus_message_type_to_string
const char * dbus_message_type_to_string(int type)
Utility function to convert a D-Bus message type into a machine-readable string (not translated).
Definition: dbus-message.c:5059
_dbus_message_remove_counter
void _dbus_message_remove_counter(DBusMessage *message, DBusCounter *counter)
Removes a counter tracking the size/unix fds of this message, and decrements the counter by the size/...
Definition: dbus-message.c:387
_dbus_message_add_counter_link
void _dbus_message_add_counter_link(DBusMessage *message, DBusList *link)
Adds a counter to be incremented immediately with the size/unix fds of this message,...
Definition: dbus-message.c:315
dbus_message_has_interface
dbus_bool_t dbus_message_has_interface(DBusMessage *message, const char *iface)
Checks if the message has an interface.
Definition: dbus-message.c:3490
dbus_message_set_no_reply
void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
Sets a flag indicating that the message does not want a reply; if this flag is set,...
Definition: dbus-message.c:3225
dbus_message_iter_append_basic
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
Definition: dbus-message.c:2749
dbus_message_get_path
const char * dbus_message_get_path(DBusMessage *message)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
Definition: dbus-message.c:3337
dbus_message_get_interface
const char * dbus_message_get_interface(DBusMessage *message)
Gets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted...
Definition: dbus-message.c:3468
dbus_message_new_error
DBusMessage * dbus_message_new_error(DBusMessage *reply_to, const char *error_name, const char *error_message)
Creates a new message that is an error reply to another message.
Definition: dbus-message.c:1503
dbus_message_get_serial
dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
Returns the serial of a message or 0 if none has been specified.
Definition: dbus-message.c:1156
dbus_message_get_type
int dbus_message_get_type(DBusMessage *message)
Gets the type of a message.
Definition: dbus-message.c:1755
dbus_message_append_args
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
Definition: dbus-message.c:1831
dbus_message_new_signal
DBusMessage * dbus_message_new_signal(const char *path, const char *iface, const char *name)
Constructs a new message representing a signal emission.
Definition: dbus-message.c:1457
dbus_message_ref
DBusMessage * dbus_message_ref(DBusMessage *message)
Increments the reference count of a DBusMessage.
Definition: dbus-message.c:1700
dbus_message_set_error_name
dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *error_name)
Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR).
Definition: dbus-message.c:3612
dbus_message_get_reply_serial
dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
Returns the serial that the message is a reply to or 0 if none.
Definition: dbus-message.c:1196
dbus_message_new_method_return
DBusMessage * dbus_message_new_method_return(DBusMessage *method_call)
Constructs a message that is a reply to a method call.
Definition: dbus-message.c:1406
dbus_message_get_destination
const char * dbus_message_get_destination(DBusMessage *message)
Gets the destination of a message or NULL if there is none set.
Definition: dbus-message.c:3691
dbus_message_unref
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0.
Definition: dbus-message.c:1723
dbus_message_new
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type.
Definition: dbus-message.c:1322
dbus_set_error_from_message
dbus_bool_t dbus_set_error_from_message(DBusError *error, DBusMessage *message)
Sets a DBusError based on the contents of the given message.
Definition: dbus-message.c:4037
dbus_message_is_method_call
dbus_bool_t dbus_message_is_method_call(DBusMessage *message, const char *iface, const char *method)
Checks whether the message is a method call with the given interface and member fields.
Definition: dbus-message.c:3843
dbus_message_set_reply_serial
dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
Sets the reply serial of a message (the serial of the message this is a reply to).
Definition: dbus-message.c:1172
dbus_message_is_signal
dbus_bool_t dbus_message_is_signal(DBusMessage *message, const char *iface, const char *signal_name)
Checks whether the message is a signal with the given interface and member fields.
Definition: dbus-message.c:3871
dbus_message_get_signature
const char * dbus_message_get_signature(DBusMessage *message)
Gets the type signature of the message, i.e.
Definition: dbus-message.c:3784
dbus_message_get_member
const char * dbus_message_get_member(DBusMessage *message)
Gets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
Definition: dbus-message.c:3554
dbus_message_iter_init_append
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
Definition: dbus-message.c:2511
_dbus_object_tree_free_all_unlocked
void _dbus_object_tree_free_all_unlocked(DBusObjectTree *tree)
Free all the handlers in the tree.
Definition: dbus-object-tree.c:721
_dbus_object_tree_unregister_and_unlock
void _dbus_object_tree_unregister_and_unlock(DBusObjectTree *tree, const char **path)
Unregisters an object subtree that was registered with the same path.
Definition: dbus-object-tree.c:626
_dbus_object_tree_unref
void _dbus_object_tree_unref(DBusObjectTree *tree)
Decrement the reference count.
Definition: dbus-object-tree.c:144
_dbus_object_tree_list_registered_and_unlock
dbus_bool_t _dbus_object_tree_list_registered_and_unlock(DBusObjectTree *tree, const char **parent_path, char ***child_entries)
Lists the registered fallback handlers and object path handlers at the given parent_path.
Definition: dbus-object-tree.c:1209
_dbus_decompose_path
dbus_bool_t _dbus_decompose_path(const char *data, int len, char ***path, int *path_len)
Decompose an object path.
Definition: dbus-object-tree.c:1245
_dbus_object_tree_register
dbus_bool_t _dbus_object_tree_register(DBusObjectTree *tree, dbus_bool_t fallback, const char **path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
Registers a new subtree in the global object tree.
Definition: dbus-object-tree.c:394
_dbus_object_tree_get_user_data_unlocked
void * _dbus_object_tree_get_user_data_unlocked(DBusObjectTree *tree, const char **path)
Looks up the data passed to _dbus_object_tree_register() for a handler at the given path.
Definition: dbus-object-tree.c:1078
_dbus_object_tree_dispatch_and_unlock
DBusHandlerResult _dbus_object_tree_dispatch_and_unlock(DBusObjectTree *tree, DBusMessage *message, dbus_bool_t *found_object)
Tries to dispatch a message by directing it to handler for the object path listed in the message head...
Definition: dbus-object-tree.c:906
_dbus_object_tree_new
DBusObjectTree * _dbus_object_tree_new(DBusConnection *connection)
Creates a new object tree, representing a mapping from paths to handler vtables.
Definition: dbus-object-tree.c:93
_dbus_pending_call_finish_completion
void _dbus_pending_call_finish_completion(DBusPendingCall *pending)
Call the notifier function for the pending call.
Definition: dbus-pending-call.c:233
_dbus_pending_call_get_connection_and_lock
DBusConnection * _dbus_pending_call_get_connection_and_lock(DBusPendingCall *pending)
Gets the connection associated with this pending call.
Definition: dbus-pending-call.c:350
_dbus_pending_call_ref_unlocked
DBUS_PRIVATE_EXPORT DBusPendingCall * _dbus_pending_call_ref_unlocked(DBusPendingCall *pending)
Increments the reference count on a pending call, while the lock on its connection is already held.
Definition: dbus-pending-call.c:421
_dbus_pending_call_queue_timeout_error_unlocked
void _dbus_pending_call_queue_timeout_error_unlocked(DBusPendingCall *pending, DBusConnection *connection)
If the pending call hasn't been timed out, add its timeout error reply to the connection's incoming m...
Definition: dbus-pending-call.c:255
_dbus_pending_call_unref_and_unlock
DBUS_PRIVATE_EXPORT void _dbus_pending_call_unref_and_unlock(DBusPendingCall *pending)
Decrements the reference count on a pending call, freeing it if the count reaches 0.
Definition: dbus-pending-call.c:484
_dbus_pending_call_get_completed_unlocked
dbus_bool_t _dbus_pending_call_get_completed_unlocked(DBusPendingCall *pending)
Checks whether the pending call has received a reply yet, or not.
Definition: dbus-pending-call.c:507
_dbus_pending_call_set_reply_unlocked
void _dbus_pending_call_set_reply_unlocked(DBusPendingCall *pending, DBusMessage *message)
Sets the reply of a pending call with the given message, or if the message is NULL,...
Definition: dbus-pending-call.c:181
_dbus_pending_call_new_unlocked
DBUS_PRIVATE_EXPORT DBusPendingCall * _dbus_pending_call_new_unlocked(DBusConnection *connection, int timeout_milliseconds, DBusTimeoutHandler timeout_handler)
Creates a new pending reply object.
Definition: dbus-pending-call.c:118
_dbus_pending_call_set_timeout_error_unlocked
dbus_bool_t _dbus_pending_call_set_timeout_error_unlocked(DBusPendingCall *pending, DBusMessage *message, dbus_uint32_t serial)
Sets the reply message associated with the pending call to a timeout error.
Definition: dbus-pending-call.c:381
_dbus_pending_call_start_completion_unlocked
void _dbus_pending_call_start_completion_unlocked(DBusPendingCall *pending)
Sets the pending call to completed.
Definition: dbus-pending-call.c:216
_dbus_pending_call_is_timeout_added_unlocked
dbus_bool_t _dbus_pending_call_is_timeout_added_unlocked(DBusPendingCall *pending)
Checks to see if a timeout has been added.
Definition: dbus-pending-call.c:275
_dbus_pending_call_get_reply_serial_unlocked
dbus_uint32_t _dbus_pending_call_get_reply_serial_unlocked(DBusPendingCall *pending)
Gets the reply's serial number.
Definition: dbus-pending-call.c:320
_dbus_pending_call_get_connection_unlocked
DBusConnection * _dbus_pending_call_get_connection_unlocked(DBusPendingCall *pending)
Gets the connection associated with this pending call.
Definition: dbus-pending-call.c:365
_dbus_pending_call_get_timeout_unlocked
DBusTimeout * _dbus_pending_call_get_timeout_unlocked(DBusPendingCall *pending)
Retrives the timeout.
Definition: dbus-pending-call.c:306
_dbus_pending_call_set_timeout_added_unlocked
void _dbus_pending_call_set_timeout_added_unlocked(DBusPendingCall *pending, dbus_bool_t is_added)
Sets wether the timeout has been added.
Definition: dbus-pending-call.c:290
dbus_pending_call_ref
DBusPendingCall * dbus_pending_call_ref(DBusPendingCall *pending)
Increments the reference count on a pending call.
Definition: dbus-pending-call.c:604
dbus_pending_call_steal_reply
DBusMessage * dbus_pending_call_steal_reply(DBusPendingCall *pending)
Gets the reply, or returns NULL if none has been received yet.
Definition: dbus-pending-call.c:729
dbus_pending_call_block
void dbus_pending_call_block(DBusPendingCall *pending)
Block until the pending call is completed.
Definition: dbus-pending-call.c:764
dbus_pending_call_get_completed
dbus_bool_t dbus_pending_call_get_completed(DBusPendingCall *pending)
Checks whether the pending call has received a reply yet, or not.
Definition: dbus-pending-call.c:706
dbus_pending_call_unref
void dbus_pending_call_unref(DBusPendingCall *pending)
Decrements the reference count on a pending call, freeing it if the count reaches 0.
Definition: dbus-pending-call.c:624
DBUS_MESSAGE_TYPE_METHOD_CALL
#define DBUS_MESSAGE_TYPE_METHOD_CALL
Message type of a method call message, see dbus_message_get_type()
Definition: dbus-protocol.h:234
DBUS_MESSAGE_TYPE_ERROR
#define DBUS_MESSAGE_TYPE_ERROR
Message type of an error reply message, see dbus_message_get_type()
Definition: dbus-protocol.h:238
DBUS_ERROR_UNKNOWN_METHOD
#define DBUS_ERROR_UNKNOWN_METHOD
Method name you invoked isn't known by the object you invoked it on.
Definition: dbus-protocol.h:401
DBUS_TYPE_UNIX_FD
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
Definition: dbus-protocol.h:114
DBUS_ERROR_OBJECT_PATH_IN_USE
#define DBUS_ERROR_OBJECT_PATH_IN_USE
There's already an object with the requested object path.
Definition: dbus-protocol.h:454
DBUS_MESSAGE_TYPE_SIGNAL
#define DBUS_MESSAGE_TYPE_SIGNAL
Message type of a signal message, see dbus_message_get_type()
Definition: dbus-protocol.h:240
DBUS_TYPE_STRING
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
Definition: dbus-protocol.h:102
DBUS_ERROR_UNKNOWN_OBJECT
#define DBUS_ERROR_UNKNOWN_OBJECT
Object you invoked a method on isn't known.
Definition: dbus-protocol.h:403
DBUS_TYPE_INVALID
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
Definition: dbus-protocol.h:60
DBUS_ERROR_FAILED
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
Definition: dbus-protocol.h:359
DBUS_ERROR_NO_MEMORY
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
Definition: dbus-protocol.h:361
DBUS_ERROR_DISCONNECTED
#define DBUS_ERROR_DISCONNECTED
The connection is disconnected and you're trying to use it.
Definition: dbus-protocol.h:393
_dbus_counter_new
DBusCounter * _dbus_counter_new(void)
Creates a new DBusCounter.
Definition: dbus-resources.c:89
_dbus_counter_get_unix_fd_value
long _dbus_counter_get_unix_fd_value(DBusCounter *counter)
Gets the current value of the unix fd counter.
Definition: dbus-resources.c:290
_dbus_counter_unref
void _dbus_counter_unref(DBusCounter *counter)
Decrements refcount of the counter and possibly finalizes the counter.
Definition: dbus-resources.c:136
_dbus_counter_get_size_value
long _dbus_counter_get_size_value(DBusCounter *counter)
Gets the current value of the size counter.
Definition: dbus-resources.c:274
_dbus_counter_ref
DBusCounter * _dbus_counter_ref(DBusCounter *counter)
Increments refcount of the counter.
Definition: dbus-resources.c:116
DBusHandlerResult
DBusHandlerResult
Results that a message handler can return.
Definition: dbus-shared.h:67
DBUS_PATH_LOCAL
#define DBUS_PATH_LOCAL
The object path used in local/in-process-generated messages.
Definition: dbus-shared.h:82
DBUS_INTERFACE_LOCAL
#define DBUS_INTERFACE_LOCAL
This is a special interface whose methods can only be invoked by the local implementation (messages f...
Definition: dbus-shared.h:105
DBUS_INTERFACE_PEER
#define DBUS_INTERFACE_PEER
The interface supported by most dbus peers.
Definition: dbus-shared.h:99
DBUS_HANDLER_RESULT_NEED_MEMORY
@ DBUS_HANDLER_RESULT_NEED_MEMORY
Need more memory in order to return DBUS_HANDLER_RESULT_HANDLED or DBUS_HANDLER_RESULT_NOT_YET_HANDLE...
Definition: dbus-shared.h:70
DBUS_HANDLER_RESULT_HANDLED
@ DBUS_HANDLER_RESULT_HANDLED
Message has had its effect - no need to run more handlers.
Definition: dbus-shared.h:68
DBUS_HANDLER_RESULT_NOT_YET_HANDLED
@ DBUS_HANDLER_RESULT_NOT_YET_HANDLED
Message has not had any effect - see if other handlers want it.
Definition: dbus-shared.h:69
dbus_type_is_valid
dbus_bool_t dbus_type_is_valid(int typecode)
Return TRUE if the argument is a valid typecode.
Definition: dbus-signature.c:387
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:182
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as _DBUS_STRING_IN...
Definition: dbus-string.c:278
_dbus_string_append_printf
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
Definition: dbus-string.c:1145
_dbus_exit
void _dbus_exit(int code)
Exit the process, returning the given value.
Definition: dbus-sysdeps-unix.c:3480
_dbus_atomic_set_nonzero
void _dbus_atomic_set_nonzero(DBusAtomic *atomic)
Atomically set the value of an integer to something nonzero.
Definition: dbus-sysdeps-unix.c:3121
_dbus_atomic_dec
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
Definition: dbus-sysdeps-unix.c:3057
_dbus_atomic_get
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
Definition: dbus-sysdeps-unix.c:3081
_dbus_disable_sigpipe
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
Definition: dbus-sysdeps-unix.c:3509
_dbus_sleep_milliseconds
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
Definition: dbus-sysdeps-unix.c:3381
_dbus_atomic_set_zero
void _dbus_atomic_set_zero(DBusAtomic *atomic)
Atomically set the value of an integer to 0.
Definition: dbus-sysdeps-unix.c:3103
_dbus_atomic_inc
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
Definition: dbus-sysdeps-unix.c:3034
_dbus_get_monotonic_time
void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
Definition: dbus-sysdeps-unix.c:3220
_dbus_rmutex_new_at_location
void _dbus_rmutex_new_at_location(DBusRMutex **location_p)
Creates a new mutex or creates a no-op mutex if threads are not initialized.
Definition: dbus-threads.c:54
_dbus_cmutex_free_at_location
void _dbus_cmutex_free_at_location(DBusCMutex **location_p)
Frees a DBusCMutex; does nothing if passed a NULL pointer.
Definition: dbus-threads.c:108
_dbus_condvar_free_at_location
void _dbus_condvar_free_at_location(DBusCondVar **location_p)
Frees a condition variable; does nothing if passed a NULL pointer.
Definition: dbus-threads.c:225
_dbus_rmutex_unlock
DBUS_PRIVATE_EXPORT void _dbus_rmutex_unlock(DBusRMutex *mutex)
Unlocks a mutex.
Definition: dbus-threads.c:151
_dbus_condvar_wait
void _dbus_condvar_wait(DBusCondVar *cond, DBusCMutex *mutex)
Atomically unlocks the mutex and waits for the conditions variable to be signalled.
Definition: dbus-threads.c:241
_dbus_condvar_new_at_location
void _dbus_condvar_new_at_location(DBusCondVar **location_p)
This does the same thing as _dbus_condvar_new.
Definition: dbus-threads.c:200
_dbus_cmutex_new_at_location
void _dbus_cmutex_new_at_location(DBusCMutex **location_p)
Creates a new mutex or creates a no-op mutex if threads are not initialized.
Definition: dbus-threads.c:78
_dbus_condvar_wake_one
void _dbus_condvar_wake_one(DBusCondVar *cond)
If there are threads waiting on the condition variable, wake up exactly one.
Definition: dbus-threads.c:279
_dbus_condvar_wait_timeout
dbus_bool_t _dbus_condvar_wait_timeout(DBusCondVar *cond, DBusCMutex *mutex, int timeout_milliseconds)
Atomically unlocks the mutex and waits for the conditions variable to be signalled,...
Definition: dbus-threads.c:262
_dbus_cmutex_lock
void _dbus_cmutex_lock(DBusCMutex *mutex)
Locks a mutex.
Definition: dbus-threads.c:137
_dbus_cmutex_unlock
void _dbus_cmutex_unlock(DBusCMutex *mutex)
Unlocks a mutex.
Definition: dbus-threads.c:165
_dbus_rmutex_free_at_location
void _dbus_rmutex_free_at_location(DBusRMutex **location_p)
Frees a DBusRMutex; does nothing if passed a NULL pointer.
Definition: dbus-threads.c:95
DBusMutex
struct DBusMutex DBusMutex
An opaque mutex type provided by the DBusThreadFunctions implementation installed by dbus_threads_ini...
Definition: dbus-threads.h:41
_dbus_timeout_list_add_timeout
dbus_bool_t _dbus_timeout_list_add_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout)
Adds a new timeout to the timeout list, invoking the application DBusAddTimeoutFunction if appropriat...
Definition: dbus-timeout.c:312
_dbus_timeout_list_free
void _dbus_timeout_list_free(DBusTimeoutList *timeout_list)
Frees a DBusTimeoutList.
Definition: dbus-timeout.c:215
_dbus_timeout_list_toggle_timeout
void _dbus_timeout_list_toggle_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout, dbus_bool_t enabled)
Sets a timeout to the given enabled state, invoking the application's DBusTimeoutToggledFunction if a...
Definition: dbus-timeout.c:364
_dbus_timeout_list_new
DBusTimeoutList * _dbus_timeout_list_new(void)
Creates a new timeout list.
Definition: dbus-timeout.c:198
_dbus_timeout_list_set_functions
dbus_bool_t _dbus_timeout_list_set_functions(DBusTimeoutList *timeout_list, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the timeout functions.
Definition: dbus-timeout.c:241
_dbus_timeout_list_remove_timeout
void _dbus_timeout_list_remove_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout)
Removes a timeout from the timeout list, invoking the application's DBusRemoveTimeoutFunction if appr...
Definition: dbus-timeout.c:342
dbus_timeout_get_interval
DBUS_EXPORT int dbus_timeout_get_interval(DBusTimeout *timeout)
Gets the timeout interval.
Definition: dbus-timeout.c:442
_dbus_transport_set_max_message_size
void _dbus_transport_set_max_message_size(DBusTransport *transport, long size)
See dbus_connection_set_max_message_size().
Definition: dbus-transport.c:1219
_dbus_transport_set_max_received_size
void _dbus_transport_set_max_received_size(DBusTransport *transport, long size)
See dbus_connection_set_max_received_size().
Definition: dbus-transport.c:1269
_dbus_transport_get_dispatch_status
DBusDispatchStatus _dbus_transport_get_dispatch_status(DBusTransport *transport)
Reports our current dispatch status (whether there's buffered data to be queued as messages,...
Definition: dbus-transport.c:1121
_dbus_transport_get_pending_fds_count
int _dbus_transport_get_pending_fds_count(DBusTransport *transport)
Return how many file descriptors are pending in the loader.
Definition: dbus-transport.c:1584
_dbus_transport_get_adt_audit_session_data
dbus_bool_t _dbus_transport_get_adt_audit_session_data(DBusTransport *transport, void **data, int *data_size)
See dbus_connection_get_adt_audit_session_data().
Definition: dbus-transport.c:1397
_dbus_transport_get_windows_user
dbus_bool_t _dbus_transport_get_windows_user(DBusTransport *transport, char **windows_sid_p)
See dbus_connection_get_windows_user().
Definition: dbus-transport.c:1499
_dbus_transport_queue_messages
dbus_bool_t _dbus_transport_queue_messages(DBusTransport *transport)
Processes data we've read while handling a watch, potentially converting some of it to messages and q...
Definition: dbus-transport.c:1160
_dbus_transport_get_socket_fd
dbus_bool_t _dbus_transport_get_socket_fd(DBusTransport *transport, DBusSocket *fd_p)
Get the socket file descriptor, if any.
Definition: dbus-transport.c:963
_dbus_transport_get_address
const char * _dbus_transport_get_address(DBusTransport *transport)
Gets the address of a transport.
Definition: dbus-transport.c:868
_dbus_transport_handle_watch
dbus_bool_t _dbus_transport_handle_watch(DBusTransport *transport, DBusWatch *watch, unsigned int condition)
Handles a watch by reading data, writing data, or disconnecting the transport, as appropriate for the...
Definition: dbus-transport.c:901
_dbus_transport_ref
DBusTransport * _dbus_transport_ref(DBusTransport *transport)
Increments the reference count for the transport.
Definition: dbus-transport.c:463
_dbus_transport_peek_is_authenticated
dbus_bool_t _dbus_transport_peek_is_authenticated(DBusTransport *transport)
Returns TRUE if we have been authenticated.
Definition: dbus-transport.c:704
_dbus_transport_set_allow_anonymous
void _dbus_transport_set_allow_anonymous(DBusTransport *transport, dbus_bool_t value)
See dbus_connection_set_allow_anonymous()
Definition: dbus-transport.c:1572
_dbus_transport_disconnect
void _dbus_transport_disconnect(DBusTransport *transport)
Closes our end of the connection to a remote application.
Definition: dbus-transport.c:505
_dbus_transport_get_max_received_size
long _dbus_transport_get_max_received_size(DBusTransport *transport)
See dbus_connection_get_max_received_size().
Definition: dbus-transport.c:1305
_dbus_transport_get_credentials
DBusCredentials * _dbus_transport_get_credentials(DBusTransport *transport)
If the transport has already been authenticated, return its credentials.
Definition: dbus-transport.c:1483
_dbus_transport_set_connection
dbus_bool_t _dbus_transport_set_connection(DBusTransport *transport, DBusConnection *connection)
Sets the connection using this transport.
Definition: dbus-transport.c:939
_dbus_transport_set_unix_user_function
void _dbus_transport_set_unix_user_function(DBusTransport *transport, DBusAllowUnixUserFunction function, void *data, DBusFreeFunction free_data_function, void **old_data, DBusFreeFunction *old_free_data_function)
See dbus_connection_set_unix_user_function().
Definition: dbus-transport.c:1433
_dbus_transport_get_max_message_unix_fds
long _dbus_transport_get_max_message_unix_fds(DBusTransport *transport)
See dbus_connection_get_max_message_unix_fds().
Definition: dbus-transport.c:1257
_dbus_transport_set_max_received_unix_fds
void _dbus_transport_set_max_received_unix_fds(DBusTransport *transport, long n)
See dbus_connection_set_max_received_unix_fds().
Definition: dbus-transport.c:1287
_dbus_transport_unref
void _dbus_transport_unref(DBusTransport *transport)
Decrements the reference count for the transport.
Definition: dbus-transport.c:480
_dbus_transport_can_pass_unix_fd
dbus_bool_t _dbus_transport_can_pass_unix_fd(DBusTransport *transport)
Returns TRUE if the transport supports sending unix fds.
Definition: dbus-transport.c:855
_dbus_transport_try_to_authenticate
dbus_bool_t _dbus_transport_try_to_authenticate(DBusTransport *transport)
Returns TRUE if we have been authenticated.
Definition: dbus-transport.c:727
_dbus_transport_do_iteration
void _dbus_transport_do_iteration(DBusTransport *transport, unsigned int flags, int timeout_milliseconds)
Performs a single poll()/select() on the transport's file descriptors and then reads/writes data as a...
Definition: dbus-transport.c:996
_dbus_transport_get_max_received_unix_fds
long _dbus_transport_get_max_received_unix_fds(DBusTransport *transport)
See dbus_connection_set_max_received_unix_fds().
Definition: dbus-transport.c:1317
_dbus_transport_get_is_connected
dbus_bool_t _dbus_transport_get_is_connected(DBusTransport *transport)
Returns TRUE if the transport has not been disconnected.
Definition: dbus-transport.c:530
_dbus_transport_set_max_message_unix_fds
void _dbus_transport_set_max_message_unix_fds(DBusTransport *transport, long n)
See dbus_connection_set_max_message_unix_fds().
Definition: dbus-transport.c:1232
_dbus_transport_set_pending_fds_function
void _dbus_transport_set_pending_fds_function(DBusTransport *transport, void(*callback)(void *), void *data)
Register a function to be called whenever the number of pending file descriptors in the loader change...
Definition: dbus-transport.c:1597
_dbus_transport_set_windows_user_function
void _dbus_transport_set_windows_user_function(DBusTransport *transport, DBusAllowWindowsUserFunction function, void *data, DBusFreeFunction free_data_function, void **old_data, DBusFreeFunction *old_free_data_function)
See dbus_connection_set_windows_user_function().
Definition: dbus-transport.c:1535
_dbus_transport_get_max_message_size
long _dbus_transport_get_max_message_size(DBusTransport *transport)
See dbus_connection_get_max_message_size().
Definition: dbus-transport.c:1245
_dbus_transport_get_unix_process_id
dbus_bool_t _dbus_transport_get_unix_process_id(DBusTransport *transport, unsigned long *pid)
See dbus_connection_get_unix_process_id().
Definition: dbus-transport.c:1363
_dbus_transport_open
DBusTransport * _dbus_transport_open(DBusAddressEntry *entry, DBusError *error)
Try to open a new transport for the given address entry.
Definition: dbus-transport.c:367
_dbus_transport_get_server_id
const char * _dbus_transport_get_server_id(DBusTransport *transport)
Gets the id of the server we are connected to (see dbus_server_get_id()).
Definition: dbus-transport.c:881
_dbus_transport_get_is_anonymous
dbus_bool_t _dbus_transport_get_is_anonymous(DBusTransport *transport)
See dbus_connection_get_is_anonymous().
Definition: dbus-transport.c:833
_dbus_transport_get_unix_user
dbus_bool_t _dbus_transport_get_unix_user(DBusTransport *transport, unsigned long *uid)
See dbus_connection_get_unix_user().
Definition: dbus-transport.c:1330
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
dbus_int32_t
int dbus_int32_t
A 32-bit signed integer on all platforms.
Definition: dbus-arch-deps.h:42
dbus_uint32_t
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms.
Definition: dbus-arch-deps.h:43
_dbus_watch_list_add_watch
dbus_bool_t _dbus_watch_list_add_watch(DBusWatchList *watch_list, DBusWatch *watch)
Adds a new watch to the watch list, invoking the application DBusAddWatchFunction if appropriate.
Definition: dbus-watch.c:381
_dbus_watch_list_toggle_watch
void _dbus_watch_list_toggle_watch(DBusWatchList *watch_list, DBusWatch *watch, dbus_bool_t enabled)
Sets a watch to the given enabled state, invoking the application's DBusWatchToggledFunction if appro...
Definition: dbus-watch.c:441
_dbus_watch_list_new
DBusWatchList * _dbus_watch_list_new(void)
Creates a new watch list.
Definition: dbus-watch.c:232
_dbus_watch_list_free
void _dbus_watch_list_free(DBusWatchList *watch_list)
Frees a DBusWatchList.
Definition: dbus-watch.c:249
_dbus_watch_list_set_functions
dbus_bool_t _dbus_watch_list_set_functions(DBusWatchList *watch_list, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the watch functions.
Definition: dbus-watch.c:295
_dbus_watch_list_remove_watch
void _dbus_watch_list_remove_watch(DBusWatchList *watch_list, DBusWatch *watch)
Removes a watch from the watch list, invoking the application's DBusRemoveWatchFunction if appropriat...
Definition: dbus-watch.c:414
DBusAddressEntry
Internals of DBusAddressEntry.
Definition: dbus-address.c:47
DBusAtomic
An atomic integer safe to increment or decrement from multiple threads.
Definition: dbus-sysdeps.h:323
DBusCMutex
Definition: dbus-sysdeps-pthread.c:53
DBusCondVar
Definition: dbus-sysdeps-pthread.c:57
DBusConnection
Implementation details of DBusConnection.
Definition: dbus-connection.c:257
DBusConnection::dispatch_status_data
void * dispatch_status_data
Application data for dispatch_status_function.
Definition: dbus-connection.c:299
DBusConnection::n_outgoing
int n_outgoing
Length of outgoing queue.
Definition: dbus-connection.c:275
DBusConnection::slot_list
DBusDataSlotList slot_list
Data stored by allocated integer ID.
Definition: dbus-connection.c:287
DBusConnection::dispatch_acquired
dbus_bool_t dispatch_acquired
Someone has dispatch path (can drain incoming queue)
Definition: dbus-connection.c:312
DBusConnection::dispatch_cond
DBusCondVar * dispatch_cond
Notify when dispatch_acquired is available.
Definition: dbus-connection.c:263
DBusConnection::wakeup_main_function
DBusWakeupMainFunction wakeup_main_function
Function to wake up the mainloop
Definition: dbus-connection.c:294
DBusConnection::exit_on_disconnect
unsigned int exit_on_disconnect
If TRUE, exit after handling disconnect signal.
Definition: dbus-connection.c:317
DBusConnection::filter_list
DBusList * filter_list
List of filters.
Definition: dbus-connection.c:284
DBusConnection::have_connection_lock
unsigned int have_connection_lock
Used to check locking.
Definition: dbus-connection.c:332
DBusConnection::disconnected_message_processed
unsigned int disconnected_message_processed
We did our default handling of the disconnected message, such as closing the connection.
Definition: dbus-connection.c:327
DBusConnection::client_serial
dbus_uint32_t client_serial
Client serial.
Definition: dbus-connection.c:291
DBusConnection::disconnected_message_arrived
unsigned int disconnected_message_arrived
We popped or are dispatching the disconnected message.
Definition: dbus-connection.c:323
DBusConnection::outgoing_counter
DBusCounter * outgoing_counter
Counts size of outgoing messages.
Definition: dbus-connection.c:278
DBusConnection::builtin_filters_enabled
unsigned int builtin_filters_enabled
If TRUE, handle org.freedesktop.DBus.Peer messages automatically, whether they have a bus name or not...
Definition: dbus-connection.c:319
DBusConnection::io_path_cond
DBusCondVar * io_path_cond
Notify when io_path_acquired is available.
Definition: dbus-connection.c:265
DBusConnection::refcount
DBusAtomic refcount
Reference count.
Definition: dbus-connection.c:258
DBusConnection::outgoing_messages
DBusList * outgoing_messages
Queue of messages we need to send, send the end of the list first.
Definition: dbus-connection.c:267
DBusConnection::free_dispatch_status_data
DBusFreeFunction free_dispatch_status_data
free dispatch_status_data
Definition: dbus-connection.c:300
DBusConnection::slot_mutex
DBusRMutex * slot_mutex
Lock on slot_list so overall connection lock need not be taken.
Definition: dbus-connection.c:286
DBusConnection::free_wakeup_main_data
DBusFreeFunction free_wakeup_main_data
free wakeup_main_data
Definition: dbus-connection.c:296
DBusConnection::transport
DBusTransport * transport
Object that sends/receives messages over network.
Definition: dbus-connection.c:280
DBusConnection::mutex
DBusRMutex * mutex
Lock on the entire DBusConnection.
Definition: dbus-connection.c:260
DBusConnection::n_incoming
int n_incoming
Length of incoming queue.
Definition: dbus-connection.c:276
DBusConnection::io_path_acquired
dbus_bool_t io_path_acquired
Someone has transport io path (can use the transport to read/write messages)
Definition: dbus-connection.c:313
DBusConnection::disconnect_message_link
DBusList * disconnect_message_link
Preallocated list node for queueing the disconnection message.
Definition: dbus-connection.c:292
DBusConnection::io_path_mutex
DBusCMutex * io_path_mutex
Protects io_path_acquired.
Definition: dbus-connection.c:264
DBusConnection::incoming_messages
DBusList * incoming_messages
Queue of messages we have received, end of the list received most recently.
Definition: dbus-connection.c:268
DBusConnection::shareable
unsigned int shareable
TRUE if libdbus owns a reference to the connection and can return it from dbus_connection_open() more...
Definition: dbus-connection.c:315
DBusConnection::route_peer_messages
unsigned int route_peer_messages
If TRUE, if org.freedesktop.DBus.Peer messages have a bus name, don't handle them automatically.
Definition: dbus-connection.c:321
DBusConnection::watches
DBusWatchList * watches
Stores active watches.
Definition: dbus-connection.c:281
DBusConnection::wakeup_main_data
void * wakeup_main_data
Application data for wakeup_main_function.
Definition: dbus-connection.c:295
DBusConnection::objects
DBusObjectTree * objects
Object path handlers registered with this connection.
Definition: dbus-connection.c:304
DBusConnection::server_guid
char * server_guid
GUID of server if we are in shared_connections, NULL if server GUID is unknown or connection is priva...
Definition: dbus-connection.c:306
DBusConnection::pending_replies
DBusHashTable * pending_replies
Hash of message serials to DBusPendingCall.
Definition: dbus-connection.c:289
DBusConnection::dispatch_mutex
DBusCMutex * dispatch_mutex
Protects dispatch_acquired.
Definition: dbus-connection.c:262
DBusConnection::message_borrowed
DBusMessage * message_borrowed
Filled in if the first incoming message has been borrowed; dispatch_acquired will be set by the borro...
Definition: dbus-connection.c:271
DBusConnection::timeouts
DBusTimeoutList * timeouts
Stores active timeouts.
Definition: dbus-connection.c:282
DBusConnection::last_dispatch_status
DBusDispatchStatus last_dispatch_status
The last dispatch status we reported to the application.
Definition: dbus-connection.c:302
DBusConnection::dispatch_status_function
DBusDispatchStatusFunction dispatch_status_function
Function on dispatch status changes
Definition: dbus-connection.c:298
DBusConnection::expired_messages
DBusList * expired_messages
Messages that will be released when we next unlock.
Definition: dbus-connection.c:269
DBusCounter
Internals of DBusCounter.
Definition: dbus-resources.c:55
DBusCredentials
Definition: dbus-credentials.c:49
DBusDataSlotAllocator
An allocator that tracks a set of slot IDs.
Definition: dbus-dataslot.h:56
DBusDataSlotList
Data structure that stores the actual user data set at a given slot.
Definition: dbus-dataslot.h:70
DBusError
Object representing an exception.
Definition: dbus-errors.h:49
DBusError::name
const char * name
public error name field
Definition: dbus-errors.h:50
DBusError::message
const char * message
public error message field
Definition: dbus-errors.h:51
DBusHashIter
Hash iterator object.
Definition: dbus-hash.h:50
DBusHashTable
Internals of DBusHashTable.
Definition: dbus-hash.c:174
DBusList
A node in a linked list.
Definition: dbus-list.h:35
DBusList::data
void * data
Data stored at this element.
Definition: dbus-list.h:38
DBusMessageFilter
Internal struct representing a message filter function.
Definition: dbus-connection.c:229
DBusMessageFilter::refcount
DBusAtomic refcount
Reference count.
Definition: dbus-connection.c:230
DBusMessageFilter::function
DBusHandleMessageFunction function
Function to call to filter.
Definition: dbus-connection.c:231
DBusMessageFilter::user_data
void * user_data
User data for the function.
Definition: dbus-connection.c:232
DBusMessageFilter::free_user_data_function
DBusFreeFunction free_user_data_function
Function to free the user data.
Definition: dbus-connection.c:233
DBusMessageIter
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:62
DBusMessage
Internals of DBusMessage.
Definition: dbus-message-private.h:100
DBusObjectPathVTable
Virtual table that must be implemented to handle a portion of the object path hierarchy.
Definition: dbus-connection.h:386
DBusObjectTree
Internals of DBusObjectTree.
Definition: dbus-object-tree.c:59
DBusPendingCall
Implementation details of DBusPendingCall - all fields are private.
Definition: dbus-pending-call.c:63
DBusPreallocatedSend
Internals of DBusPreallocatedSend.
Definition: dbus-connection.c:241
DBusPreallocatedSend::connection
DBusConnection * connection
Connection we'd send the message to.
Definition: dbus-connection.c:242
DBusPreallocatedSend::counter_link
DBusList * counter_link
Preallocated link in the resource counter.
Definition: dbus-connection.c:244
DBusPreallocatedSend::queue_link
DBusList * queue_link
Preallocated link in the queue.
Definition: dbus-connection.c:243
DBusRMutex
Definition: dbus-sysdeps-pthread.c:49
DBusSocket
Socket interface.
Definition: dbus-sysdeps.h:181
DBusString
Definition: dbus-string.h:43
DBusTimeoutList
DBusTimeoutList implementation details.
Definition: dbus-timeout.c:181
DBusTimeout
Internals of DBusTimeout.
Definition: dbus-timeout.c:41
DBusTransport
Object representing a transport such as a socket.
Definition: dbus-transport-protected.h:81
DBusWatchList
DBusWatchList implementation details.
Definition: dbus-watch.c:215
DBusWatch
Implementation of DBusWatch.
Definition: dbus-watch.c:41