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"
34 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
50 #ifdef DBUS_ENABLE_VERBOSE_MODE
62 #ifdef PDPLINUX_USE_FILELOG
65 #define PDPLINUX_LOGCLOSE "!PDPLINUX_LOGCLOSE!"
234 fatal_warnings =
FALSE;
235 fatal_warnings_on_check_failed =
FALSE;
239 fatal_warnings =
TRUE;
240 fatal_warnings_on_check_failed =
TRUE;
244 fprintf(stderr,
"DBUS_FATAL_WARNINGS should be set to 0 or 1 if set, not '%s'",
266 DBusSystemLogSeverity severity = DBUS_SYSTEM_LOG_WARNING;
273 severity = DBUS_SYSTEM_LOG_ERROR;
275 va_start (args, format);
298 DBusSystemLogSeverity severity = DBUS_SYSTEM_LOG_WARNING;
304 if (fatal_warnings_on_check_failed)
305 severity = DBUS_SYSTEM_LOG_ERROR;
307 va_start (args, format);
311 if (fatal_warnings_on_check_failed)
318 #ifdef DBUS_ENABLE_VERBOSE_MODE
323 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
324 static char module_name[1024];
331 #ifdef PDPLINUX_USE_FILELOG
332 static FILE* fdlog=0;
333 static char namelog[1024];
338 _dbus_verbose_init (
void)
340 if (!verbose_initted)
344 verbose = p !=
NULL && *p ==
'1';
345 verbose_initted =
TRUE;
348 #ifdef HAVE_PDPLINUX_FORCE_ENABLE_DBUS_VERBOSE
352 #ifdef PDPLINUX_USE_FILELOG
353 if (!fdlog && verbose){
356 char* textlabel=
NULL;
357 struct tm* timeinfo=
NULL;
361 timeinfo=localtime(&rawtime);
363 snprintf(sttime,
sizeof(sttime),
"notime");
365 strftime (sttime,
sizeof(sttime),
"%F-%H%M%S",timeinfo);
367 pdpl=pdp_get_current();
369 textlabel=pdpl_get_text(pdpl,PDPL_FMT_NUM);
371 if (snprintf(namelog,
sizeof(namelog),
"/dbuslog/dbus-%s-(%s)-%ld",
373 textlabel ? textlabel :
"-",
376 while (
'\0' != *pos && pos <= namelog+
sizeof(namelog)/
sizeof(*namelog)){
377 if (*pos ==
':') *pos=
'-';
381 fdlog=fopen(namelog,
"wt+");
383 if (textlabel) free(textlabel);
384 if (pdpl) pdpl_put(pdpl);
389 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
391 char *last_period, *last_slash;
392 GetModuleFileName(0,module_name,
sizeof(module_name)-1);
393 last_period = _mbsrchr(module_name,
'.');
396 last_slash = _mbsrchr(module_name,
'\\');
398 strcpy(module_name,last_slash+1);
399 strcat(module_name,
": ");
411 #define DBUS_IS_DIR_SEPARATOR(c) (c == '\\' || c == '/')
413 #define DBUS_IS_DIR_SEPARATOR(c) (c == '/')
420 static char *_dbus_file_path_extract_elements_from_tail(
const char *file,
int level)
423 char *p = (
char *)file + strlen(file);
428 if (DBUS_IS_DIR_SEPARATOR(*p))
438 return (
char *)file+prefix;
447 _dbus_is_verbose_real (
void)
449 _dbus_verbose_init ();
473 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
476 const char *
function,
485 FILE* outfile=stderr;
488 #ifdef PDPLINUX_USE_FILELOG
489 if (fdlog) outfile=fdlog;
491 if (strlen(format) ==
sizeof(PDPLINUX_LOGCLOSE)-1 ){
492 if (0 == memcmp(format,PDPLINUX_LOGCLOSE,
sizeof(PDPLINUX_LOGCLOSE))){
493 if (fdlog) fclose(fdlog);
507 if (!_dbus_is_verbose_real())
510 #ifndef DBUS_USE_OUTPUT_DEBUG_STRING
514 _dbus_print_thread ();
517 fprintf (outfile,
"%ld.%06ld ", sec, usec);
522 len = strlen (format);
524 if (format[len-1] ==
'\n')
530 va_start (args, format);
531 #ifdef DBUS_USE_OUTPUT_DEBUG_STRING
534 strcpy(buf,module_name);
535 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
536 sprintf (buf+strlen(buf),
"[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,
function);
538 vsprintf (buf+strlen(buf),format, args);
540 OutputDebugStringA(buf);
543 #ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
544 fprintf (outfile,
"[%s(%d):%s] ",_dbus_file_path_extract_elements_from_tail(file,2),line,
function);
547 vfprintf (outfile, format, args);
562 _dbus_verbose_reset_real (
void)
564 verbose_initted =
FALSE;
568 _dbus_trace_ref (
const char *obj_name,
581 if (old_refcount == -1)
609 _dbus_warn (
"%s should be 0 or 1 if set, not '%s'", env_var, s);
615 if (old_refcount == -1)
617 VALGRIND_PRINTF_BACKTRACE (
"%s %p ref stolen (%s)",
619 _dbus_verbose (
"%s %p ref stolen (%s)\n",
624 VALGRIND_PRINTF_BACKTRACE (
"%s %p %d -> %d refs (%s)",
626 old_refcount, new_refcount, why);
627 _dbus_verbose (
"%s %p %d -> %d refs (%s)\n",
628 obj_name, obj, old_refcount, new_refcount, why);
658 memcpy (copy, str, len + 1);
681 memcpy (copy, mem, n_bytes);
704 for (len = 0; array[len] !=
NULL; ++len)
741 while (array[i] !=
NULL)
743 if (strcmp (array[i], str) == 0)
761 for (i = 0; array[i]; i++) {}
788 uuid->
as_uint32s[DBUS_UUID_LENGTH_WORDS - 1] = DBUS_UINT32_TO_BE (now);
791 DBUS_UUID_LENGTH_BYTES - 4,
795 "Failed to generate UUID: %s", rand_error.
message);
820 _dbus_read_uuid_file_without_creating (
const DBusString *filename,
830 _DBUS_SET_OOM (error);
837 _DBUS_SET_OOM (error);
846 if (_dbus_string_get_length (&contents) != DBUS_UUID_LENGTH_HEX)
849 "UUID file '%s' should contain a hex string of length %d, not length %d, with no other text",
850 _dbus_string_get_const_data (filename),
851 DBUS_UUID_LENGTH_HEX,
852 _dbus_string_get_length (&contents));
858 _DBUS_SET_OOM (error);
865 "UUID file '%s' contains invalid hex data",
866 _dbus_string_get_const_data (filename));
870 if (_dbus_string_get_length (&decoded) != DBUS_UUID_LENGTH_BYTES)
873 "UUID file '%s' contains %d bytes of hex-encoded data instead of %d",
874 _dbus_string_get_const_data (filename),
875 _dbus_string_get_length (&decoded),
876 DBUS_UUID_LENGTH_BYTES);
885 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
890 _DBUS_ASSERT_ERROR_IS_SET (error);
913 _DBUS_SET_OOM (error);
919 _DBUS_SET_OOM (error);
925 _DBUS_SET_OOM (error);
934 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
938 _DBUS_ASSERT_ERROR_IS_SET (error);
961 if (_dbus_read_uuid_file_without_creating (filename, uuid, &read_error))
964 if (!create_if_not_found)
991 static int machine_uuid_initialized_generation = 0;
1013 _DBUS_SET_OOM (error);
1028 _DBUS_SET_OOM (error);
1037 #ifndef DBUS_DISABLE_CHECKS
1039 _dbus_warn_return_if_fail (
const char *
function,
1040 const char *assertion,
1045 "arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n"
1046 "This is normally a bug in some application using the D-Bus library.\n",
1047 function, assertion, file, line);
1051 #ifndef DBUS_DISABLE_ASSERT
1066 const char *condition_text,
1071 if (_DBUS_UNLIKELY (!condition))
1073 _dbus_warn (
"assertion failed \"%s\" file \"%s\" line %d function %s",
1074 condition_text, file, line, func);
1094 _dbus_warn (
"File \"%s\" line %d should not have been reached: %s",
1095 file, line, explanation);
1100 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
1102 run_failing_each_malloc (
int n_mallocs,
1103 const char *description,
1104 DBusTestMemoryFunction func,
1109 while (n_mallocs >= 0)
1111 _dbus_set_fail_alloc_counter (n_mallocs);
1113 _dbus_verbose (
"\n===\n%s: (will fail malloc %d with %d failures)\n===\n",
1114 description, n_mallocs,
1115 _dbus_get_fail_alloc_failures ());
1117 if (!(* func) (data))
1142 _dbus_test_oom_handling (
const char *description,
1143 DBusTestMemoryFunction func,
1147 const char *setting;
1148 int max_failures_to_try;
1155 _dbus_verbose (
"Running once to count mallocs\n");
1157 if (!(* func) (data))
1160 approx_mallocs =
_DBUS_INT_MAX - _dbus_get_fail_alloc_counter ();
1162 _dbus_verbose (
"\n=================\n%s: about %d mallocs total\n=================\n",
1163 description, approx_mallocs);
1166 if (setting !=
NULL)
1173 _dbus_warn (
"couldn't parse '%s' as integer\n", setting);
1174 max_failures_to_try = v;
1178 max_failures_to_try = 4;
1181 if (max_failures_to_try < 1)
1183 _dbus_verbose (
"not testing OOM handling\n");
1187 i = setting ? max_failures_to_try - 1 : 1;
1188 while (i < max_failures_to_try)
1190 _dbus_set_fail_alloc_failures (i);
1191 if (!run_failing_each_malloc (approx_mallocs, description, func, data))
1196 _dbus_verbose (
"\n=================\n%s: all iterations passed\n=================\n",
dbus_bool_t _dbus_uuid_encode(const DBusGUID *uuid, DBusString *encoded)
Hex-encode a UUID.
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.
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
char ** _dbus_dup_string_array(const char **array)
Duplicates a string array.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called,...
dbus_bool_t _dbus_generate_uuid(DBusGUID *uuid, DBusError *error)
Generates a new UUID.
#define _DBUS_INT_MAX
Maximum value of type "int".
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.
#define DBUS_ERROR_INVALID_FILE_CONTENT
A file contains invalid syntax or is otherwise broken.
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
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.
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.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
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.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
#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_string_array_contains(const char **array, const char *str)
Checks whether a string array contains the given string.
#define TRUE
Expands to "1".
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_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
dbus_uint32_t as_uint32s[DBUS_UUID_LENGTH_WORDS]
guid as four uint32 values
const char * _dbus_no_memory_message
Fixed "out of memory" error message, just to avoid making up a different string every time and wastin...
const char * name
public error name field
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.
#define FALSE
Expands to "0".
char as_bytes[DBUS_UUID_LENGTH_BYTES]
guid as 16 single-byte values
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
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.
void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
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...
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
char * _dbus_strdup(const char *str)
Duplicates a string.
Object representing an exception.
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.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
dbus_bool_t _dbus_write_uuid_file(const DBusString *filename, const DBusGUID *uuid, DBusError *error)
Write the give UUID to a file.
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...
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
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 * message
public error message field
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_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
void * _dbus_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
size_t _dbus_string_array_length(const char **array)
Returns the size of a string array.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
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_move_error(DBusError *src, DBusError *dest)
Moves an error src into dest, freeing src and overwriting dest.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
#define NULL
A null pointer, defined appropriately for C or C++.