D-Bus: dbus-internals.c Source File

D-Bus 1.10.22

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
366 void _dbus_set_verbose (dbus_bool_t state)
367 {
368 verbose = state;
369 }
370
371 dbus_bool_t _dbus_get_verbose (void)
372 {
373 return verbose;
374 }
375
384 void
385 _dbus_verbose_real (
386 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
387 const char *file,
388 const int line,
389 const char *function,
390 #endif
391 const char *format,
392 ...)
393 {
394 va_list args;
395 static dbus_bool_t need_pid = TRUE;
396 int len;
397
398 /* things are written a bit oddly here so that
399 * in the non-verbose case we just have the one
400 * conditional and return immediately.
401 */
402 if (!_dbus_is_verbose_real())
403 return;
404
405 #ifndef DBUS_USE_OUTPUT_DEBUG_STRING
406 /* Print out pid before the line */
407 if (need_pid)
408 {
409 #if PTHREAD_IN_VERBOSE
410 fprintf (stderr, "%lu: 0x%lx: ", _dbus_pid_for_log (), pthread_self ());
411 #else
412 fprintf (stderr, "%lu: ", _dbus_pid_for_log ());
413 #endif
414 }
415 #endif
416
417 /* Only print pid again if the next line is a new line */
418 len = strlen (format);
419 if (format[len-1] == '\n')
420 need_pid = TRUE;
421 else
422 need_pid = FALSE;
423
424 va_start (args, format);
425 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
426 {
427 char buf[1024];
428 strcpy(buf,module_name);
429 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
430 sprintf (buf+strlen(buf), "[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,function);
431 #endif
432 vsprintf (buf+strlen(buf),format, args);
433 va_end (args);
434 OutputDebugStringA(buf);
435 }
436 #else
437 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
438 fprintf (stderr, "[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,function);
439 #endif
440
441 vfprintf (stderr, format, args);
442 va_end (args);
443
444 fflush (stderr);
445 #endif
446 }
447
454 void
455 _dbus_verbose_reset_real (void)
456 {
457 verbose_initted = FALSE;
458 }
459
460 void
461 _dbus_trace_ref (const char *obj_name,
462 void *obj,
463 int old_refcount,
464 int new_refcount,
465 const char *why,
466 const char *env_var,
467 int *enabled)
468 {
469 _dbus_assert (obj_name != NULL);
470 _dbus_assert (obj != NULL);
471 _dbus_assert (old_refcount >= -1);
472 _dbus_assert (new_refcount >= -1);
473
474 if (old_refcount == -1)
475 {
476 _dbus_assert (new_refcount == -1);
477 }
478 else
479 {
480 _dbus_assert (new_refcount >= 0);
481 _dbus_assert (old_refcount >= 0);
482 _dbus_assert (old_refcount > 0 || new_refcount > 0);
483 }
484
485 _dbus_assert (why != NULL);
486 _dbus_assert (env_var != NULL);
487 _dbus_assert (enabled != NULL);
488
489 if (*enabled < 0)
490 {
491 const char *s = _dbus_getenv (env_var);
492
493 *enabled = FALSE;
494
495 if (s && *s)
496 {
497 if (*s == '0')
498 *enabled = FALSE;
499 else if (*s == '1')
500 *enabled = TRUE;
501 else
502 _dbus_warn ("%s should be 0 or 1 if set, not '%s'", env_var, s);
503 }
504 }
505
506 if (*enabled)
507 {
508 if (old_refcount == -1)
509 {
510 VALGRIND_PRINTF_BACKTRACE ("%s %p ref stolen (%s)",
511 obj_name, obj, why);
512 _dbus_verbose ("%s %p ref stolen (%s)\n",
513 obj_name, obj, why);
514 }
515 else
516 {
517 VALGRIND_PRINTF_BACKTRACE ("%s %p %d -> %d refs (%s)",
518 obj_name, obj,
519 old_refcount, new_refcount, why);
520 _dbus_verbose ("%s %p %d -> %d refs (%s)\n",
521 obj_name, obj, old_refcount, new_refcount, why);
522 }
523 }
524 }
525
526 #endif /* DBUS_ENABLE_VERBOSE_MODE */
527
536 char*
537 _dbus_strdup (const char *str)
538 {
539 size_t len;
540 char *copy;
541
542 if (str == NULL)
543 return NULL;
544
545 len = strlen (str);
546
547 copy = dbus_malloc (len + 1);
548 if (copy == NULL)
549 return NULL;
550
551 memcpy (copy, str, len + 1);
552
553 return copy;
554 }
555
564 void*
565 _dbus_memdup (const void *mem,
566 size_t n_bytes)
567 {
568 void *copy;
569
570 copy = dbus_malloc (n_bytes);
571 if (copy == NULL)
572 return NULL;
573
574 memcpy (copy, mem, n_bytes);
575
576 return copy;
577 }
578
587 char**
588 _dbus_dup_string_array (const char **array)
589 {
590 int len;
591 int i;
592 char **copy;
593
594 if (array == NULL)
595 return NULL;
596
597 for (len = 0; array[len] != NULL; ++len)
598 ;
599
600 copy = dbus_new0 (char*, len + 1);
601 if (copy == NULL)
602 return NULL;
603
604 i = 0;
605 while (i < len)
606 {
607 copy[i] = _dbus_strdup (array[i]);
608 if (copy[i] == NULL)
609 {
610 dbus_free_string_array (copy);
611 return NULL;
612 }
613
614 ++i;
615 }
616
617 return copy;
618 }
619
627 dbus_bool_t
628 _dbus_string_array_contains (const char **array,
629 const char *str)
630 {
631 int i;
632
633 i = 0;
634 while (array[i] != NULL)
635 {
636 if (strcmp (array[i], str) == 0)
637 return TRUE;
638 ++i;
639 }
640
641 return FALSE;
642 }
643
652 dbus_bool_t
653 _dbus_generate_uuid (DBusGUID *uuid,
654 DBusError *error)
655 {
656 DBusError rand_error;
657 long now;
658
659 dbus_error_init (&rand_error);
660
661 /* don't use monotonic time because the UUID may be saved to disk, e.g.
662 * it may persist across reboots
663 */
664 _dbus_get_real_time (&now, NULL);
665
666 uuid->as_uint32s[DBUS_UUID_LENGTH_WORDS - 1] = DBUS_UINT32_TO_BE (now);
667
668 if (!_dbus_generate_random_bytes_buffer (uuid->as_bytes,
669 DBUS_UUID_LENGTH_BYTES - 4,
670 &rand_error))
671 {
672 dbus_set_error (error, rand_error.name,
673 "Failed to generate UUID: %s", rand_error.message);
674 dbus_error_free (&rand_error);
675 return FALSE;
676 }
677
678 return TRUE;
679 }
680
688 dbus_bool_t
689 _dbus_uuid_encode (const DBusGUID *uuid,
690 DBusString *encoded)
691 {
692 DBusString binary;
693 _dbus_string_init_const_len (&binary, uuid->as_bytes, DBUS_UUID_LENGTH_BYTES);
694 return _dbus_string_hex_encode (&binary, 0, encoded, _dbus_string_get_length (encoded));
695 }
696
697 static dbus_bool_t
698 _dbus_read_uuid_file_without_creating (const DBusString *filename,
699 DBusGUID *uuid,
700 DBusError *error)
701 {
702 DBusString contents;
703 DBusString decoded;
704 int end;
705
706 if (!_dbus_string_init (&contents))
707 {
708 _DBUS_SET_OOM (error);
709 return FALSE;
710 }
711
712 if (!_dbus_string_init (&decoded))
713 {
714 _dbus_string_free (&contents);
715 _DBUS_SET_OOM (error);
716 return FALSE;
717 }
718
719 if (!_dbus_file_get_contents (&contents, filename, error))
720 goto error;
721
722 _dbus_string_chop_white (&contents);
723
724 if (_dbus_string_get_length (&contents) != DBUS_UUID_LENGTH_HEX)
725 {
726 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
727 "UUID file '%s' should contain a hex string of length %d, not length %d, with no other text",
728 _dbus_string_get_const_data (filename),
729 DBUS_UUID_LENGTH_HEX,
730 _dbus_string_get_length (&contents));
731 goto error;
732 }
733
734 if (!_dbus_string_hex_decode (&contents, 0, &end, &decoded, 0))
735 {
736 _DBUS_SET_OOM (error);
737 goto error;
738 }
739
740 if (end == 0)
741 {
742 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
743 "UUID file '%s' contains invalid hex data",
744 _dbus_string_get_const_data (filename));
745 goto error;
746 }
747
748 if (_dbus_string_get_length (&decoded) != DBUS_UUID_LENGTH_BYTES)
749 {
750 dbus_set_error (error, DBUS_ERROR_INVALID_FILE_CONTENT,
751 "UUID file '%s' contains %d bytes of hex-encoded data instead of %d",
752 _dbus_string_get_const_data (filename),
753 _dbus_string_get_length (&decoded),
754 DBUS_UUID_LENGTH_BYTES);
755 goto error;
756 }
757
758 _dbus_string_copy_to_buffer (&decoded, uuid->as_bytes, DBUS_UUID_LENGTH_BYTES);
759
760 _dbus_string_free (&decoded);
761 _dbus_string_free (&contents);
762
763 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
764
765 return TRUE;
766
767 error:
768 _DBUS_ASSERT_ERROR_IS_SET (error);
769 _dbus_string_free (&contents);
770 _dbus_string_free (&decoded);
771 return FALSE;
772 }
773
782 dbus_bool_t
783 _dbus_write_uuid_file (const DBusString *filename,
784 const DBusGUID *uuid,
785 DBusError *error)
786 {
787 DBusString encoded;
788
789 if (!_dbus_string_init (&encoded))
790 {
791 _DBUS_SET_OOM (error);
792 return FALSE;
793 }
794
795 if (!_dbus_uuid_encode (uuid, &encoded))
796 {
797 _DBUS_SET_OOM (error);
798 goto error;
799 }
800
801 if (!_dbus_string_append_byte (&encoded, '\n'))
802 {
803 _DBUS_SET_OOM (error);
804 goto error;
805 }
806
807 if (!_dbus_string_save_to_file (&encoded, filename, TRUE, error))
808 goto error;
809
810 _dbus_string_free (&encoded);
811
812 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
813 return TRUE;
814
815 error:
816 _DBUS_ASSERT_ERROR_IS_SET (error);
817 _dbus_string_free (&encoded);
818 return FALSE;
819 }
820
831 dbus_bool_t
832 _dbus_read_uuid_file (const DBusString *filename,
833 DBusGUID *uuid,
834 dbus_bool_t create_if_not_found,
835 DBusError *error)
836 {
837 DBusError read_error = DBUS_ERROR_INIT;
838
839 if (_dbus_read_uuid_file_without_creating (filename, uuid, &read_error))
840 return TRUE;
841
842 if (!create_if_not_found)
843 {
844 dbus_move_error (&read_error, error);
845 return FALSE;
846 }
847
848 /* If the file exists and contains junk, we want to keep that error
849 * message instead of overwriting it with a "file exists" error
850 * message when we try to write
851 */
852 if (dbus_error_has_name (&read_error, DBUS_ERROR_INVALID_FILE_CONTENT))
853 {
854 dbus_move_error (&read_error, error);
855 return FALSE;
856 }
857 else
858 {
859 dbus_error_free (&read_error);
860
861 if (!_dbus_generate_uuid (uuid, error))
862 return FALSE;
863
864 return _dbus_write_uuid_file (filename, uuid, error);
865 }
866 }
867
868 /* Protected by _DBUS_LOCK (machine_uuid) */
869 static int machine_uuid_initialized_generation = 0;
870 static DBusGUID machine_uuid;
871
883 dbus_bool_t
884 _dbus_get_local_machine_uuid_encoded (DBusString *uuid_str,
885 DBusError *error)
886 {
887 dbus_bool_t ok = TRUE;
888
889 if (!_DBUS_LOCK (machine_uuid))
890 {
891 _DBUS_SET_OOM (error);
892 return FALSE;
893 }
894
895 if (machine_uuid_initialized_generation != _dbus_current_generation)
896 {
897 DBusError local_error = DBUS_ERROR_INIT;
898
899 if (!_dbus_read_local_machine_uuid (&machine_uuid, FALSE,
900 &local_error))
901 {
902 #ifndef DBUS_ENABLE_EMBEDDED_TESTS
903 /* For the test suite, we may not be installed so just continue silently
904 * here. But in a production build, we want to be nice and loud about
905 * this.
906 */
907 _dbus_warn_check_failed ("D-Bus library appears to be incorrectly set up; failed to read machine uuid: %s\n"
908 "See the manual page for dbus-uuidgen to correct this issue.\n",
909 local_error.message);
910 #endif
911
912 dbus_error_free (&local_error);
913
914 ok = _dbus_generate_uuid (&machine_uuid, error);
915 }
916 }
917
918 if (ok)
919 {
920 if (!_dbus_uuid_encode (&machine_uuid, uuid_str))
921 {
922 ok = FALSE;
923 _DBUS_SET_OOM (error);
924 }
925 }
926
927 _DBUS_UNLOCK (machine_uuid);
928
929 return ok;
930 }
931
932 #ifndef DBUS_DISABLE_CHECKS
933
934 const char *_dbus_return_if_fail_warning_format =
935 "arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n"
936 "This is normally a bug in some application using the D-Bus library.\n";
937 #endif
938
939 #ifndef DBUS_DISABLE_ASSERT
940
952 void
953 _dbus_real_assert (dbus_bool_t condition,
954 const char *condition_text,
955 const char *file,
956 int line,
957 const char *func)
958 {
959 if (_DBUS_UNLIKELY (!condition))
960 {
961 _dbus_warn ("%lu: assertion failed \"%s\" file \"%s\" line %d function %s\n",
962 _dbus_pid_for_log (), condition_text, file, line, func);
963 _dbus_abort ();
964 }
965 }
966
977 void
978 _dbus_real_assert_not_reached (const char *explanation,
979 const char *file,
980 int line)
981 {
982 _dbus_warn ("File \"%s\" line %d process %lu should not have been reached: %s\n",
983 file, line, _dbus_pid_for_log (), explanation);
984 _dbus_abort ();
985 }
986 #endif /* DBUS_DISABLE_ASSERT */
987
988 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
989 static dbus_bool_t
990 run_failing_each_malloc (int n_mallocs,
991 const char *description,
992 DBusTestMemoryFunction func,
993 void *data)
994 {
995 n_mallocs += 10; /* fudge factor to ensure reallocs etc. are covered */
996
997 while (n_mallocs >= 0)
998 {
999 _dbus_set_fail_alloc_counter (n_mallocs);
1000
1001 _dbus_verbose ("\n===\n%s: (will fail malloc %d with %d failures)\n===\n",
1002 description, n_mallocs,
1003 _dbus_get_fail_alloc_failures ());
1004
1005 if (!(* func) (data))
1006 return FALSE;
1007
1008 n_mallocs -= 1;
1009 }
1010
1011 _dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
1012
1013 return TRUE;
1014 }
1015
1029 dbus_bool_t
1030 _dbus_test_oom_handling (const char *description,
1031 DBusTestMemoryFunction func,
1032 void *data)
1033 {
1034 int approx_mallocs;
1035 const char *setting;
1036 int max_failures_to_try;
1037 int i;
1038
1039 /* Run once to see about how many mallocs are involved */
1040
1041 _dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
1042
1043 _dbus_verbose ("Running once to count mallocs\n");
1044
1045 if (!(* func) (data))
1046 return FALSE;
1047
1048 approx_mallocs = _DBUS_INT_MAX - _dbus_get_fail_alloc_counter ();
1049
1050 _dbus_verbose ("\n=================\n%s: about %d mallocs total\n=================\n",
1051 description, approx_mallocs);
1052
1053 setting = _dbus_getenv ("DBUS_TEST_MALLOC_FAILURES");
1054 if (setting != NULL)
1055 {
1056 DBusString str;
1057 long v;
1058 _dbus_string_init_const (&str, setting);
1059 v = 4;
1060 if (!_dbus_string_parse_int (&str, 0, &v, NULL))
1061 _dbus_warn ("couldn't parse '%s' as integer\n", setting);
1062 max_failures_to_try = v;
1063 }
1064 else
1065 {
1066 max_failures_to_try = 4;
1067 }
1068
1069 if (max_failures_to_try < 1)
1070 {
1071 _dbus_verbose ("not testing OOM handling\n");
1072 return TRUE;
1073 }
1074
1075 i = setting ? max_failures_to_try - 1 : 1;
1076 while (i < max_failures_to_try)
1077 {
1078 _dbus_set_fail_alloc_failures (i);
1079 if (!run_failing_each_malloc (approx_mallocs, description, func, data))
1080 return FALSE;
1081 ++i;
1082 }
1083
1084 _dbus_verbose ("\n=================\n%s: all iterations passed\n=================\n",
1085 description);
1086
1087 return TRUE;
1088 }
1089 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
1090
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_PRIVATE_EXPORT 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:697
_dbus_uuid_encode
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
Definition: dbus-internals.c:689
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:444
_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:2259
_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&#39;s a function rather than a macro with the inline code so that the ass...
Definition: dbus-internals.c:953
_dbus_generate_uuid
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
Definition: dbus-internals.c:653
_dbus_get_local_machine_uuid_encoded
dbus_bool_t _dbus_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on.
Definition: dbus-internals.c:884
DBusGUID::as_uint32s
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values
Definition: dbus-internals.h:392
_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:934
_dbus_string_chop_white
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
Definition: dbus-string.c:1989
_dbus_assert
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
Definition: dbus-internals.h:148
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:393
_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&#39;s been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
_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
DBusGUID
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
Definition: dbus-internals.h:390
_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:263
_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&#39;s a function rather than a macro with the inline code so ...
Definition: dbus-internals.c:978
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
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:565
_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&#39;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:1157
_DBUS_UNLOCK
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
Definition: dbus-internals.h:369
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
_dbus_dup_string_array
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
Definition: dbus-internals.c:588
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
DBusError::name
const char * name
public error name field
Definition: dbus-errors.h:50
_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:832
_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:2692
dbus_error_init
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
Definition: dbus-errors.c:188
_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:2309
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:628
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&#39;re running on from the dbus configuration.
Definition: dbus-sysdeps-unix.c:3883
_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:783
_DBUS_LOCK
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
Definition: dbus-internals.h:368
_dbus_generate_random_bytes_buffer
dbus_bool_t _dbus_generate_random_bytes_buffer(char *buffer, int n_bytes, DBusError *error)
Fills n_bytes of the given buffer with random bytes.
Definition: dbus-sysdeps.c:516
_dbus_strdup
char * _dbus_strdup(const char *str)
Duplicates a string.
Definition: dbus-internals.c:537
_dbus_getenv
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:185
_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
_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:2934