D-Bus: dbus-internals.c Source File

D-Bus 1.8.16

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List

dbus-internals.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-internals.c random utility stuff (internal to D-Bus implementation)
3 *
4 * Copyright (C) 2002, 2003 Red Hat, Inc.
5 *
6 * Licensed under the Academic Free License version 2.1
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 */
23
24 #include <config.h>
25 #include "dbus-internals.h"
26 #include "dbus-protocol.h"
27 #include "dbus-marshal-basic.h"
28 #include "dbus-test.h"
29 #include "dbus-valgrind-internal.h"
30 #include <stdio.h>
31 #include <stdarg.h>
32 #include <string.h>
33 #include <stdlib.h>
34 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
35 #include <windows.h>
36 #include <mbstring.h>
37 #endif
38
184 const char *_dbus_no_memory_message = "Not enough memory";
185
186 static dbus_bool_t warn_initted = FALSE;
187 static dbus_bool_t fatal_warnings = FALSE;
188 static dbus_bool_t fatal_warnings_on_check_failed = TRUE;
189
190 static void
191 init_warnings(void)
192 {
193 if (!warn_initted)
194 {
195 const char *s;
196 s = _dbus_getenv ("DBUS_FATAL_WARNINGS");
197 if (s && *s)
198 {
199 if (*s == '0')
200 {
201 fatal_warnings = FALSE;
202 fatal_warnings_on_check_failed = FALSE;
203 }
204 else if (*s == '1')
205 {
206 fatal_warnings = TRUE;
207 fatal_warnings_on_check_failed = TRUE;
208 }
209 else
210 {
211 fprintf(stderr, "DBUS_FATAL_WARNINGS should be set to 0 or 1 if set, not '%s'",
212 s);
213 }
214 }
215
216 warn_initted = TRUE;
217 }
218 }
219
229 void
230 _dbus_warn (const char *format,
231 ...)
232 {
233 va_list args;
234
235 if (!warn_initted)
236 init_warnings ();
237
238 va_start (args, format);
239 vfprintf (stderr, format, args);
240 va_end (args);
241
242 if (fatal_warnings)
243 {
244 fflush (stderr);
245 _dbus_abort ();
246 }
247 }
248
257 void
258 _dbus_warn_check_failed(const char *format,
259 ...)
260 {
261 va_list args;
262
263 if (!warn_initted)
264 init_warnings ();
265
266 fprintf (stderr, "process %lu: ", _dbus_pid_for_log ());
267
268 va_start (args, format);
269 vfprintf (stderr, format, args);
270 va_end (args);
271
272 if (fatal_warnings_on_check_failed)
273 {
274 fflush (stderr);
275 _dbus_abort ();
276 }
277 }
278
279 #ifdef DBUS_ENABLE_VERBOSE_MODE
280
281 static dbus_bool_t verbose_initted = FALSE;
282 static dbus_bool_t verbose = TRUE;
283
285 #define PTHREAD_IN_VERBOSE 0
286 #if PTHREAD_IN_VERBOSE
287 #include <pthread.h>
288 #endif
289
290 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
291 static char module_name[1024];
292 #endif
293
294 static inline void
295 _dbus_verbose_init (void)
296 {
297 if (!verbose_initted)
298 {
299 const char *p = _dbus_getenv ("DBUS_VERBOSE");
300 verbose = p != NULL && *p == '1';
301 verbose_initted = TRUE;
302 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
303 {
304 char *last_period, *last_slash;
305 GetModuleFileName(0,module_name,sizeof(module_name)-1);
306 last_period = _mbsrchr(module_name,'.');
307 if (last_period)
308 *last_period ='\0';
309 last_slash = _mbsrchr(module_name,'\\');
310 if (last_slash)
311 strcpy(module_name,last_slash+1);
312 strcat(module_name,": ");
313 }
314 #endif
315 }
316 }
317
323 #ifdef DBUS_WIN
324 #define DBUS_IS_DIR_SEPARATOR(c) (c == '\\' || c == '/')
325 #else
326 #define DBUS_IS_DIR_SEPARATOR(c) (c == '/')
327 #endif
328
333 static char *_dbus_file_path_extract_elements_from_tail(const char *file,int level)
334 {
335 int prefix = 0;
336 char *p = (char *)file + strlen(file);
337 int i = 0;
338
339 for (;p >= file;p--)
340 {
341 if (DBUS_IS_DIR_SEPARATOR(*p))
342 {
343 if (++i >= level)
344 {
345 prefix = p-file+1;
346 break;
347 }
348 }
349 }
350
351 return (char *)file+prefix;
352 }
353
359 dbus_bool_t
360 _dbus_is_verbose_real (void)
361 {
362 _dbus_verbose_init ();
363 return verbose;
364 }
365
374 void
375 _dbus_verbose_real (
376 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
377 const char *file,
378 const int line,
379 const char *function,
380 #endif
381 const char *format,
382 ...)
383 {
384 va_list args;
385 static dbus_bool_t need_pid = TRUE;
386 int len;
387
388 /* things are written a bit oddly here so that
389 * in the non-verbose case we just have the one
390 * conditional and return immediately.
391 */
392 if (!_dbus_is_verbose_real())
393 return;
394
395 #ifndef DBUS_USE_OUTPUT_DEBUG_STRING
396 /* Print out pid before the line */
397 if (need_pid)
398 {
399 #if PTHREAD_IN_VERBOSE
400 fprintf (stderr, "%lu: 0x%lx: ", _dbus_pid_for_log (), pthread_self ());
401 #else
402 fprintf (stderr, "%lu: ", _dbus_pid_for_log ());
403 #endif
404 }
405 #endif
406
407 /* Only print pid again if the next line is a new line */
408 len = strlen (format);
409 if (format[len-1] == '\n')
410 need_pid = TRUE;
411 else
412 need_pid = FALSE;
413
414 va_start (args, format);
415 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
416 {
417 char buf[1024];
418 strcpy(buf,module_name);
419 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
420 sprintf (buf+strlen(buf), "[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,function);
421 #endif
422 vsprintf (buf+strlen(buf),format, args);
423 va_end (args);
424 OutputDebugStringA(buf);
425 }
426 #else
427 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
428 fprintf (stderr, "[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,function);
429 #endif
430
431 vfprintf (stderr, format, args);
432 va_end (args);
433
434 fflush (stderr);
435 #endif
436 }
437
444 void
445 _dbus_verbose_reset_real (void)
446 {
447 verbose_initted = FALSE;
448 }
449
450 void
451 _dbus_trace_ref (const char *obj_name,
452 void *obj,
453 int old_refcount,
454 int new_refcount,
455 const char *why,
456 const char *env_var,
457 int *enabled)
458 {
459 _dbus_assert (obj_name != NULL);
460 _dbus_assert (obj != NULL);
461 _dbus_assert (old_refcount >= -1);
462 _dbus_assert (new_refcount >= -1);
463
464 if (old_refcount == -1)
465 {
466 _dbus_assert (new_refcount == -1);
467 }
468 else
469 {
470 _dbus_assert (new_refcount >= 0);
471 _dbus_assert (old_refcount >= 0);
472 _dbus_assert (old_refcount > 0 || new_refcount > 0);
473 }
474
475 _dbus_assert (why != NULL);
476 _dbus_assert (env_var != NULL);
477 _dbus_assert (enabled != NULL);
478
479 if (*enabled < 0)
480 {
481 const char *s = _dbus_getenv (env_var);
482
483 *enabled = FALSE;
484
485 if (s && *s)
486 {
487 if (*s == '0')
488 *enabled = FALSE;
489 else if (*s == '1')
490 *enabled = TRUE;
491 else
492 _dbus_warn ("%s should be 0 or 1 if set, not '%s'", env_var, s);
493 }
494 }
495
496 if (*enabled)
497 {
498 if (old_refcount == -1)
499 {
500 VALGRIND_PRINTF_BACKTRACE ("%s %p ref stolen (%s)",
501 obj_name, obj, why);
502 _dbus_verbose ("%s %p ref stolen (%s)",
503 obj_name, obj, why);
504 }
505 else
506 {
507 VALGRIND_PRINTF_BACKTRACE ("%s %p %d -> %d refs (%s)",
508 obj_name, obj,
509 old_refcount, new_refcount, why);
510 _dbus_verbose ("%s %p %d -> %d refs (%s)",
511 obj_name, obj, old_refcount, new_refcount, why);
512 }
513 }
514 }
515
516 #endif /* DBUS_ENABLE_VERBOSE_MODE */
517
526 char*
527 _dbus_strdup (const char *str)
528 {
529 size_t len;
530 char *copy;
531
532 if (str == NULL)
533 return NULL;
534
535 len = strlen (str);
536
537 copy = dbus_malloc (len + 1);
538 if (copy == NULL)
539 return NULL;
540
541 memcpy (copy, str, len + 1);
542
543 return copy;
544 }
545
554 void*
555 _dbus_memdup (const void *mem,
556 size_t n_bytes)
557 {
558 void *copy;
559
560 copy = dbus_malloc (n_bytes);
561 if (copy == NULL)
562 return NULL;
563
564 memcpy (copy, mem, n_bytes);
565
566 return copy;
567 }
568
577 char**
578 _dbus_dup_string_array (const char **array)
579 {
580 int len;
581 int i;
582 char **copy;
583
584 if (array == NULL)
585 return NULL;
586
587 for (len = 0; array[len] != NULL; ++len)
588 ;
589
590 copy = dbus_new0 (char*, len + 1);
591 if (copy == NULL)
592 return NULL;
593
594 i = 0;
595 while (i < len)
596 {
597 copy[i] = _dbus_strdup (array[i]);
598 if (copy[i] == NULL)
599 {
600 dbus_free_string_array (copy);
601 return NULL;
602 }
603
604 ++i;
605 }
606
607 return copy;
608 }
609
617 dbus_bool_t
618 _dbus_string_array_contains (const char **array,
619 const char *str)
620 {
621 int i;
622
623 i = 0;
624 while (array[i] != NULL)
625 {
626 if (strcmp (array[i], str) == 0)
627 return TRUE;
628 ++i;
629 }
630
631 return FALSE;
632 }
633
640 void
641 _dbus_generate_uuid (DBusGUID *uuid)
642 {
643 long now;
644
645 /* don't use monotonic time because the UUID may be saved to disk, e.g.
646 * it may persist across reboots
647 */
648 _dbus_get_real_time (&now, NULL);
649
650 uuid->as_uint32s[DBUS_UUID_LENGTH_WORDS - 1] = DBUS_UINT32_TO_BE (now);
651
652 _dbus_generate_random_bytes_buffer (uuid->as_bytes, DBUS_UUID_LENGTH_BYTES - 4);
653 }
654
662 dbus_bool_t
663 _dbus_uuid_encode (const DBusGUID *uuid,
664 DBusString *encoded)
665 {
666 DBusString binary;
667 _dbus_string_init_const_len (&binary, uuid->as_bytes, DBUS_UUID_LENGTH_BYTES);
668 return _dbus_string_hex_encode (&binary, 0, encoded, _dbus_string_get_length (encoded));
669 }
670
671 static dbus_bool_t
672 _dbus_read_uuid_file_without_creating (const DBusString *filename,
673 DBusGUID *uuid,
674 DBusError *error)
675 {
676 DBusString contents;
677 DBusString decoded;
678 int end;
679
680 if (!_dbus_string_init (&contents))
681 {
682 _DBUS_SET_OOM (error);
683 return FALSE;
684 }
685
686 if (!_dbus_string_init (&decoded))
687 {
688 _dbus_string_free (&contents);
689 _DBUS_SET_OOM (error);
690 return FALSE;
691 }
692
693 if (!_dbus_file_get_contents (&contents, filename, error))
694 goto error;
695
696 _dbus_string_chop_white (&contents);
697
698 if (_dbus_string_get_length (&contents) != DBUS_UUID_LENGTH_HEX)
699 {
700 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
701 "UUID file '%s' should contain a hex string of length %d, not length %d, with no other text",
702 _dbus_string_get_const_data (filename),
703 DBUS_UUID_LENGTH_HEX,
704 _dbus_string_get_length (&contents));
705 goto error;
706 }
707
708 if (!_dbus_string_hex_decode (&contents, 0, &end, &decoded, 0))
709 {
710 _DBUS_SET_OOM (error);
711 goto error;
712 }
713
714 if (end == 0)
715 {
716 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
717 "UUID file '%s' contains invalid hex data",
718 _dbus_string_get_const_data (filename));
719 goto error;
720 }
721
722 if (_dbus_string_get_length (&decoded) != DBUS_UUID_LENGTH_BYTES)
723 {
724 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
725 "UUID file '%s' contains %d bytes of hex-encoded data instead of %d",
726 _dbus_string_get_const_data (filename),
727 _dbus_string_get_length (&decoded),
728 DBUS_UUID_LENGTH_BYTES);
729 goto error;
730 }
731
732 _dbus_string_copy_to_buffer (&decoded, uuid->as_bytes, DBUS_UUID_LENGTH_BYTES);
733
734 _dbus_string_free (&decoded);
735 _dbus_string_free (&contents);
736
737 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
738
739 return TRUE;
740
741 error:
742 _DBUS_ASSERT_ERROR_IS_SET (error);
743 _dbus_string_free (&contents);
744 _dbus_string_free (&decoded);
745 return FALSE;
746 }
747
756 dbus_bool_t
757 _dbus_write_uuid_file (const DBusString *filename,
758 const DBusGUID *uuid,
759 DBusError *error)
760 {
761 DBusString encoded;
762
763 if (!_dbus_string_init (&encoded))
764 {
765 _DBUS_SET_OOM (error);
766 return FALSE;
767 }
768
769 if (!_dbus_uuid_encode (uuid, &encoded))
770 {
771 _DBUS_SET_OOM (error);
772 goto error;
773 }
774
775 if (!_dbus_string_append_byte (&encoded, '\n'))
776 {
777 _DBUS_SET_OOM (error);
778 goto error;
779 }
780
781 if (!_dbus_string_save_to_file (&encoded, filename, TRUE, error))
782 goto error;
783
784 _dbus_string_free (&encoded);
785
786 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
787 return TRUE;
788
789 error:
790 _DBUS_ASSERT_ERROR_IS_SET (error);
791 _dbus_string_free (&encoded);
792 return FALSE;
793 }
794
805 dbus_bool_t
806 _dbus_read_uuid_file (const DBusString *filename,
807 DBusGUID *uuid,
808 dbus_bool_t create_if_not_found,
809 DBusError *error)
810 {
811 DBusError read_error = DBUS_ERROR_INIT;
812
813 if (_dbus_read_uuid_file_without_creating (filename, uuid, &read_error))
814 return TRUE;
815
816 if (!create_if_not_found)
817 {
818 dbus_move_error (&read_error, error);
819 return FALSE;
820 }
821
822 /* If the file exists and contains junk, we want to keep that error
823 * message instead of overwriting it with a "file exists" error
824 * message when we try to write
825 */
826 if (dbus_error_has_name (&read_error, DBUS_ERROR_INVALID_FILE_CONTENT))
827 {
828 dbus_move_error (&read_error, error);
829 return FALSE;
830 }
831 else
832 {
833 dbus_error_free (&read_error);
834 _dbus_generate_uuid (uuid);
835 return _dbus_write_uuid_file (filename, uuid, error);
836 }
837 }
838
839 /* Protected by _DBUS_LOCK (machine_uuid) */
840 static int machine_uuid_initialized_generation = 0;
841 static DBusGUID machine_uuid;
842
853 dbus_bool_t
854 _dbus_get_local_machine_uuid_encoded (DBusString *uuid_str)
855 {
856 dbus_bool_t ok;
857
858 if (!_DBUS_LOCK (machine_uuid))
859 return FALSE;
860
861 if (machine_uuid_initialized_generation != _dbus_current_generation)
862 {
863 DBusError error = DBUS_ERROR_INIT;
864
865 if (!_dbus_read_local_machine_uuid (&machine_uuid, FALSE,
866 &error))
867 {
868 #ifndef DBUS_ENABLE_EMBEDDED_TESTS
869 /* For the test suite, we may not be installed so just continue silently
870 * here. But in a production build, we want to be nice and loud about
871 * this.
872 */
873 _dbus_warn_check_failed ("D-Bus library appears to be incorrectly set up; failed to read machine uuid: %s\n"
874 "See the manual page for dbus-uuidgen to correct this issue.\n",
875 error.message);
876 #endif
877
878 dbus_error_free (&error);
879
880 _dbus_generate_uuid (&machine_uuid);
881 }
882 }
883
884 ok = _dbus_uuid_encode (&machine_uuid, uuid_str);
885
886 _DBUS_UNLOCK (machine_uuid);
887
888 return ok;
889 }
890
891 #ifndef DBUS_DISABLE_CHECKS
892
893 const char *_dbus_return_if_fail_warning_format =
894 "arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n"
895 "This is normally a bug in some application using the D-Bus library.\n";
896 #endif
897
898 #ifndef DBUS_DISABLE_ASSERT
899
911 void
912 _dbus_real_assert (dbus_bool_t condition,
913 const char *condition_text,
914 const char *file,
915 int line,
916 const char *func)
917 {
918 if (_DBUS_UNLIKELY (!condition))
919 {
920 _dbus_warn ("%lu: assertion failed \"%s\" file \"%s\" line %d function %s\n",
921 _dbus_pid_for_log (), condition_text, file, line, func);
922 _dbus_abort ();
923 }
924 }
925
936 void
937 _dbus_real_assert_not_reached (const char *explanation,
938 const char *file,
939 int line)
940 {
941 _dbus_warn ("File \"%s\" line %d process %lu should not have been reached: %s\n",
942 file, line, _dbus_pid_for_log (), explanation);
943 _dbus_abort ();
944 }
945 #endif /* DBUS_DISABLE_ASSERT */
946
947 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
948 static dbus_bool_t
949 run_failing_each_malloc (int n_mallocs,
950 const char *description,
951 DBusTestMemoryFunction func,
952 void *data)
953 {
954 n_mallocs += 10; /* fudge factor to ensure reallocs etc. are covered */
955
956 while (n_mallocs >= 0)
957 {
958 _dbus_set_fail_alloc_counter (n_mallocs);
959
960 _dbus_verbose ("\n===\n%s: (will fail malloc %d with %d failures)\n===\n",
961 description, n_mallocs,
962 _dbus_get_fail_alloc_failures ());
963
964 if (!(* func) (data))
965 return FALSE;
966
967 n_mallocs -= 1;
968 }
969
970 _dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
971
972 return TRUE;
973 }
974
988 dbus_bool_t
989 _dbus_test_oom_handling (const char *description,
990 DBusTestMemoryFunction func,
991 void *data)
992 {
993 int approx_mallocs;
994 const char *setting;
995 int max_failures_to_try;
996 int i;
997
998 /* Run once to see about how many mallocs are involved */
999
1000 _dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
1001
1002 _dbus_verbose ("Running once to count mallocs\n");
1003
1004 if (!(* func) (data))
1005 return FALSE;
1006
1007 approx_mallocs = _DBUS_INT_MAX - _dbus_get_fail_alloc_counter ();
1008
1009 _dbus_verbose ("\n=================\n%s: about %d mallocs total\n=================\n",
1010 description, approx_mallocs);
1011
1012 setting = _dbus_getenv ("DBUS_TEST_MALLOC_FAILURES");
1013 if (setting != NULL)
1014 {
1015 DBusString str;
1016 long v;
1017 _dbus_string_init_const (&str, setting);
1018 v = 4;
1019 if (!_dbus_string_parse_int (&str, 0, &v, NULL))
1020 _dbus_warn ("couldn't parse '%s' as integer\n", setting);
1021 max_failures_to_try = v;
1022 }
1023 else
1024 {
1025 max_failures_to_try = 4;
1026 }
1027
1028 i = setting ? max_failures_to_try - 1 : 1;
1029 while (i < max_failures_to_try)
1030 {
1031 _dbus_set_fail_alloc_failures (i);
1032 if (!run_failing_each_malloc (approx_mallocs, description, func, data))
1033 return FALSE;
1034 ++i;
1035 }
1036
1037 _dbus_verbose ("\n=================\n%s: all iterations passed\n=================\n",
1038 description);
1039
1040 return TRUE;
1041 }
1042 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
1043
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_string_parse_int
dbus_bool_t _dbus_string_parse_int(const DBusString *str, int start, long *value_return, int *end_return)
Parses an integer contained in a DBusString.
Definition: dbus-sysdeps.c:435
_dbus_string_copy_to_buffer
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
Definition: dbus-string.c:680
_dbus_uuid_encode
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
Definition: dbus-internals.c:663
DBusError::message
const char * message
public error message field
Definition: dbus-errors.h:51
NULL
#define NULL
A null pointer, defined appropriately for C or C++.
DBUS_ERROR_INVALID_FILE_CONTENT
#define DBUS_ERROR_INVALID_FILE_CONTENT
A file contains invalid syntax or is otherwise broken.
Definition: dbus-protocol.h:439
_dbus_string_save_to_file
dbus_bool_t _dbus_string_save_to_file(const DBusString *str, const DBusString *filename, dbus_bool_t world_readable, DBusError *error)
Writes a string out to a file.
Definition: dbus-file-unix.c:164
_dbus_string_hex_encode
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
Definition: dbus-string.c:2241
_dbus_real_assert
void _dbus_real_assert(dbus_bool_t condition, const char *condition_text, const char *file, int line, const char *func)
Internals of _dbus_assert(); it's a function rather than a macro with the inline code so that the ass...
Definition: dbus-internals.c:912
DBusGUID::as_uint32s
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values
Definition: dbus-internals.h:352
_dbus_return_if_fail_warning_format
const char * _dbus_return_if_fail_warning_format
String used in _dbus_return_if_fail macro.
Definition: dbus-internals.c:893
_dbus_string_chop_white
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
Definition: dbus-string.c:1971
_dbus_assert
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
Definition: dbus-internals.h:135
DBUS_ERROR_INIT
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
DBusGUID::as_bytes
char as_bytes[DBUS_UUID_LENGTH_BYTES]
guid as 16 single-byte values
Definition: dbus-internals.h:353
_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:258
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
DBusGUID
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
Definition: dbus-internals.h:350
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
_DBUS_INT_MAX
#define _DBUS_INT_MAX
Maximum value of type "int".
Definition: dbus-internals.h:231
_dbus_getenv
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:185
_dbus_get_local_machine_uuid_encoded
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str)
Gets the hex-encoded UUID of the machine this function is executed on.
Definition: dbus-internals.c:854
_dbus_abort
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
Definition: dbus-sysdeps.c:77
_dbus_real_assert_not_reached
void _dbus_real_assert_not_reached(const char *explanation, const char *file, int line)
Internals of _dbus_assert_not_reached(); it's a function rather than a macro with the inline code so ...
Definition: dbus-internals.c:937
_dbus_get_real_time
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
Definition: dbus-sysdeps-unix.c:2702
dbus_malloc
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
Definition: dbus-memory.c:461
dbus_new0
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:59
_dbus_generate_random_bytes_buffer
void _dbus_generate_random_bytes_buffer(char *buffer, int n_bytes)
Fills n_bytes of the given buffer with random bytes.
Definition: dbus-sysdeps.c:543
DBusString
Definition: dbus-string.h:42
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
_dbus_string_init_const
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
_dbus_no_memory_message
const char * _dbus_no_memory_message
Fixed "out of memory" error message, just to avoid making up a different string every time and wastin...
Definition: dbus-internals.c:184
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition: dbus-internals.c:230
_dbus_memdup
void * _dbus_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
Definition: dbus-internals.c:555
_dbus_current_generation
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called, so we can reinit things after it's been called.
Definition: dbus-memory.c:781
DBusError
Object representing an exception.
Definition: dbus-errors.h:48
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_string_append_byte
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
Definition: dbus-string.c:1139
_DBUS_UNLOCK
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
Definition: dbus-internals.h:330
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:242
_dbus_dup_string_array
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
Definition: dbus-internals.c:578
TRUE
#define TRUE
Expands to "1".
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_read_uuid_file
dbus_bool_t _dbus_read_uuid_file(const DBusString *filename, DBusGUID *uuid, dbus_bool_t create_if_not_found, DBusError *error)
Reads (and optionally writes) a uuid to a file.
Definition: dbus-internals.c:806
_dbus_pid_for_log
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
Definition: dbus-sysdeps-unix.c:2439
_dbus_string_hex_decode
dbus_bool_t _dbus_string_hex_decode(const DBusString *source, int start, int *end_return, DBusString *dest, int insert_at)
Decodes a string from hex encoding.
Definition: dbus-string.c:2291
dbus_free_string_array
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:749
_dbus_string_array_contains
dbus_bool_t _dbus_string_array_contains(const char **array, const char *str)
Checks whether a string array contains the given string.
Definition: dbus-internals.c:618
_dbus_file_get_contents
dbus_bool_t _dbus_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
Definition: dbus-file-unix.c:55
FALSE
#define FALSE
Expands to "0".
_dbus_read_local_machine_uuid
dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration.
Definition: dbus-sysdeps-unix.c:3610
_dbus_generate_uuid
void _dbus_generate_uuid(DBusGUID *uuid)
Generates a new UUID.
Definition: dbus-internals.c:641
_dbus_write_uuid_file
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
Definition: dbus-internals.c:757
_DBUS_LOCK
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
Definition: dbus-internals.h:329
_dbus_strdup
char * _dbus_strdup(const char *str)
Duplicates a string.
Definition: dbus-internals.c:527
_dbus_string_init_const_len
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
Definition: dbus-string.c:210