D-Bus  1.10.24
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 
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 
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 
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:
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  {
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
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... */
213 
215 
216  _dbus_watch_list_free (server->watches);
218 
220 
221  dbus_free (server->address);
222 
224 
225  _dbus_string_free (&server->guid_hex);
226 }
227 
228 
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;
281 
282  return retval;
283  }
284  else
285  return FALSE;
286 }
287 
297  DBusWatch *watch)
298 {
299  HAVE_LOCK_CHECK (server);
300  return protected_change_watch (server, watch,
302  NULL, NULL, FALSE);
303 }
304 
311 void
313  DBusWatch *watch)
314 {
315  HAVE_LOCK_CHECK (server);
316  protected_change_watch (server, watch,
317  NULL,
319  NULL, FALSE);
320 }
321 
329 void
331  dbus_bool_t enabled)
332 {
333  _dbus_watch_list_toggle_all_watches (server->watches, enabled);
334 }
335 
338  DBusTimeout *timeout);
341  DBusTimeout *timeout);
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;
388 
389  return retval;
390  }
391  else
392  return FALSE;
393 }
394 
406  DBusTimeout *timeout)
407 {
408  return protected_change_timeout (server, timeout,
410  NULL, NULL, FALSE);
411 }
412 
419 void
421  DBusTimeout *timeout)
422 {
423  protected_change_timeout (server, timeout,
424  NULL,
426  NULL, FALSE);
427 }
428 
438 void
440  DBusTimeout *timeout,
441  dbus_bool_t enabled)
442 {
443  protected_change_timeout (server, timeout,
444  NULL, NULL,
446  enabled);
447 }
448 
449 
455 void
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
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[] = {
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_set_error (error,
600  "Address '%s' already used",
601  dbus_address_entry_get_method (entries[0]));
602  handled_once = TRUE;
603  goto out;
604  }
605  else if (result == DBUS_SERVER_LISTEN_BAD_ADDRESS)
606  {
607  _dbus_assert (server == NULL);
608  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
609  dbus_move_error (&tmp_error, error);
610  handled_once = TRUE;
611  goto out;
612  }
613  else if (result == DBUS_SERVER_LISTEN_NOT_HANDLED)
614  {
615  _dbus_assert (server == NULL);
616  _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
617 
618  /* keep trying addresses */
619  }
620  else if (result == DBUS_SERVER_LISTEN_DID_NOT_CONNECT)
621  {
622  _dbus_assert (server == NULL);
623  _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
624  if (!dbus_error_is_set (&first_connect_error))
625  dbus_move_error (&tmp_error, &first_connect_error);
626  else
627  dbus_error_free (&tmp_error);
628 
629  handled_once = TRUE;
630 
631  /* keep trying addresses */
632  }
633  }
634 
635  _dbus_assert (server == NULL);
636  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
637  }
638 
639  out:
640 
641  if (!handled_once)
642  {
643  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
644  if (len > 0)
645  dbus_set_error (error,
647  "Unknown address type '%s'",
648  dbus_address_entry_get_method (entries[0]));
649  else
650  dbus_set_error (error,
652  "Empty address '%s'",
653  address);
654  }
655 
656  dbus_address_entries_free (entries);
657 
658  if (server == NULL)
659  {
660  _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error) ||
661  dbus_error_is_set (error));
662 
663  if (error && dbus_error_is_set (error))
664  {
665  /* already set the error */
666  }
667  else
668  {
669  /* didn't set the error but either error should be
670  * NULL or first_connect_error should be set.
671  */
672  _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error));
673  dbus_move_error (&first_connect_error, error);
674  }
675 
676  _DBUS_ASSERT_ERROR_IS_CLEAR (&first_connect_error); /* be sure we freed it */
677  _DBUS_ASSERT_ERROR_IS_SET (error);
678 
679  return NULL;
680  }
681  else
682  {
683  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
684  return server;
685  }
686 }
687 
694 DBusServer *
696 {
697  dbus_int32_t old_refcount;
698 
699  _dbus_return_val_if_fail (server != NULL, NULL);
700 
701  old_refcount = _dbus_atomic_inc (&server->refcount);
702 
703 #ifndef DBUS_DISABLE_CHECKS
704  if (_DBUS_UNLIKELY (old_refcount <= 0))
705  {
706  _dbus_atomic_dec (&server->refcount);
708  _DBUS_FUNCTION_NAME, "old_refcount > 0",
709  __FILE__, __LINE__);
710  return NULL;
711  }
712 #endif
713 
714  _dbus_server_trace_ref (server, old_refcount, old_refcount + 1, "ref");
715 
716  return server;
717 }
718 
727 void
729 {
730  dbus_int32_t old_refcount;
731 
732  /* keep this in sync with unref_unlocked */
733 
734  _dbus_return_if_fail (server != NULL);
735 
736  old_refcount = _dbus_atomic_dec (&server->refcount);
737 
738 #ifndef DBUS_DISABLE_CHECKS
739  if (_DBUS_UNLIKELY (old_refcount <= 0))
740  {
741  /* undo side-effect first
742  * please do not try to simplify the code here by using
743  * _dbus_atomic_get(), why we don't use it is
744  * because it issues another atomic operation even though
745  * DBUS_DISABLE_CHECKS defined.
746  * Bug: https://bugs.freedesktop.org/show_bug.cgi?id=68303
747  */
748  _dbus_atomic_inc (&server->refcount);
750  _DBUS_FUNCTION_NAME, "old_refcount > 0",
751  __FILE__, __LINE__);
752  return;
753  }
754 #endif
755 
756  _dbus_server_trace_ref (server, old_refcount, old_refcount - 1, "unref");
757 
758  if (old_refcount == 1)
759  {
760  /* lock not held! */
761  _dbus_assert (server->disconnected);
762 
763  _dbus_assert (server->vtable->finalize != NULL);
764 
765  (* server->vtable->finalize) (server);
766  }
767 }
768 
777 void
779 {
780  _dbus_return_if_fail (server != NULL);
781 
782  dbus_server_ref (server);
783  SERVER_LOCK (server);
784 
785  _dbus_assert (server->vtable->disconnect != NULL);
786 
787  if (!server->disconnected)
788  {
789  /* this has to be first so recursive calls to disconnect don't happen */
790  server->disconnected = TRUE;
791 
792  (* server->vtable->disconnect) (server);
793  }
794 
795  SERVER_UNLOCK (server);
796  dbus_server_unref (server);
797 }
798 
806 {
807  dbus_bool_t retval;
808 
809  _dbus_return_val_if_fail (server != NULL, FALSE);
810 
811  SERVER_LOCK (server);
812  retval = !server->disconnected;
813  SERVER_UNLOCK (server);
814 
815  return retval;
816 }
817 
825 char*
827 {
828  char *retval;
829 
830  _dbus_return_val_if_fail (server != NULL, NULL);
831 
832  SERVER_LOCK (server);
833  retval = _dbus_strdup (server->address);
834  SERVER_UNLOCK (server);
835 
836  return retval;
837 }
838 
861 char*
863 {
864  char *retval;
865 
866  _dbus_return_val_if_fail (server != NULL, NULL);
867 
868  SERVER_LOCK (server);
869  retval = NULL;
870  _dbus_string_copy_data (&server->guid_hex, &retval);
871  SERVER_UNLOCK (server);
872 
873  return retval;
874 }
875 
896 void
898  DBusNewConnectionFunction function,
899  void *data,
900  DBusFreeFunction free_data_function)
901 {
902  DBusFreeFunction old_free_function;
903  void *old_data;
904 
905  _dbus_return_if_fail (server != NULL);
906 
907  SERVER_LOCK (server);
908  old_free_function = server->new_connection_free_data_function;
909  old_data = server->new_connection_data;
910 
911  server->new_connection_function = function;
912  server->new_connection_data = data;
913  server->new_connection_free_data_function = free_data_function;
914  SERVER_UNLOCK (server);
915 
916  if (old_free_function != NULL)
917  (* old_free_function) (old_data);
918 }
919 
938  DBusAddWatchFunction add_function,
939  DBusRemoveWatchFunction remove_function,
940  DBusWatchToggledFunction toggled_function,
941  void *data,
942  DBusFreeFunction free_data_function)
943 {
944  dbus_bool_t result;
945  DBusWatchList *watches;
946 
947  _dbus_return_val_if_fail (server != NULL, FALSE);
948 
949  SERVER_LOCK (server);
950  watches = server->watches;
951  server->watches = NULL;
952  if (watches)
953  {
954  SERVER_UNLOCK (server);
955  result = _dbus_watch_list_set_functions (watches,
956  add_function,
957  remove_function,
958  toggled_function,
959  data,
960  free_data_function);
961  SERVER_LOCK (server);
962  }
963  else
964  {
965  _dbus_warn_check_failed ("Re-entrant call to %s\n", _DBUS_FUNCTION_NAME);
966  result = FALSE;
967  }
968  server->watches = watches;
969  SERVER_UNLOCK (server);
970 
971  return result;
972 }
973 
991  DBusAddTimeoutFunction add_function,
992  DBusRemoveTimeoutFunction remove_function,
993  DBusTimeoutToggledFunction toggled_function,
994  void *data,
995  DBusFreeFunction free_data_function)
996 {
997  dbus_bool_t result;
998  DBusTimeoutList *timeouts;
999 
1000  _dbus_return_val_if_fail (server != NULL, FALSE);
1001 
1002  SERVER_LOCK (server);
1003  timeouts = server->timeouts;
1004  server->timeouts = NULL;
1005  if (timeouts)
1006  {
1007  SERVER_UNLOCK (server);
1008  result = _dbus_timeout_list_set_functions (timeouts,
1009  add_function,
1010  remove_function,
1011  toggled_function,
1012  data,
1013  free_data_function);
1014  SERVER_LOCK (server);
1015  }
1016  else
1017  {
1018  _dbus_warn_check_failed ("Re-entrant call to %s\n", _DBUS_FUNCTION_NAME);
1019  result = FALSE;
1020  }
1021  server->timeouts = timeouts;
1022  SERVER_UNLOCK (server);
1023 
1024  return result;
1025 }
1026 
1042  const char **mechanisms)
1043 {
1044  char **copy;
1045 
1046  _dbus_return_val_if_fail (server != NULL, FALSE);
1047 
1048  SERVER_LOCK (server);
1049 
1050  if (mechanisms != NULL)
1051  {
1052  copy = _dbus_dup_string_array (mechanisms);
1053  if (copy == NULL)
1054  {
1055  SERVER_UNLOCK (server);
1056  return FALSE;
1057  }
1058  }
1059  else
1060  copy = NULL;
1061 
1063  server->auth_mechanisms = copy;
1064 
1065  SERVER_UNLOCK (server);
1066 
1067  return TRUE;
1068 }
1069 
1070 static DBusDataSlotAllocator slot_allocator =
1071  _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (server_slots));
1072 
1088 dbus_server_allocate_data_slot (dbus_int32_t *slot_p)
1089 {
1090  return _dbus_data_slot_allocator_alloc (&slot_allocator,
1091  slot_p);
1092 }
1093 
1105 void
1106 dbus_server_free_data_slot (dbus_int32_t *slot_p)
1107 {
1108  _dbus_return_if_fail (*slot_p >= 0);
1109 
1110  _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
1111 }
1112 
1128  int slot,
1129  void *data,
1130  DBusFreeFunction free_data_func)
1131 {
1132  DBusFreeFunction old_free_func;
1133  void *old_data;
1134  dbus_bool_t retval;
1135 
1136  _dbus_return_val_if_fail (server != NULL, FALSE);
1137 
1138  SERVER_LOCK (server);
1139 
1140  retval = _dbus_data_slot_list_set (&slot_allocator,
1141  &server->slot_list,
1142  slot, data, free_data_func,
1143  &old_free_func, &old_data);
1144 
1145 
1146  SERVER_UNLOCK (server);
1147 
1148  if (retval)
1149  {
1150  /* Do the actual free outside the server lock */
1151  if (old_free_func)
1152  (* old_free_func) (old_data);
1153  }
1154 
1155  return retval;
1156 }
1157 
1166 void*
1168  int slot)
1169 {
1170  void *res;
1171 
1172  _dbus_return_val_if_fail (server != NULL, NULL);
1173 
1174  SERVER_LOCK (server);
1175 
1176  res = _dbus_data_slot_list_get (&slot_allocator,
1177  &server->slot_list,
1178  slot);
1179 
1180  SERVER_UNLOCK (server);
1181 
1182  return res;
1183 }
1184 
1187 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
1188 #include "dbus-test.h"
1189 #include <string.h>
1190 
1192 _dbus_server_test (void)
1193 {
1194  const char *valid_addresses[] = {
1195  "tcp:port=1234",
1196  "tcp:host=localhost,port=1234",
1197  "tcp:host=localhost,port=1234;tcp:port=5678",
1198 #ifdef DBUS_UNIX
1199  "unix:path=./boogie",
1200  "tcp:port=1234;unix:path=./boogie",
1201 #endif
1202  };
1203 
1204  DBusServer *server;
1205  int i;
1206 
1207  for (i = 0; i < _DBUS_N_ELEMENTS (valid_addresses); i++)
1208  {
1209  DBusError error = DBUS_ERROR_INIT;
1210  char *address;
1211  char *id;
1212 
1213  server = dbus_server_listen (valid_addresses[i], &error);
1214  if (server == NULL)
1215  {
1216  _dbus_warn ("server listen error: %s: %s\n", error.name, error.message);
1217  dbus_error_free (&error);
1218  _dbus_assert_not_reached ("Failed to listen for valid address.");
1219  }
1220 
1221  id = dbus_server_get_id (server);
1222  _dbus_assert (id != NULL);
1223  address = dbus_server_get_address (server);
1224  _dbus_assert (address != NULL);
1225 
1226  if (strstr (address, id) == NULL)
1227  {
1228  _dbus_warn ("server id '%s' is not in the server address '%s'\n",
1229  id, address);
1230  _dbus_assert_not_reached ("bad server id or address");
1231  }
1232 
1233  dbus_free (id);
1234  dbus_free (address);
1235 
1236  dbus_server_disconnect (server);
1237  dbus_server_unref (server);
1238  }
1239 
1240  return TRUE;
1241 }
1242 
1243 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
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:935
Internals of DBusTimeout.
Definition: dbus-timeout.c:40
void dbus_server_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for server data slots.
Definition: dbus-server.c:1106
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
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
void(* DBusTimeoutToggledFunction)(DBusTimeout *timeout, void *data)
Called when dbus_timeout_get_enabled() may return a different value than it did before.
const char * message
public error message field
Definition: dbus-errors.h:51
Implementation of DBusWatch.
Definition: dbus-watch.c:40
#define NULL
A null pointer, defined appropriately for C or C++.
void(* DBusFreeFunction)(void *memory)
The type of a function which frees a block of memory.
Definition: dbus-memory.h:64
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:239
void(* DBusRemoveWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus no longer needs a watch to be monitored by the main loop.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:701
unsigned int disconnected
TRUE if we are disconnected.
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:1127
dbus_bool_t(* DBusWatchAddFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
void _dbus_timeout_list_free(DBusTimeoutList *timeout_list)
Frees a DBusTimeoutList.
Definition: dbus-timeout.c:211
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
Internals of DBusServer object.
const char * _dbus_return_if_fail_warning_format
String used in _dbus_return_if_fail macro.
DBusTimeoutList * _dbus_timeout_list_new(void)
Creates a new timeout list.
Definition: dbus-timeout.c:194
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
const char * dbus_address_entry_get_method(DBusAddressEntry *entry)
Returns the method string of an address entry.
Definition: dbus-address.c:227
void _dbus_warn_check_failed(const char *format,...)
Prints a &quot;critical&quot; warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
void dbus_error_free(DBusError *error)
Frees an error that&#39;s been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
void _dbus_watch_list_free(DBusWatchList *watch_list)
Frees a DBusWatchList.
Definition: dbus-watch.c:249
void dbus_address_entries_free(DBusAddressEntry **entries)
Frees a NULL-terminated array of address entries.
Definition: dbus-address.c:189
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:53
DBusWatchList * _dbus_watch_list_new(void)
Creates a new watch list.
Definition: dbus-watch.c:232
void(* DBusTimeoutToggleFunction)(DBusTimeoutList *list, DBusTimeout *timeout, dbus_bool_t enabled)
Function to be called in protected_change_timeout() with refcount held.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
void(* DBusWatchRemoveFunction)(DBusWatchList *list, DBusWatch *watch)
Function to be called in protected_change_watch() with refcount held.
DBUS_PRIVATE_EXPORT 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
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&#39;s copied to the d...
Definition: dbus-string.c:1283
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 ...
DBusNewConnectionFunction new_connection_function
Callback to invoke when a new connection is created.
char ** auth_mechanisms
Array of allowed authentication mechanisms.
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:296
const DBusServerVTable * vtable
Virtual methods for this instance.
void(* disconnect)(DBusServer *server)
Disconnect this server.
dbus_bool_t(* DBusAddWatchFunction)(DBusWatch *watch, void *data)
Called when libdbus needs a new watch to be monitored by the main loop.
DBusRMutex * mutex
Lock on the server object.
DBusServer * dbus_server_listen(const char *address, DBusError *error)
Listens for new connections on the given address.
Definition: dbus-server.c:557
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:310
void _dbus_server_toggle_timeout(DBusServer *server, DBusTimeout *timeout, dbus_bool_t enabled)
Toggles a timeout and notifies app via server&#39;s DBusTimeoutToggledFunction if available.
Definition: dbus-server.c:439
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:672
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
DBUS_PRIVATE_EXPORT 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
DBusAtomic refcount
Reference count.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
dbus_bool_t(* DBusAddTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus needs a new timeout to be monitored by the main loop.
DBusTimeoutList * timeouts
Our timeouts.
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
DBusServer * dbus_server_ref(DBusServer *server)
Increments the reference count of a DBusServer.
Definition: dbus-server.c:695
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...
Internals of DBusAddressEntry.
Definition: dbus-address.c:43
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&#39;s DBusWatchToggledFunction if a...
Definition: dbus-watch.c:473
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_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:1088
Object representing an exception.
Definition: dbus-errors.h:48
void(* finalize)(DBusServer *server)
The finalize method must free the server.
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:897
#define DBUS_ERROR_BAD_ADDRESS
A D-Bus bus address was malformed.
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
void * dbus_server_get_data(DBusServer *server, int slot)
Retrieves data previously set with dbus_server_set_data().
Definition: dbus-server.c:1167
void dbus_server_disconnect(DBusServer *server)
Releases the server&#39;s address and stops listening for new clients.
Definition: dbus-server.c:778
void _dbus_server_remove_timeout(DBusServer *server, DBusTimeout *timeout)
Removes a timeout previously added with _dbus_server_add_timeout().
Definition: dbus-server.c:420
void _dbus_server_finalize_base(DBusServer *server)
Finalizes the members of the DBusServer base class.
Definition: dbus-server.c:201
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
Virtual table to be implemented by all server &quot;subclasses&quot;.
DBusWatchList * watches
Our watches.
void dbus_server_unref(DBusServer *server)
Decrements the reference count of a DBusServer.
Definition: dbus-server.c:728
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&#39;s DBusTimeoutToggledFunction if a...
Definition: dbus-timeout.c:362
void(* DBusWatchToggleFunction)(DBusWatchList *list, DBusWatch *watch, dbus_bool_t enabled)
Function to be called in protected_change_watch() with refcount held.
#define DBUS_ERROR_ADDRESS_IN_USE
Can&#39;t bind a socket since its address is in use (i.e.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
DBusDataSlotList slot_list
Data stored by allocated integer ID.
void * _dbus_data_slot_list_get(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot)
Retrieves data previously set with _dbus_data_slot_list_set_data().
#define TRUE
Expands to &quot;1&quot;.
void _dbus_data_slot_list_init(DBusDataSlotList *list)
Initializes a slot list.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
char * address
Address this server is listening on.
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:382
dbus_bool_t published_address
flag which indicates that server has published its bus address.
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
Definition: dbus-errors.c:279
const char * name
public error name field
Definition: dbus-errors.h:50
void(* DBusTimeoutRemoveFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.
DBusFreeFunction new_connection_free_data_function
Callback to invoke to free new_connection_data when server is finalized or data is replaced...
DBusWatchList implementation details.
Definition: dbus-watch.c:214
void * new_connection_data
Data for new connection callback.
An allocator that tracks a set of slot IDs.
Definition: dbus-dataslot.h:55
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:1041
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:805
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...
void _dbus_watch_list_remove_watch(DBusWatchList *watch_list, DBusWatch *watch)
Removes a watch from the watch list, invoking the application&#39;s DBusRemoveWatchFunction if appropriat...
Definition: dbus-watch.c:415
void _dbus_timeout_list_remove_timeout(DBusTimeoutList *timeout_list, DBusTimeout *timeout)
Removes a timeout from the timeout list, invoking the application&#39;s DBusRemoveTimeoutFunction if appr...
Definition: dbus-timeout.c:340
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
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
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:749
void _dbus_rmutex_free_at_location(DBusRMutex **location_p)
Frees a DBusRMutex; does nothing if passed a NULL pointer.
Definition: dbus-threads.c:94
unsigned int have_server_lock
Does someone have the server mutex locked.
DBusString guid_hex
Hex-encoded version of GUID.
#define FALSE
Expands to &quot;0&quot;.
DBUS_PRIVATE_EXPORT void _dbus_server_toggle_all_watches(DBusServer *server, dbus_bool_t enabled)
Toggles all watch and notifies app via server&#39;s DBusWatchToggledFunction if available.
Definition: dbus-server.c:330
dbus_bool_t dbus_parse_address(const char *address, DBusAddressEntry ***entry, int *array_len, DBusError *error)
Parses an address string of the form:
Definition: dbus-address.c:363
#define _DBUS_LOCK_NAME(name)
Expands to name of a global lock variable.
void(* DBusWatchToggledFunction)(DBusWatch *watch, void *data)
Called when dbus_watch_get_enabled() may return a different value than it did before.
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:826
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:641
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:937
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:990
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_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:69
char * _dbus_strdup(const char *str)
Duplicates a string.
DBusGUID guid
Globally unique ID of server.
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().
void(* DBusNewConnectionFunction)(DBusServer *server, DBusConnection *new_connection, void *data)
Called when a new connection to the server is available.
Definition: dbus-server.h:47
void(* DBusRemoveTimeoutFunction)(DBusTimeout *timeout, void *data)
Called when libdbus no longer needs a timeout to be monitored by the main loop.
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
Definition: dbus-errors.c:329
DBusTimeoutList implementation details.
Definition: dbus-timeout.c:176
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:862
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...
dbus_bool_t(* DBusTimeoutAddFunction)(DBusTimeoutList *list, DBusTimeout *timeout)
Function to be called in protected_change_timeout() with refcount held.