D-Bus  1.8.16
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 
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 
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
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 
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  {
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  {
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  {
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 
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 
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  */
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 
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 
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
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 
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_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_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
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_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
const char * message
public error message field
Definition: dbus-errors.h:51
#define NULL
A null pointer, defined appropriately for C or C++.
#define DBUS_ERROR_INVALID_FILE_CONTENT
A file contains invalid syntax or is otherwise broken.
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.
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
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...
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values
const char * _dbus_return_if_fail_warning_format
String used in _dbus_return_if_fail macro.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
Definition: dbus-string.c:1971
#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
char as_bytes[DBUS_UUID_LENGTH_BYTES]
guid as 16 single-byte values
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...
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
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
#define _DBUS_INT_MAX
Maximum value of type "int".
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:185
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.
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
Definition: dbus-sysdeps.c:77
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 ...
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
Definition: dbus-memory.c:461
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:59
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
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
const char * _dbus_no_memory_message
Fixed "out of memory" error message, just to avoid making up a different string every time and wastin...
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
void * _dbus_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
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
Object representing an exception.
Definition: dbus-errors.h:48
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_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
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:242
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
#define TRUE
Expands to "1".
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
Definition: dbus-errors.c:279
dbus_bool_t _dbus_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.
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...
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
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:749
dbus_bool_t _dbus_string_array_contains(const char **array, const char *str)
Checks whether a string array contains the given string.
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.
#define FALSE
Expands to "0".
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.
void _dbus_generate_uuid(DBusGUID *uuid)
Generates a new UUID.
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
char * _dbus_strdup(const char *str)
Duplicates a string.
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