27#include "dbus-internals.h" 
   28#include "dbus-protocol.h" 
   29#include "dbus-marshal-basic.h" 
   31#include "dbus-test-tap.h" 
   32#include "dbus-valgrind-internal.h" 
   37#ifdef DBUS_USE_OUTPUT_DEBUG_STRING 
  183_DBUS_STATIC_ASSERT (
sizeof (
void *) == DBUS_SIZEOF_VOID_P);
 
  189_DBUS_STATIC_ASSERT (
sizeof (
void *) == 
sizeof (DBusShutdownFunction));
 
  190_DBUS_STATIC_ASSERT (_DBUS_ALIGNOF (
void *) == _DBUS_ALIGNOF (DBusShutdownFunction));
 
  193_DBUS_STATIC_ASSERT (
sizeof (
void *) == 
sizeof (intptr_t));
 
  194_DBUS_STATIC_ASSERT (
sizeof (
void *) == 
sizeof (uintptr_t));
 
  229static int check_failed_count = 0;
 
  231int _dbus_get_check_failed_count (
void)
 
  233  return check_failed_count;
 
  247              fatal_warnings = 
FALSE;
 
  248              fatal_warnings_on_check_failed = 
FALSE;
 
  252              fatal_warnings = 
TRUE;
 
  253              fatal_warnings_on_check_failed = 
TRUE;
 
  257              fprintf(stderr, 
"DBUS_FATAL_WARNINGS should be set to 0 or 1 if set, not '%s'",
 
  262      check_failed_count = 0;
 
  281  DBusSystemLogSeverity severity = DBUS_SYSTEM_LOG_WARNING;
 
  288    severity = DBUS_SYSTEM_LOG_ERROR;
 
  290  va_start (args, format);
 
 
  313  DBusSystemLogSeverity severity = DBUS_SYSTEM_LOG_WARNING;
 
  319  if (fatal_warnings_on_check_failed)
 
  320    severity = DBUS_SYSTEM_LOG_ERROR;
 
  322  va_start (args, format);
 
  326  if (fatal_warnings_on_check_failed)
 
  332    check_failed_count++;
 
 
  335#ifdef DBUS_ENABLE_VERBOSE_MODE 
  340#ifdef DBUS_USE_OUTPUT_DEBUG_STRING 
  341static char module_name[1024];
 
  345_dbus_verbose_init (
void)
 
  347  if (!verbose_initted)
 
  350      verbose = p != 
NULL && *p == 
'1';
 
  351      verbose_initted = 
TRUE;
 
  352#ifdef DBUS_USE_OUTPUT_DEBUG_STRING 
  354        char *last_period, *last_slash;
 
  355        GetModuleFileName(0,module_name,
sizeof(module_name)-1);
 
  356        last_period = _mbsrchr(module_name,
'.');
 
  359        last_slash = _mbsrchr(module_name,
'\\');
 
  361          strcpy(module_name,last_slash+1);
 
  362        strcat(module_name,
": ");
 
  372static char *_dbus_file_path_extract_elements_from_tail(
const char *file,
int level)
 
  375  char *p = (
char *)file + strlen(file);
 
  380      if (DBUS_IS_DIR_SEPARATOR(*p))
 
  390  return (
char *)file+prefix;
 
  399_dbus_is_verbose_real (
void)
 
  401  _dbus_verbose_init ();
 
  427_dbus_verbose_raw (
const char *s)
 
  429  if (!_dbus_is_verbose_real ())
 
  431#ifdef DBUS_USE_OUTPUT_DEBUG_STRING 
  432  OutputDebugStringA (s);
 
  449#ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
 
  452                    const char *function, 
 
  467  if (!_dbus_is_verbose_real())
 
  470#ifndef DBUS_USE_OUTPUT_DEBUG_STRING 
  474      _dbus_print_thread ();
 
  481  len = strlen (format);
 
  482  if (format[len-1] == 
'\n')
 
  487  va_start (args, format);
 
  489#ifdef DBUS_USE_OUTPUT_DEBUG_STRING 
  492    const char *message = 
NULL;
 
  500#ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS 
  506    message = _dbus_string_get_const_data (&out);
 
  510        OutputDebugStringA (
"Out of memory while formatting verbose message: '''");
 
  511        OutputDebugStringA (format);
 
  512        OutputDebugStringA (
"'''");
 
  516        OutputDebugStringA (message);
 
  521#ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS 
  522  fprintf (stderr, 
"[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,function);
 
  525  vfprintf (stderr, format, args);
 
  539_dbus_verbose_reset_real (
void)
 
  541  verbose_initted = 
FALSE;
 
  545_dbus_trace_ref (
const char *obj_name,
 
  558  if (old_refcount == -1)
 
  586            _dbus_warn (
"%s should be 0 or 1 if set, not '%s'", env_var, s);
 
  592      if (old_refcount == -1)
 
  594          VALGRIND_PRINTF_BACKTRACE (
"%s %p ref stolen (%s)",
 
  596          _dbus_verbose (
"%s %p ref stolen (%s)\n",
 
  601          VALGRIND_PRINTF_BACKTRACE (
"%s %p %d -> %d refs (%s)",
 
  603                                     old_refcount, new_refcount, why);
 
  604          _dbus_verbose (
"%s %p %d -> %d refs (%s)\n",
 
  605                         obj_name, obj, old_refcount, new_refcount, why);
 
  635  memcpy (copy, str, len + 1);
 
 
  658  memcpy (copy, mem, n_bytes);
 
 
  681  for (len = 0; array[len] != 
NULL; ++len)
 
 
  718  while (array[i] != 
NULL)
 
  720      if (strcmp (array[i], str) == 0)
 
 
  738  for (i = 0; array[i]; i++) {}
 
 
  765  uuid->
as_uint32s[DBUS_UUID_LENGTH_WORDS - 1] = DBUS_UINT32_TO_BE (now);
 
  768                                           DBUS_UUID_LENGTH_BYTES - 4,
 
  772                      "Failed to generate UUID: %s", rand_error.
message);
 
 
  797_dbus_read_uuid_file_without_creating (
const DBusString *filename,
 
  807      _DBUS_SET_OOM (error);
 
  814      _DBUS_SET_OOM (error);
 
  823  if (_dbus_string_get_length (&contents) != DBUS_UUID_LENGTH_HEX)
 
  826                      "UUID file '%s' should contain a hex string of length %d, not length %d, with no other text",
 
  827                      _dbus_string_get_const_data (filename),
 
  828                      DBUS_UUID_LENGTH_HEX,
 
  829                      _dbus_string_get_length (&contents));
 
  835      _DBUS_SET_OOM (error);
 
  842                      "UUID file '%s' contains invalid hex data",
 
  843                      _dbus_string_get_const_data (filename));
 
  847  if (_dbus_string_get_length (&decoded) != DBUS_UUID_LENGTH_BYTES)
 
  850                      "UUID file '%s' contains %d bytes of hex-encoded data instead of %d",
 
  851                      _dbus_string_get_const_data (filename),
 
  852                      _dbus_string_get_length (&decoded),
 
  853                      DBUS_UUID_LENGTH_BYTES);
 
  862  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  867  _DBUS_ASSERT_ERROR_IS_SET (error);
 
  890      _DBUS_SET_OOM (error);
 
  896      _DBUS_SET_OOM (error);
 
  902      _DBUS_SET_OOM (error);
 
  911  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 
  915  _DBUS_ASSERT_ERROR_IS_SET (error);
 
 
  938  if (_dbus_read_uuid_file_without_creating (filename, uuid, &read_error))
 
  941  if (!create_if_not_found)
 
 
  968static int machine_uuid_initialized_generation = 0;
 
  990      _DBUS_SET_OOM (error);
 
 1005          _DBUS_SET_OOM (error);
 
 
 1014#ifndef DBUS_DISABLE_CHECKS 
 1016_dbus_warn_return_if_fail (
const char *function,
 
 1017                           const char *assertion,
 
 1022      "arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n" 
 1023      "This is normally a bug in some application using the D-Bus library.\n",
 
 1024      function, assertion, file, line);
 
 1028#ifndef DBUS_DISABLE_ASSERT 
 1043                   const char  *condition_text,
 
 1048  if (_DBUS_UNLIKELY (!condition))
 
 1050      _dbus_warn (
"assertion failed \"%s\" file \"%s\" line %d function %s",
 
 1051                  condition_text, file, line, func);
 
 
 1071  _dbus_warn (
"File \"%s\" line %d should not have been reached: %s",
 
 1072              file, line, explanation);
 
 
 1077#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 1079run_failing_each_malloc (
int                    n_mallocs,
 
 1080                         const char            *description,
 
 1081                         DBusTestMemoryFunction func,
 
 1086  while (n_mallocs >= 0)
 
 1088      _dbus_set_fail_alloc_counter (n_mallocs);
 
 1090      _dbus_test_diag (
"%s: will fail malloc %d and %d that follow",
 
 1091                       description, n_mallocs,
 
 1092                       _dbus_get_fail_alloc_failures () - 1);
 
 1094      if (!(* func) (data, 
FALSE))
 
 1100  _dbus_set_fail_alloc_counter (-1);
 
 1119_dbus_test_oom_handling (
const char             *description,
 
 1120                         DBusTestMemoryFunction  func,
 
 1124  const char *setting;
 
 1125  int max_failures_to_try;
 
 1130  _dbus_set_fail_alloc_counter (-1);
 
 1132  _dbus_test_diag (
"Running \"%s\" once to count mallocs", description);
 
 1134  if (!(* func) (data, 
TRUE))
 
 1141  approx_mallocs = -1 - _dbus_get_fail_alloc_counter ();
 
 1143  _dbus_test_diag (
"\"%s\" has about %d mallocs in total",
 
 1144                   description, approx_mallocs);
 
 1148  if (setting != 
NULL)
 
 1155        _dbus_warn (
"couldn't parse '%s' as integer\n", setting);
 
 1156      max_failures_to_try = v;
 
 1160      max_failures_to_try = 4;
 
 1168      max_failures_to_try = 0;
 
 1171  if (max_failures_to_try < 1)
 
 1173      _dbus_test_diag (
"not testing OOM handling");
 
 1177  _dbus_test_diag (
"testing \"%s\" with up to %d consecutive malloc failures",
 
 1178                   description, max_failures_to_try);
 
 1180  i = setting ? max_failures_to_try - 1 : 1;
 
 1181  while (i < max_failures_to_try)
 
 1183      _dbus_test_diag (
"testing \"%s\" with %d consecutive malloc failures",
 
 1184                       description, i + 1);
 
 1186      _dbus_set_fail_alloc_failures (i);
 
 1187      if (!run_failing_each_malloc (approx_mallocs, description, func, data))
 
 1192  _dbus_verbose (
"\"%s\" coped OK with malloc failures\n", description);
 
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
void dbus_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
dbus_bool_t dbus_error_has_name(const DBusError *error, const char *name)
Checks whether the error is set and has the given name.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
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...
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_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
#define _DBUS_LOCK(name)
Locks a global lock, initializing it first if necessary.
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 ...
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
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...
char * _dbus_strdup(const char *str)
Duplicates a string.
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.
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_get_local_machine_uuid_encoded(DBusString *uuid_str, DBusError *error)
Gets the hex-encoded UUID of the machine this function is executed on.
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_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
size_t _dbus_string_array_length(const char **array)
Returns the size of a string array.
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_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
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.
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called,...
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
#define DBUS_ERROR_INVALID_FILE_CONTENT
A file contains invalid syntax or is otherwise broken.
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.
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as _DBUS_STRING_IN...
dbus_bool_t _dbus_string_append_printf_valist(DBusString *str, const char *format, va_list args)
Appends a printf-style formatted string to the DBusString.
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.
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.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
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.
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
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.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
void _dbus_get_real_time(dbus_int64_t *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
_DBUS_GNUC_EXTENSION typedef long dbus_int64_t
A 64-bit signed integer.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
#define DBUS_INT64_MODIFIER
A string literal for a length modifier that is appropriate to print the dbus_int64_t and dbus_uint64_...
Object representing an exception.
const char * name
public error name field
const char * message
public error message field
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values
char as_bytes[DBUS_UUID_LENGTH_BYTES]
guid as 16 single-byte values