D-Bus 1.13.18

dbus-server.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-server.c DBusServer object
3 *
4 * Copyright (C) 2002, 2003, 2004, 2005 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-server.h"
26 #include "dbus-server-unix.h"
27 #include "dbus-server-socket.h"
28 #include "dbus-string.h"
29 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
30 #include "dbus-server-debug-pipe.h"
31 #endif
32 #include "dbus-address.h"
33 #include "dbus-protocol.h"
34
56 #ifndef _dbus_server_trace_ref
57 void
58 _dbus_server_trace_ref (DBusServer *server,
59 int old_refcount,
60 int new_refcount,
61 const char *why)
62 {
63 static int enabled = -1;
64
65 _dbus_trace_ref ("DBusServer", server, old_refcount, new_refcount, why,
66 "DBUS_SERVER_TRACE", &enabled);
67 }
68 #endif
69
70 /* this is a little fragile since it assumes the address doesn't
71 * already have a guid, but it shouldn't
72 */
73 static char*
74 copy_address_with_guid_appended (const DBusString *address,
75 const DBusString *guid_hex)
76 {
77 DBusString with_guid;
78 char *retval;
79
80 if (!_dbus_string_init (&with_guid))
81 return NULL;
82
83 if (!_dbus_string_copy (address, 0, &with_guid,
84 _dbus_string_get_length (&with_guid)) ||
85 !_dbus_string_append (&with_guid, ",guid=") ||
86 !_dbus_string_copy (guid_hex, 0,
87 &with_guid, _dbus_string_get_length (&with_guid)))
88 {
89 _dbus_string_free (&with_guid);
90 return NULL;
91 }
92
93 retval = NULL;
94 _dbus_string_steal_data (&with_guid, &retval);
95
96 _dbus_string_free (&with_guid);
97
98 return retval; /* may be NULL if steal_data failed */
99 }
100
111 dbus_bool_t
112 _dbus_server_init_base (DBusServer *server,
113 const DBusServerVTable *vtable,
114 const DBusString *address,
115 DBusError *error)
116 {
117 server->vtable = vtable;
118
119 #ifdef DBUS_DISABLE_ASSERT
120 _dbus_atomic_inc (&server->refcount);
121 #else
122 {
123 dbus_int32_t old_refcount = _dbus_atomic_inc (&server->refcount);
124
125 _dbus_assert (old_refcount == 0);
126 }
127 #endif
128
129 server->address = NULL;
130 server->watches = NULL;
131 server->timeouts = NULL;
132 server->published_address = FALSE;
133
134 if (!_dbus_string_init (&server->guid_hex))
135 {
136 _DBUS_SET_OOM (error);
137 return FALSE;
138 }
139
140 if (!_dbus_generate_uuid (&server->guid, error))
141 goto failed;
142
143 if (!_dbus_uuid_encode (&server->guid, &server->guid_hex))
144 goto oom;
145
146 server->address = copy_address_with_guid_appended (address,
147 &server->guid_hex);
148 if (server->address == NULL)
149 goto oom;
150
151 _dbus_rmutex_new_at_location (&server->mutex);
152 if (server->mutex == NULL)
153 goto oom;
154
155 server->watches = _dbus_watch_list_new ();
156 if (server->watches == NULL)
157 goto oom;
158
159 server->timeouts = _dbus_timeout_list_new ();
160 if (server->timeouts == NULL)
161 goto oom;
162
163 _dbus_data_slot_list_init (&server->slot_list);
164
165 _dbus_verbose ("Initialized server on address %s\n", server->address);
166
167 return TRUE;
168
169 oom:
170 _DBUS_SET_OOM (error);
171 failed:
172 _dbus_rmutex_free_at_location (&server->mutex);
173 server->mutex = NULL;
174 if (server->watches)
175 {
176 _dbus_watch_list_free (server->watches);
177 server->watches = NULL;
178 }
179 if (server->timeouts)
180 {
181 _dbus_timeout_list_free (server->timeouts);
182 server->timeouts = NULL;
183 }
184 if (server->address)
185 {
186 dbus_free (server->address);
187 server->address = NULL;
188 }
189 _dbus_string_free (&server->guid_hex);
190
191 return FALSE;
192 }
193
200 void
201 _dbus_server_finalize_base (DBusServer *server)
202 {
203 /* We don't have the lock, but nobody should be accessing
204 * concurrently since they don't have a ref
205 */
206 #ifndef DBUS_DISABLE_CHECKS
207 _dbus_assert (!server->have_server_lock);
208 #endif
209 _dbus_assert (server->disconnected);
210
211 /* calls out to application code... */
212 _dbus_data_slot_list_free (&server->slot_list);
213
214 dbus_server_set_new_connection_function (server, NULL, NULL, NULL);
215
216 _dbus_watch_list_free (server->watches);
217 _dbus_timeout_list_free (server->timeouts);
218
219 _dbus_rmutex_free_at_location (&server->mutex);
220
221 dbus_free (server->address);
222
223 dbus_free_string_array (server->auth_mechanisms);
224
225 _dbus_string_free (&server->guid_hex);
226 }
227
228
230 typedef dbus_bool_t (* DBusWatchAddFunction) (DBusWatchList *list,
231 DBusWatch *watch);
233 typedef void (* DBusWatchRemoveFunction) (DBusWatchList *list,
234 DBusWatch *watch);
236 typedef void (* DBusWatchToggleFunction) (DBusWatchList *list,
237 DBusWatch *watch,
238 dbus_bool_t enabled);
239
240 static dbus_bool_t
241 protected_change_watch (DBusServer *server,
242 DBusWatch *watch,
243 DBusWatchAddFunction add_function,
244 DBusWatchRemoveFunction remove_function,
245 DBusWatchToggleFunction toggle_function,
246 dbus_bool_t enabled)
247 {
248 DBusWatchList *watches;
249 dbus_bool_t retval;
250
251 HAVE_LOCK_CHECK (server);
252
253 /* This isn't really safe or reasonable; a better pattern is the "do
254 * everything, then drop lock and call out" one; but it has to be
255 * propagated up through all callers
256 */
257
258 watches = server->watches;
259 if (watches)
260 {
261 server->watches = NULL;
262 _dbus_server_ref_unlocked (server);
263 SERVER_UNLOCK (server);
264
265 if (add_function)
266 retval = (* add_function) (watches, watch);
267 else if (remove_function)
268 {
269 retval = TRUE;
270 (* remove_function) (watches, watch);
271 }
272 else
273 {
274 retval = TRUE;
275 (* toggle_function) (watches, watch, enabled);
276 }
277
278 SERVER_LOCK (server);
279 server->watches = watches;
280 _dbus_server_unref_unlocked (server);
281
282 return retval;
283 }
284 else
285 return FALSE;
286 }
287
295 dbus_bool_t
296 _dbus_server_add_watch (DBusServer *server,
297 DBusWatch *watch)
298 {
299 HAVE_LOCK_CHECK (server);
300 return protected_change_watch (server, watch,
301 _dbus_watch_list_add_watch,
302 NULL, NULL, FALSE);
303 }
304
311 void
312 _dbus_server_remove_watch (DBusServer *server,
313 DBusWatch *watch)
314 {
315 HAVE_LOCK_CHECK (server);
316 protected_change_watch (server, watch,
317 NULL,
318 _dbus_watch_list_remove_watch,
319 NULL, FALSE);
320 }
321
329 void
330 _dbus_server_toggle_all_watches (DBusServer *server,
331 dbus_bool_t enabled)
332 {
333 _dbus_watch_list_toggle_all_watches (server->watches, enabled);
334 }
335
337 typedef dbus_bool_t (* DBusTimeoutAddFunction) (DBusTimeoutList *list,
338 DBusTimeout *timeout);
340 typedef void (* DBusTimeoutRemoveFunction) (DBusTimeoutList *list,
341 DBusTimeout *timeout);
343 typedef void (* DBusTimeoutToggleFunction) (DBusTimeoutList *list,
344 DBusTimeout *timeout,
345 dbus_bool_t enabled);
346
347
348 static dbus_bool_t
349 protected_change_timeout (DBusServer *server,
350 DBusTimeout *timeout,
351 DBusTimeoutAddFunction add_function,
352 DBusTimeoutRemoveFunction remove_function,
353 DBusTimeoutToggleFunction toggle_function,
354 dbus_bool_t enabled)
355 {
356 DBusTimeoutList *timeouts;
357 dbus_bool_t retval;
358
359 HAVE_LOCK_CHECK (server);
360
361 /* This isn't really safe or reasonable; a better pattern is the "do everything, then
362 * drop lock and call out" one; but it has to be propagated up through all callers
363 */
364
365 timeouts = server->timeouts;
366 if (timeouts)
367 {
368 server->timeouts = NULL;
369 _dbus_server_ref_unlocked (server);
370 SERVER_UNLOCK (server);
371
372 if (add_function)
373 retval = (* add_function) (timeouts, timeout);
374 else if (remove_function)
375 {
376 retval = TRUE;
377 (* remove_function) (timeouts, timeout);
378 }
379 else
380 {
381 retval = TRUE;
382 (* toggle_function) (timeouts, timeout, enabled);
383 }
384
385 SERVER_LOCK (server);
386 server->timeouts = timeouts;
387 _dbus_server_unref_unlocked (server);
388
389 return retval;
390 }
391 else
392 return FALSE;
393 }
394
404 dbus_bool_t
405 _dbus_server_add_timeout (DBusServer *server,
406 DBusTimeout *timeout)
407 {
408 return protected_change_timeout (server, timeout,
409 _dbus_timeout_list_add_timeout,
410 NULL, NULL, FALSE);
411 }
412
419 void
420 _dbus_server_remove_timeout (DBusServer *server,
421 DBusTimeout *timeout)
422 {
423 protected_change_timeout (server, timeout,
424 NULL,
425 _dbus_timeout_list_remove_timeout,
426 NULL, FALSE);
427 }
428
438 void
439 _dbus_server_toggle_timeout (DBusServer *server,
440 DBusTimeout *timeout,
441 dbus_bool_t enabled)
442 {
443 protected_change_timeout (server, timeout,
444 NULL, NULL,
445 _dbus_timeout_list_toggle_timeout,
446 enabled);
447 }
448
449
455 void
456 _dbus_server_ref_unlocked (DBusServer *server)
457 {
458 dbus_int32_t old_refcount;
459
460 _dbus_assert (server != NULL);
461 HAVE_LOCK_CHECK (server);
462
463 old_refcount = _dbus_atomic_inc (&server->refcount);
464 _dbus_assert (old_refcount > 0);
465 _dbus_server_trace_ref (server, old_refcount, old_refcount + 1,
466 "ref_unlocked");
467 }
468
474 void
475 _dbus_server_unref_unlocked (DBusServer *server)
476 {
477 dbus_int32_t old_refcount;
478
479 /* Keep this in sync with dbus_server_unref */
480
481 _dbus_assert (server != NULL);
482
483 HAVE_LOCK_CHECK (server);
484
485 old_refcount = _dbus_atomic_dec (&server->refcount);
486 _dbus_assert (old_refcount > 0);
487
488 _dbus_server_trace_ref (server, old_refcount, old_refcount - 1,
489 "unref_unlocked");
490
491 if (old_refcount == 1)
492 {
493 _dbus_assert (server->disconnected);
494
495 SERVER_UNLOCK (server);
496
497 _dbus_assert (server->vtable->finalize != NULL);
498
499 (* server->vtable->finalize) (server);
500 }
501 }
502
524 static const struct {
525 DBusServerListenResult (* func) (DBusAddressEntry *entry,
526 DBusServer **server_p,
527 DBusError *error);
528 } listen_funcs[] = {
529 { _dbus_server_listen_socket }
530 , { _dbus_server_listen_platform_specific }
531 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
532 , { _dbus_server_listen_debug_pipe }
533 #endif
534 };
535
556 DBusServer*
557 dbus_server_listen (const char *address,
558 DBusError *error)
559 {
560 DBusServer *server;
561 DBusAddressEntry **entries;
562 int len, i;
563 DBusError first_connect_error = DBUS_ERROR_INIT;
564 dbus_bool_t handled_once;
565
566 _dbus_return_val_if_fail (address != NULL, NULL);
567 _dbus_return_val_if_error_is_set (error, NULL);
568
569 if (!dbus_parse_address (address, &entries, &len, error))
570 return NULL;
571
572 server = NULL;
573 handled_once = FALSE;
574
575 for (i = 0; i < len; i++)
576 {
577 int j;
578
579 for (j = 0; j < (int) _DBUS_N_ELEMENTS (listen_funcs); ++j)
580 {
581 DBusServerListenResult result;
582 DBusError tmp_error = DBUS_ERROR_INIT;
583
584 result = (* listen_funcs[j].func) (entries[i],
585 &server,
586 &tmp_error);
587
588 if (result == DBUS_SERVER_LISTEN_OK)
589 {
590 _dbus_assert (server != NULL);
591 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
592 handled_once = TRUE;
593 goto out;
594 }
595 else if (result == DBUS_SERVER_LISTEN_ADDRESS_ALREADY_USED)
596 {
597 _dbus_assert (server == NULL);
598 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
599 dbus_set_error (error,
600 DBUS_ERROR_ADDRESS_IN_USE,
601 "Address '%s' already used",
602 dbus_address_entry_get_method (entries[0]));
603 handled_once = TRUE;
604 goto out;
605 }
606 else if (result == DBUS_SERVER_LISTEN_BAD_ADDRESS)
607 {
608 _dbus_assert (server == NULL);
609 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
610 dbus_move_error (&tmp_error, error);
611 handled_once = TRUE;
612 goto out;
613 }
614 else if (result == DBUS_SERVER_LISTEN_NOT_HANDLED)
615 {
616 _dbus_assert (server == NULL);
617 _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
618
619 /* keep trying addresses */
620 }
621 else if (result == DBUS_SERVER_LISTEN_DID_NOT_CONNECT)
622 {
623 _dbus_assert (server == NULL);
624 _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
625 if (!dbus_error_is_set (&first_connect_error))
626 dbus_move_error (&tmp_error, &first_connect_error);
627 else
628 dbus_error_free (&tmp_error);
629
630 handled_once = TRUE;
631
632 /* keep trying addresses */
633 }
634 else
635 {
636 _dbus_assert_not_reached ("Unknown result in dbus_server_listen");
637 }
638 }
639
640 _dbus_assert (server == NULL);
641 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
642 }
643
644 out:
645
646 if (!handled_once)
647 {
648 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
649 if (len > 0)
650 dbus_set_error (error,
651 DBUS_ERROR_BAD_ADDRESS,
652 "Unknown address type '%s'",
653 dbus_address_entry_get_method (entries[0]));
654 else
655 dbus_set_error (error,
656 DBUS_ERROR_BAD_ADDRESS,
657 "Empty address '%s'",
658 address);
659 }
660
661 dbus_address_entries_free (entries);
662
663 if (server == NULL)
664 {
665 _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error) ||
666 dbus_error_is_set (error));
667
668 if (error && dbus_error_is_set (error))
669 {
670 /* already set the error */
671 }
672 else
673 {
674 /* didn't set the error but either error should be
675 * NULL or first_connect_error should be set.
676 */
677 _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error));
678 dbus_move_error (&first_connect_error, error);
679 }
680
681 _DBUS_ASSERT_ERROR_IS_CLEAR (&first_connect_error); /* be sure we freed it */
682 _DBUS_ASSERT_ERROR_IS_SET (error);
683
684 return NULL;
685 }
686 else
687 {
688 dbus_error_free (&first_connect_error);
689 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
690 return server;
691 }
692 }
693
700 DBusServer *
701 dbus_server_ref (DBusServer *server)
702 {
703 dbus_int32_t old_refcount;
704
705 _dbus_return_val_if_fail (server != NULL, NULL);
706
707 old_refcount = _dbus_atomic_inc (&server->refcount);
708
709 #ifndef DBUS_DISABLE_CHECKS
710 if (_DBUS_UNLIKELY (old_refcount <= 0))
711 {
712 _dbus_atomic_dec (&server->refcount);
713 _dbus_warn_return_if_fail (_DBUS_FUNCTION_NAME, "old_refcount > 0",
714 __FILE__, __LINE__);
715 return NULL;
716 }
717 #endif
718
719 _dbus_server_trace_ref (server, old_refcount, old_refcount + 1, "ref");
720
721 return server;
722 }
723
732 void
733 dbus_server_unref (DBusServer *server)
734 {
735 dbus_int32_t old_refcount;
736
737 /* keep this in sync with unref_unlocked */
738
739 _dbus_return_if_fail (server != NULL);
740
741 old_refcount = _dbus_atomic_dec (&server->refcount);
742
743 #ifndef DBUS_DISABLE_CHECKS
744 if (_DBUS_UNLIKELY (old_refcount <= 0))
745 {
746 /* undo side-effect first
747 * please do not try to simplify the code here by using
748 * _dbus_atomic_get(), why we don't use it is
749 * because it issues another atomic operation even though
750 * DBUS_DISABLE_CHECKS defined.
751 * Bug: https://bugs.freedesktop.org/show_bug.cgi?id=68303
752 */
753 _dbus_atomic_inc (&server->refcount);
754 _dbus_warn_return_if_fail (_DBUS_FUNCTION_NAME, "old_refcount > 0",
755 __FILE__, __LINE__);
756 return;
757 }
758 #endif
759
760 _dbus_server_trace_ref (server, old_refcount, old_refcount - 1, "unref");
761
762 if (old_refcount == 1)
763 {
764 /* lock not held! */
765 _dbus_assert (server->disconnected);
766
767 _dbus_assert (server->vtable->finalize != NULL);
768
769 (* server->vtable->finalize) (server);
770 }
771 }
772
773 void
774 _dbus_server_disconnect_unlocked (DBusServer *server)
775 {
776 _dbus_assert (server->vtable->disconnect != NULL);
777
778 if (!server->disconnected)
779 {
780 /* this has to be first so recursive calls to disconnect don't happen */
781 server->disconnected = TRUE;
782
783 (* server->vtable->disconnect) (server);
784 }
785 }
786
795 void
796 dbus_server_disconnect (DBusServer *server)
797 {
798 _dbus_return_if_fail (server != NULL);
799
800 dbus_server_ref (server);
801 SERVER_LOCK (server);
802
803 _dbus_server_disconnect_unlocked (server);
804
805 SERVER_UNLOCK (server);
806 dbus_server_unref (server);
807 }
808
814 dbus_bool_t
815 dbus_server_get_is_connected (DBusServer *server)
816 {
817 dbus_bool_t retval;
818
819 _dbus_return_val_if_fail (server != NULL, FALSE);
820
821 SERVER_LOCK (server);
822 retval = !server->disconnected;
823 SERVER_UNLOCK (server);
824
825 return retval;
826 }
827
835 char*
836 dbus_server_get_address (DBusServer *server)
837 {
838 char *retval;
839
840 _dbus_return_val_if_fail (server != NULL, NULL);
841
842 SERVER_LOCK (server);
843 retval = _dbus_strdup (server->address);
844 SERVER_UNLOCK (server);
845
846 return retval;
847 }
848
871 char*
872 dbus_server_get_id (DBusServer *server)
873 {
874 char *retval;
875
876 _dbus_return_val_if_fail (server != NULL, NULL);
877
878 SERVER_LOCK (server);
879 retval = NULL;
880 _dbus_string_copy_data (&server->guid_hex, &retval);
881 SERVER_UNLOCK (server);
882
883 return retval;
884 }
885
906 void
907 dbus_server_set_new_connection_function (DBusServer *server,
908 DBusNewConnectionFunction function,
909 void *data,
910 DBusFreeFunction free_data_function)
911 {
912 DBusFreeFunction old_free_function;
913 void *old_data;
914
915 _dbus_return_if_fail (server != NULL);
916
917 SERVER_LOCK (server);
918 old_free_function = server->new_connection_free_data_function;
919 old_data = server->new_connection_data;
920
921 server->new_connection_function = function;
922 server->new_connection_data = data;
923 server->new_connection_free_data_function = free_data_function;
924 SERVER_UNLOCK (server);
925
926 if (old_free_function != NULL)
927 (* old_free_function) (old_data);
928 }
929
946 dbus_bool_t
947 dbus_server_set_watch_functions (DBusServer *server,
948 DBusAddWatchFunction add_function,
949 DBusRemoveWatchFunction remove_function,
950 DBusWatchToggledFunction toggled_function,
951 void *data,
952 DBusFreeFunction free_data_function)
953 {
954 dbus_bool_t result;
955 DBusWatchList *watches;
956
957 _dbus_return_val_if_fail (server != NULL, FALSE);
958
959 SERVER_LOCK (server);
960 watches = server->watches;
961 server->watches = NULL;
962 if (watches)
963 {
964 SERVER_UNLOCK (server);
965 result = _dbus_watch_list_set_functions (watches,
966 add_function,
967 remove_function,
968 toggled_function,
969 data,
970 free_data_function);
971 SERVER_LOCK (server);
972 }
973 else
974 {
975 _dbus_warn_check_failed ("Re-entrant call to %s", _DBUS_FUNCTION_NAME);
976 result = FALSE;
977 }
978 server->watches = watches;
979 SERVER_UNLOCK (server);
980
981 return result;
982 }
983
999 dbus_bool_t
1000 dbus_server_set_timeout_functions (DBusServer *server,
1001 DBusAddTimeoutFunction add_function,
1002 DBusRemoveTimeoutFunction remove_function,
1003 DBusTimeoutToggledFunction toggled_function,
1004 void *data,
1005 DBusFreeFunction free_data_function)
1006 {
1007 dbus_bool_t result;
1008 DBusTimeoutList *timeouts;
1009
1010 _dbus_return_val_if_fail (server != NULL, FALSE);
1011
1012 SERVER_LOCK (server);
1013 timeouts = server->timeouts;
1014 server->timeouts = NULL;
1015 if (timeouts)
1016 {
1017 SERVER_UNLOCK (server);
1018 result = _dbus_timeout_list_set_functions (timeouts,
1019 add_function,
1020 remove_function,
1021 toggled_function,
1022 data,
1023 free_data_function);
1024 SERVER_LOCK (server);
1025 }
1026 else
1027 {
1028 _dbus_warn_check_failed ("Re-entrant call to %s", _DBUS_FUNCTION_NAME);
1029 result = FALSE;
1030 }
1031 server->timeouts = timeouts;
1032 SERVER_UNLOCK (server);
1033
1034 return result;
1035 }
1036
1050 dbus_bool_t
1051 dbus_server_set_auth_mechanisms (DBusServer *server,
1052 const char **mechanisms)
1053 {
1054 char **copy;
1055
1056 _dbus_return_val_if_fail (server != NULL, FALSE);
1057
1058 SERVER_LOCK (server);
1059
1060 if (mechanisms != NULL)
1061 {
1062 copy = _dbus_dup_string_array (mechanisms);
1063 if (copy == NULL)
1064 {
1065 SERVER_UNLOCK (server);
1066 return FALSE;
1067 }
1068 }
1069 else
1070 copy = NULL;
1071
1072 dbus_free_string_array (server->auth_mechanisms);
1073 server->auth_mechanisms = copy;
1074
1075 SERVER_UNLOCK (server);
1076
1077 return TRUE;
1078 }
1079
1080 static DBusDataSlotAllocator slot_allocator =
1081 _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (server_slots));
1082
1097 dbus_bool_t
1098 dbus_server_allocate_data_slot (dbus_int32_t *slot_p)
1099 {
1100 return _dbus_data_slot_allocator_alloc (&slot_allocator,
1101 slot_p);
1102 }
1103
1115 void
1116 dbus_server_free_data_slot (dbus_int32_t *slot_p)
1117 {
1118 _dbus_return_if_fail (*slot_p >= 0);
1119
1120 _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
1121 }
1122
1136 dbus_bool_t
1137 dbus_server_set_data (DBusServer *server,
1138 int slot,
1139 void *data,
1140 DBusFreeFunction free_data_func)
1141 {
1142 DBusFreeFunction old_free_func;
1143 void *old_data;
1144 dbus_bool_t retval;
1145
1146 _dbus_return_val_if_fail (server != NULL, FALSE);
1147
1148 SERVER_LOCK (server);
1149
1150 retval = _dbus_data_slot_list_set (&slot_allocator,
1151 &server->slot_list,
1152 slot, data, free_data_func,
1153 &old_free_func, &old_data);
1154
1155
1156 SERVER_UNLOCK (server);
1157
1158 if (retval)
1159 {
1160 /* Do the actual free outside the server lock */
1161 if (old_free_func)
1162 (* old_free_func) (old_data);
1163 }
1164
1165 return retval;
1166 }
1167
1176 void*
1177 dbus_server_get_data (DBusServer *server,
1178 int slot)
1179 {
1180 void *res;
1181
1182 _dbus_return_val_if_fail (server != NULL, NULL);
1183
1184 SERVER_LOCK (server);
1185
1186 res = _dbus_data_slot_list_get (&slot_allocator,
1187 &server->slot_list,
1188 slot);
1189
1190 SERVER_UNLOCK (server);
1191
1192 return res;
1193 }
1194
_dbus_server_init_base
dbus_bool_t _dbus_server_init_base(DBusServer *server, const DBusServerVTable *vtable, const DBusString *address, DBusError *error)
Initializes the members of the DBusServer base class.
Definition: dbus-server.c:112
_dbus_uuid_encode
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
Definition: dbus-internals.c:756
_dbus_atomic_dec
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
Definition: dbus-sysdeps-unix.c:3057
_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_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_watch_list_new
DBusWatchList * _dbus_watch_list_new(void)
Creates a new watch list.
Definition: dbus-watch.c:232
_DBUS_N_ELEMENTS
#define _DBUS_N_ELEMENTS(array)
Definition: dbus-internals.h:189
dbus_server_listen
DBusServer * dbus_server_listen(const char *address, DBusError *error)
Listens for new connections on the given address.
Definition: dbus-server.c:557
_dbus_dup_string_array
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
Definition: dbus-internals.c:640
_dbus_timeout_list_free
void _dbus_timeout_list_free(DBusTimeoutList *timeout_list)
Frees a DBusTimeoutList.
Definition: dbus-timeout.c:215
dbus_server_get_id
char * dbus_server_get_id(DBusServer *server)
Returns the unique ID of the server, as a newly-allocated string which must be freed by the caller.
Definition: dbus-server.c:872
dbus_server_unref
void dbus_server_unref(DBusServer *server)
Decrements the reference count of a DBusServer.
Definition: dbus-server.c:733
_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_I...
Definition: dbus-string.c:271
_dbus_generate_uuid
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
Definition: dbus-internals.c:720
_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
DBusTimeoutList
DBusTimeoutList implementation details.
Definition: dbus-timeout.c:181
_dbus_server_remove_watch
void _dbus_server_remove_watch(DBusServer *server, DBusWatch *watch)
Removes a watch previously added with _dbus_server_remove_watch().
Definition: dbus-server.c:312
_dbus_server_add_timeout
dbus_bool_t _dbus_server_add_timeout(DBusServer *server, DBusTimeout *timeout)
Adds a timeout for this server, chaining out to application-provided timeout handlers.
Definition: dbus-server.c:405
_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
DBusServer::vtable
const DBusServerVTable * vtable
Virtual methods for this instance.
Definition: dbus-server-protected.h:59
DBusServer
Definition: dbus-server-protected.h:57
dbus_server_get_address
char * dbus_server_get_address(DBusServer *server)
Returns the address of the server, as a newly-allocated string which must be freed by the caller.
Definition: dbus-server.c:836
DBusServerVTable::finalize
void(* finalize)(DBusServer *server)
The finalize method must free the server.
Definition: dbus-server-protected.h:45
dbus_address_entry_get_method
const char * dbus_address_entry_get_method(DBusAddressEntry *entry)
Returns the method string of an address entry.
Definition: dbus-address.c:230
_dbus_timeout_list_new
DBusTimeoutList * _dbus_timeout_list_new(void)
Creates a new timeout list.
Definition: dbus-timeout.c:198
DBusFreeFunction
void(* DBusFreeFunction)(void *memory)
Definition: dbus-memory.h:63
DBusWatch
Implementation of DBusWatch.
Definition: dbus-watch.c:41
_dbus_server_listen_socket
DBusServerListenResult _dbus_server_listen_socket(DBusAddressEntry *entry, DBusServer **server_p, DBusError *error)
Tries to interpret the address entry for various socket-related addresses (well, currently only tcp a...
Definition: dbus-server-socket.c:538
_dbus_string_copy
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
Definition: dbus-string.c:1307
_dbus_server_listen_platform_specific
DBusServerListenResult _dbus_server_listen_platform_specific(DBusAddressEntry *entry, DBusServer **server_p, DBusError *error)
Tries to interpret the address entry in a platform-specific way, creating a platform-specific server ...
Definition: dbus-server-unix.c:54
DBusServer::auth_mechanisms
char ** auth_mechanisms
Array of allowed authentication mechanisms.
Definition: dbus-server-protected.h:85
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_ERROR_ADDRESS_IN_USE
#define DBUS_ERROR_ADDRESS_IN_USE
Can't bind a socket since its address is in use (i.e.
Definition: dbus-protocol.h:391
_dbus_string_copy_data
dbus_bool_t _dbus_string_copy_data(const DBusString *str, char **data_return)
Copies the data from the string into a char*.
Definition: dbus-string.c:696
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:182
_dbus_server_add_watch
dbus_bool_t _dbus_server_add_watch(DBusServer *server, DBusWatch *watch)
Adds a watch for this server, chaining out to application-provided watch handlers.
Definition: dbus-server.c:296
DBusServer::refcount
DBusAtomic refcount
Reference count.
Definition: dbus-server-protected.h:58
dbus_int32_t
int dbus_int32_t
Definition: dbus-arch-deps.h:42
DBusServer::new_connection_function
DBusNewConnectionFunction new_connection_function
Callback to invoke when a new connection is created.
Definition: dbus-server-protected.h:76
TRUE
#define TRUE
dbus_server_free_data_slot
void dbus_server_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for server data slots.
Definition: dbus-server.c:1116
DBusWatchAddFunction
dbus_bool_t(* DBusWatchAddFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-server.c:230
_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
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_free
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:704
DBusWatchToggleFunction
void(* DBusWatchToggleFunction)(DBusWatchList *list, DBusWatch *watch, dbus_bool_t enabled)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-server.c:236
DBusServer::watches
DBusWatchList * watches
Our watches.
Definition: dbus-server-protected.h:66
_DBUS_LOCK_NAME
#define _DBUS_LOCK_NAME(name)
Definition: dbus-internals.h:411
DBUS_ERROR_BAD_ADDRESS
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
Definition: dbus-protocol.h:371
DBusString
Definition: dbus-string.h:43
dbus_server_set_data
dbus_bool_t dbus_server_set_data(DBusServer *server, int slot, void *data, DBusFreeFunction free_data_func)
Stores a pointer on a DBusServer, along with an optional function to be used for freeing the data whe...
Definition: dbus-server.c:1137
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_server_disconnect
void dbus_server_disconnect(DBusServer *server)
Releases the server's address and stops listening for new clients.
Definition: dbus-server.c:796
_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
DBusServer::published_address
dbus_bool_t published_address
flag which indicates that server has published its bus address.
Definition: dbus-server-protected.h:70
DBusServer::address
char * address
Address this server is listening on.
Definition: dbus-server-protected.h:69
DBusTimeout
Internals of DBusTimeout.
Definition: dbus-timeout.c:41
_dbus_data_slot_list_init
void _dbus_data_slot_list_init(DBusDataSlotList *list)
Initializes a slot list.
Definition: dbus-dataslot.c:198
DBusAddressEntry
Internals of DBusAddressEntry.
Definition: dbus-address.c:47
_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
FALSE
#define FALSE
DBusServer::timeouts
DBusTimeoutList * timeouts
Our timeouts.
Definition: dbus-server-protected.h:67
DBusServer::mutex
DBusRMutex * mutex
Lock on the server object.
Definition: dbus-server-protected.h:60
_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_ERROR_INIT
#define DBUS_ERROR_INIT
Definition: dbus-errors.h:62
_dbus_server_toggle_all_watches
void _dbus_server_toggle_all_watches(DBusServer *server, dbus_bool_t enabled)
Toggles all watch and notifies app via server's DBusWatchToggledFunction if available.
Definition: dbus-server.c:330
DBusNewConnectionFunction
void(* DBusNewConnectionFunction)(DBusServer *server, DBusConnection *new_connection, void *data)
Called when a new connection to the server is available.
Definition: dbus-server.h:48
dbus_error_is_set
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
Definition: dbus-errors.c:329
_dbus_assert_not_reached
#define _dbus_assert_not_reached(explanation)
Definition: dbus-internals.h:164
DBusServer::new_connection_free_data_function
DBusFreeFunction new_connection_free_data_function
Callback to invoke to free new_connection_data when server is finalized or data is replaced.
Definition: dbus-server-protected.h:80
DBusTimeoutToggleFunction
void(* DBusTimeoutToggleFunction)(DBusTimeoutList *list, DBusTimeout *timeout, dbus_bool_t enabled)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-server.c:343
DBusTimeoutAddFunction
dbus_bool_t(* DBusTimeoutAddFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-server.c:337
_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
DBusWatchList
DBusWatchList implementation details.
Definition: dbus-watch.c:215
_dbus_server_toggle_timeout
void _dbus_server_toggle_timeout(DBusServer *server, DBusTimeout *timeout, dbus_bool_t enabled)
Toggles a timeout and notifies app via server's DBusTimeoutToggledFunction if available.
Definition: dbus-server.c:439
DBusWatchRemoveFunction
void(* DBusWatchRemoveFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
Definition: dbus-server.c:233
dbus_server_allocate_data_slot
dbus_bool_t dbus_server_allocate_data_slot(dbus_int32_t *slot_p)
Allocates an integer ID to be used for storing application-specific data on any DBusServer.
Definition: dbus-server.c:1098
dbus_server_set_new_connection_function
void dbus_server_set_new_connection_function(DBusServer *server, DBusNewConnectionFunction function, void *data, DBusFreeFunction free_data_function)
Sets a function to be used for handling new connections.
Definition: dbus-server.c:907
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_assert
#define _dbus_assert(condition)
Definition: dbus-internals.h:153
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
DBusServerVTable
Virtual table to be implemented by all server "subclasses".
Definition: dbus-server-protected.h:44
dbus_server_ref
DBusServer * dbus_server_ref(DBusServer *server)
Increments the reference count of a DBusServer.
Definition: dbus-server.c:701
_dbus_strdup
char * _dbus_strdup(const char *str)
Duplicates a string.
Definition: dbus-internals.c:589
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_watch_list_free
void _dbus_watch_list_free(DBusWatchList *watch_list)
Frees a DBusWatchList.
Definition: dbus-watch.c:249
_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
DBusServer::slot_list
DBusDataSlotList slot_list
Data stored by allocated integer ID.
Definition: dbus-server-protected.h:74
DBusError
Object representing an exception.
Definition: dbus-errors.h:49
DBusDataSlotAllocator
An allocator that tracks a set of slot IDs.
Definition: dbus-dataslot.h:56
DBusServer::guid_hex
DBusString guid_hex
Hex-encoded version of GUID.
Definition: dbus-server-protected.h:64
_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
DBusServer::guid
DBusGUID guid
Globally unique ID of server.
Definition: dbus-server-protected.h:62
_dbus_server_unref_unlocked
void _dbus_server_unref_unlocked(DBusServer *server)
Like dbus_server_unref() but does not acquire the lock (must already be held)
Definition: dbus-server.c:475
_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_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_watch_list_toggle_all_watches
void _dbus_watch_list_toggle_all_watches(DBusWatchList *watch_list, dbus_bool_t enabled)
Sets all watches to the given enabled state, invoking the application's DBusWatchToggledFunction if a...
Definition: dbus-watch.c:472
dbus_free_string_array
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:752
DBusServer::have_server_lock
unsigned int have_server_lock
Does someone have the server mutex locked.
Definition: dbus-server-protected.h:90
_dbus_string_steal_data
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
Definition: dbus-string.c:665
_dbus_server_remove_timeout
void _dbus_server_remove_timeout(DBusServer *server, DBusTimeout *timeout)
Removes a timeout previously added with _dbus_server_add_timeout().
Definition: dbus-server.c:420
_dbus_server_finalize_base
void _dbus_server_finalize_base(DBusServer *server)
Finalizes the members of the DBusServer base class.
Definition: dbus-server.c:201
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_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
DBusServer::new_connection_data
void * new_connection_data
Data for new connection callback.
Definition: dbus-server-protected.h:78
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
_dbus_atomic_inc
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
Definition: dbus-sysdeps-unix.c:3034
dbus_server_get_is_connected
dbus_bool_t dbus_server_get_is_connected(DBusServer *server)
Returns TRUE if the server is still listening for new connections.
Definition: dbus-server.c:815
dbus_server_get_data
void * dbus_server_get_data(DBusServer *server, int slot)
Retrieves data previously set with dbus_server_set_data().
Definition: dbus-server.c:1177
_dbus_server_ref_unlocked
void _dbus_server_ref_unlocked(DBusServer *server)
Like dbus_server_ref() but does not acquire the lock (must already be held)
Definition: dbus-server.c:456
DBusServerVTable::disconnect
void(* disconnect)(DBusServer *server)
Disconnect this server.
Definition: dbus-server-protected.h:48
DBusServer::disconnected
unsigned int disconnected
TRUE if we are disconnected.
Definition: dbus-server-protected.h:87
_dbus_string_append
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
Definition: dbus-string.c:959
_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
_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
DBusTimeoutRemoveFunction
void(* DBusTimeoutRemoveFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.
Definition: dbus-server.c:340
dbus_server_set_watch_functions
dbus_bool_t dbus_server_set_watch_functions(DBusServer *server, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the watch functions for the server.
Definition: dbus-server.c:947
dbus_server_set_timeout_functions
dbus_bool_t dbus_server_set_timeout_functions(DBusServer *server, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
Sets the timeout functions for the server.
Definition: dbus-server.c:1000
_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_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_bool_t
dbus_uint32_t dbus_bool_t
Definition: dbus-types.h:35
dbus_server_set_auth_mechanisms
dbus_bool_t dbus_server_set_auth_mechanisms(DBusServer *server, const char **mechanisms)
Sets the authentication mechanisms that this server offers to clients, as a NULL-terminated array of ...
Definition: dbus-server.c:1051
NULL
#define NULL