static void
test_post_hook (void)
{
if (_dbus_getenv ("DBUS_TEST_SELINUX"))
bus_selinux_shutdown ();
check_memleaks (progname);
}
static void
init_warnings(void)
{
if (!warn_initted)
{
const char *s;
s = _dbus_getenv ("DBUS_FATAL_WARNINGS");
if (s && *s)
{
if (*s == '0')
{
fatal_warnings = FALSE;
fatal_warnings_on_check_failed = FALSE;
}
else if (*s == '1')
{
fatal_warnings = TRUE;
fatal_warnings_on_check_failed = TRUE;
}
else
{
fprintf(stderr, "DBUS_FATAL_WARNINGS should be set to 0 or 1 if set, not '%s'",
s);
}
}
warn_initted = TRUE;
}
}
static void
test_pre_hook (void)
{
if (_dbus_getenv ("DBUS_TEST_SELINUX")
&& (!bus_selinux_pre_init ()
|| !bus_selinux_full_init ()))
die ("could not init selinux support");
}
static inline void
_dbus_verbose_init (void)
{
if (!verbose_initted)
{
const char *p = _dbus_getenv ("DBUS_VERBOSE");
verbose = p != NULL && *p == '1';
verbose_initted = TRUE;
}
}
static void
test_post_hook (void)
{
if (_dbus_getenv ("DBUS_TEST_SELINUX"))
bus_selinux_shutdown ();
check_memleaks (progname);
_dbus_check_fdleaks_leave (initial_fds);
initial_fds = NULL;
}
static void
test_pre_hook (void)
{
if (_dbus_getenv ("DBUS_TEST_SELINUX")
&& (!bus_selinux_pre_init ()
|| !bus_selinux_full_init ()))
die ("could not init selinux support");
initial_fds = _dbus_check_fdleaks_enter ();
}
/**
* Tests how well the given function responds to out-of-memory
* situations. Calls the function repeatedly, failing a different
* call to malloc() each time. If the function ever returns #FALSE,
* the test fails. The function should return #TRUE whenever something
* valid (such as returning an error, or succeeding) occurs, and #FALSE
* if it gets confused in some way.
*
* @param description description of the test used in verbose output
* @param func function to call
* @param data data to pass to function
* @returns #TRUE if the function never returns FALSE
*/
dbus_bool_t
_dbus_test_oom_handling (const char *description,
DBusTestMemoryFunction func,
void *data)
{
int approx_mallocs;
const char *setting;
int max_failures_to_try;
int i;
/* Run once to see about how many mallocs are involved */
_dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
_dbus_verbose ("Running once to count mallocs\n");
if (!(* func) (data))
return FALSE;
approx_mallocs = _DBUS_INT_MAX - _dbus_get_fail_alloc_counter ();
_dbus_verbose ("\n=================\n%s: about %d mallocs total\n=================\n",
description, approx_mallocs);
setting = _dbus_getenv ("DBUS_TEST_MALLOC_FAILURES");
if (setting != NULL)
{
DBusString str;
long v;
_dbus_string_init_const (&str, setting);
v = 4;
if (!_dbus_string_parse_int (&str, 0, &v, NULL))
_dbus_warn ("couldn't parse '%s' as integer\n", setting);
max_failures_to_try = v;
}
else
{
max_failures_to_try = 4;
}
i = setting ? max_failures_to_try - 1 : 1;
while (i < max_failures_to_try)
{
_dbus_set_fail_alloc_failures (i);
if (!run_failing_each_malloc (approx_mallocs, description, func, data))
return FALSE;
++i;
}
_dbus_verbose ("\n=================\n%s: all iterations passed\n=================\n",
description);
return TRUE;
}
/* Cleares the environment, except for DBUS_VERBOSE and DBUS_STARTER_x */
static dbus_bool_t
clear_environment (DBusError *error)
{
const char *debug_env = NULL;
const char *starter_env = NULL;
#ifdef DBUS_ENABLE_VERBOSE_MODE
/* are we debugging */
debug_env = _dbus_getenv ("DBUS_VERBOSE");
#endif
/* we save the starter */
starter_env = _dbus_getenv ("DBUS_STARTER_ADDRESS");
#ifndef ACTIVATION_LAUNCHER_TEST
/* totally clear the environment */
if (!_dbus_clearenv ())
{
dbus_set_error (error, DBUS_ERROR_SPAWN_SETUP_FAILED,
"could not clear environment\n");
return FALSE;
}
#endif
#ifdef DBUS_ENABLE_VERBOSE_MODE
/* restore the debugging environment setting if set */
if (debug_env)
_dbus_setenv ("DBUS_VERBOSE", debug_env);
#endif
/* restore the starter */
if (starter_env)
_dbus_setenv ("DBUS_STARTER_ADDRESS", starter_env);
/* set the type, which must be system if we got this far */
_dbus_setenv ("DBUS_STARTER_BUS_TYPE", "system");
return TRUE;
}
int
main (int argc, char **argv)
{
#ifdef DBUS_BUILD_TESTS
const char *dir;
DBusString config_file;
if (argc > 1)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
if (dir == NULL)
{
fprintf (stderr, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
return 1;
}
printf ("%s: Running launch helper OOM checks\n", argv[0]);
if (!_dbus_string_init (&config_file))
return 1;
if (!_dbus_string_append (&config_file, dir))
return 1;
if (!_dbus_string_append (&config_file, "/valid-config-files-system/debug-allow-all-pass.conf"))
return 1;
/* use a config file that will actually work... */
_dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG",
_dbus_string_get_const_data (&config_file));
_dbus_string_free (&config_file);
if (!_dbus_test_oom_handling ("dbus-daemon-launch-helper",
bus_activation_helper_oom_test,
"org.freedesktop.DBus.TestSuiteEchoService"))
die ("OOM failed");
test_post_hook (argv[0]);
printf ("%s: Success\n", argv[0]);
return 0;
#else /* DBUS_BUILD_TESTS */
printf ("Not compiled with test support\n");
return 0;
#endif
}
static void
_dbus_initialize_malloc_debug (void)
{
if (!debug_initialized)
{
debug_initialized = TRUE;
if (_dbus_getenv ("DBUS_MALLOC_FAIL_NTH") != NULL)
{
fail_nth = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_NTH"));
fail_alloc_counter = fail_nth;
_dbus_verbose ("Will fail dbus_malloc every %d times\n", fail_nth);
}
if (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN") != NULL)
{
fail_size = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN"));
_dbus_verbose ("Will fail mallocs over %ld bytes\n",
(long) fail_size);
}
if (_dbus_getenv ("DBUS_MALLOC_GUARDS") != NULL)
{
guards = TRUE;
_dbus_verbose ("Will use dbus_malloc guards\n");
}
if (_dbus_getenv ("DBUS_DISABLE_MEM_POOLS") != NULL)
{
disable_mem_pools = TRUE;
_dbus_verbose ("Will disable memory pools\n");
}
if (_dbus_getenv ("DBUS_MALLOC_BACKTRACES") != NULL)
{
backtrace_on_fail_alloc = TRUE;
_dbus_verbose ("Will backtrace on failing a dbus_malloc\n");
}
if (_dbus_getenv ("DBUS_MALLOC_CANNOT_FAIL") != NULL)
{
malloc_cannot_fail = TRUE;
_dbus_verbose ("Will abort if system malloc() and friends fail\n");
}
}
}
static dbus_bool_t
get_from_env (char **connection_p,
const char *env_var)
{
const char *s;
_dbus_assert (*connection_p == NULL);
s = _dbus_getenv (env_var);
if (s == NULL || *s == '\0')
return TRUE; /* successfully didn't use the env var */
else
{
*connection_p = _dbus_strdup (s);
return *connection_p != NULL;
}
}
/**
* Aborts the program with SIGABRT (dumping core).
*/
void
_dbus_abort (void)
{
const char *s;
_dbus_print_backtrace ();
s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT");
if (s && *s)
{
/* don't use _dbus_warn here since it can _dbus_abort() */
fprintf (stderr, " Process %lu sleeping for gdb attach\n", _dbus_pid_for_log ());
_dbus_sleep_milliseconds (1000 * 180);
}
abort ();
_dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */
}
static inline void
_dbus_verbose_init (void)
{
if (!verbose_initted)
{
char *p = _dbus_getenv ("DBUS_VERBOSE");
verbose = p != NULL && *p == '1';
verbose_initted = TRUE;
#ifdef USE_OUTPUTDEBUGSTRING
GetModuleFileName(0,module_name,sizeof(module_name)-1);
p = strrchr(module_name,'.');
if (p)
*p ='\0';
p = strrchr(module_name,'\\');
if (p)
strcpy(module_name,p+1);
strcat(module_name,": ");
#endif
}
}
int
main (int argc, char **argv)
{
#ifdef DBUS_BUILD_TESTS
const char *dir;
DBusString test_data_dir;
progname = argv[0];
if (argc > 1)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
if (dir == NULL)
{
fprintf (stderr, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
return 1;
}
_dbus_string_init_const (&test_data_dir, dir);
if (!_dbus_threads_init_debug ())
die ("initializing debug threads");
test_pre_hook ();
printf ("%s: Running config file parser (trivial) test\n", argv[0]);
if (!bus_config_parser_trivial_test (&test_data_dir))
die ("parser");
test_post_hook ();
printf ("%s: Success\n", argv[0]);
return 0;
#else /* DBUS_BUILD_TESTS */
printf ("Not compiled with test support\n");
return 0;
#endif
}
int
main (int argc, char **argv)
{
const char *dir;
DBusString config_file;
if (argc > 1 && strcmp (argv[1], "--tap") != 0)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
if (dir == NULL)
_dbus_test_fatal ("Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable");
_dbus_test_diag ("%s: Running launch helper OOM checks", argv[0]);
if (!_dbus_string_init (&config_file) ||
!_dbus_string_append (&config_file, dir) ||
!_dbus_string_append (&config_file, "/valid-config-files-system/debug-allow-all-pass.conf"))
_dbus_test_fatal ("OOM during initialization");
/* use a config file that will actually work... */
dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG",
_dbus_string_get_const_data (&config_file));
_dbus_string_free (&config_file);
if (!_dbus_test_oom_handling ("dbus-daemon-launch-helper",
bus_activation_helper_oom_test,
(char *) "org.freedesktop.DBus.TestSuiteEchoService"))
_dbus_test_fatal ("OOM test failed");
/* ... otherwise it must have passed */
_dbus_test_ok ("%s", argv[0]);
_dbus_test_check_memleaks (argv[0]);
return _dbus_test_done_testing ();
}
static char *
get_test_exec (const char *exe,
DBusString *scratch_space)
{
const char *dbus_test_exec;
dbus_test_exec = _dbus_getenv ("DBUS_TEST_EXEC");
if (dbus_test_exec == NULL)
dbus_test_exec = DBUS_TEST_EXEC;
if (!_dbus_string_init (scratch_space))
return NULL;
if (!_dbus_string_append_printf (scratch_space, "%s/%s%s",
dbus_test_exec, exe, DBUS_EXEEXT))
{
_dbus_string_free (scratch_space);
return NULL;
}
return _dbus_string_get_data (scratch_space);
}
static inline void
_dbus_verbose_init (void)
{
if (!verbose_initted)
{
const char *p = _dbus_getenv ("DBUS_VERBOSE");
verbose = p != NULL && *p == '1';
verbose_initted = TRUE;
#ifdef DBUS_USE_OUTPUT_DEBUG_STRING
{
char *last_period, *last_slash;
GetModuleFileName(0,module_name,sizeof(module_name)-1);
last_period = _mbsrchr(module_name,'.');
if (last_period)
*last_period ='\0';
last_slash = _mbsrchr(module_name,'\\');
if (last_slash)
strcpy(module_name,last_slash+1);
strcat(module_name,": ");
}
#endif
}
}
/**
* An exported symbol to be run in order to execute
* unit tests. Should not be used by
* any app other than our test app, this symbol
* won't exist in some builds of the library.
* (with --enable-tests=no)
*
* @param test_data_dir the directory with test data (test/data normally)
*/
void
dbus_internal_do_not_use_run_tests (const char *test_data_dir, const char *specific_test)
{
#ifdef DBUS_BUILD_TESTS
if (!_dbus_threads_init_debug ())
die ("debug threads init");
if (test_data_dir == NULL)
test_data_dir = _dbus_getenv ("DBUS_TEST_DATA");
if (test_data_dir != NULL)
printf ("Test data in %s\n", test_data_dir);
else
printf ("No test data!\n");
run_test ("string", specific_test, _dbus_string_test);
run_test ("sysdeps", specific_test, _dbus_sysdeps_test);
run_test ("data-slot", specific_test, _dbus_data_slot_test);
run_test ("misc", specific_test, _dbus_misc_test);
run_test ("address", specific_test, _dbus_address_test);
run_test ("server", specific_test, _dbus_server_test);
run_test ("object-tree", specific_test, _dbus_object_tree_test);
run_test ("signature", specific_test, _dbus_signature_test);
run_test ("marshalling", specific_test, _dbus_marshal_test);
#if 0
printf ("%s: running recursive marshalling tests\n", "dbus-test");
if (!_dbus_marshal_recursive_test ())
die ("recursive marshal");
check_memleaks ();
#else
_dbus_warn ("recursive marshal tests disabled\n");
#endif
run_test ("byteswap", specific_test, _dbus_marshal_byteswap_test);
run_test ("memory", specific_test, _dbus_memory_test);
#if 1
run_test ("mem-pool", specific_test, _dbus_mem_pool_test);
#endif
run_test ("list", specific_test, _dbus_list_test);
run_test ("marshal-validate", specific_test, _dbus_marshal_validate_test);
run_test ("marshal-header", specific_test, _dbus_marshal_header_test);
run_data_test ("message", specific_test, _dbus_message_test, test_data_dir);
run_test ("hash", specific_test, _dbus_hash_test);
#if !defined(DBUS_WINCE)
run_data_test ("spawn", specific_test, _dbus_spawn_test, test_data_dir);
#endif
run_data_test ("credentials", specific_test, _dbus_credentials_test, test_data_dir);
#ifdef DBUS_UNIX
run_data_test ("userdb", specific_test, _dbus_userdb_test, test_data_dir);
#endif
run_test ("keyring", specific_test, _dbus_keyring_test);
#if 0
printf ("%s: running md5 tests\n", "dbus-test");
if (!_dbus_md5_test ())
die ("md5");
check_memleaks ();
#endif
run_data_test ("sha", specific_test, _dbus_sha_test, test_data_dir);
run_data_test ("auth", specific_test, _dbus_auth_test, test_data_dir);
run_data_test ("pending-call", specific_test, _dbus_pending_call_test, test_data_dir);
printf ("%s: completed successfully\n", "dbus-test");
#else
printf ("Not compiled with unit tests, not running any\n");
#endif
}
int
main (int argc, char **argv)
{
#ifdef DBUS_BUILD_TESTS
const char *dir;
const char *only;
DBusString test_data_dir;
progname = argv[0];
if (argc > 1)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
if (argc > 2)
only = argv[2];
else
only = NULL;
if (dir == NULL)
{
fprintf (stderr, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
return 1;
}
_dbus_string_init_const (&test_data_dir, dir);
if (!_dbus_threads_init_debug ())
die ("initializing debug threads");
if (only == NULL || strcmp (only, "expire-list") == 0)
{
test_pre_hook ();
printf ("%s: Running expire list test\n", argv[0]);
if (!bus_expire_list_test (&test_data_dir))
die ("expire list");
test_post_hook ();
}
if (only == NULL || strcmp (only, "config-parser") == 0)
{
test_pre_hook ();
printf ("%s: Running config file parser test\n", argv[0]);
if (!bus_config_parser_test (&test_data_dir))
die ("parser");
test_post_hook ();
}
if (only == NULL || strcmp (only, "signals") == 0)
{
test_pre_hook ();
printf ("%s: Running signals test\n", argv[0]);
if (!bus_signals_test (&test_data_dir))
die ("signals");
test_post_hook ();
}
if (only == NULL || strcmp (only, "dispatch-sha1") == 0)
{
test_pre_hook ();
printf ("%s: Running SHA1 connection test\n", argv[0]);
if (!bus_dispatch_sha1_test (&test_data_dir))
die ("sha1");
test_post_hook ();
}
if (only == NULL || strcmp (only, "dispatch") == 0)
{
test_pre_hook ();
printf ("%s: Running message dispatch test\n", argv[0]);
if (!bus_dispatch_test (&test_data_dir))
die ("dispatch");
test_post_hook ();
}
if (only == NULL || strcmp (only, "activation-service-reload") == 0)
{
test_pre_hook ();
printf ("%s: Running service files reloading test\n", argv[0]);
if (!bus_activation_service_reload_test (&test_data_dir))
die ("service reload");
test_post_hook ();
}
#ifdef HAVE_UNIX_FD_PASSING
if (only == NULL || strcmp (only, "unix-fds-passing") == 0)
{
test_pre_hook ();
printf ("%s: Running unix fd passing test\n", argv[0]);
if (!bus_unix_fds_passing_test (&test_data_dir))
die ("unix fd passing");
test_post_hook ();
}
#endif
printf ("%s: Success\n", argv[0]);
return 0;
#else /* DBUS_BUILD_TESTS */
printf ("Not compiled with test support\n");
return 0;
#endif
}
int
main (int argc, char **argv)
{
#ifdef DBUS_BUILD_TESTS
const char *dir;
DBusString test_data_dir;
progname = argv[0];
if (argc > 1)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
if (dir == NULL)
{
fprintf (stderr, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
return 1;
}
_dbus_string_init_const (&test_data_dir, dir);
#if 0
/* FIXME this is disabled because of thread bugs that need fixing... */
if (!_dbus_threads_init_debug ())
die ("initializing debug threads");
#endif
test_pre_hook ();
printf ("%s: Running expire list test\n", argv[0]);
if (!bus_expire_list_test (&test_data_dir))
die ("expire list");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running config file parser test\n", argv[0]);
if (!bus_config_parser_test (&test_data_dir))
die ("parser");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running policy test\n", argv[0]);
if (!bus_policy_test (&test_data_dir))
die ("policy");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running signals test\n", argv[0]);
if (!bus_signals_test (&test_data_dir))
die ("signals");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running SHA1 connection test\n", argv[0]);
if (!bus_dispatch_sha1_test (&test_data_dir))
die ("sha1");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running message dispatch test\n", argv[0]);
if (!bus_dispatch_test (&test_data_dir))
die ("dispatch");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running service files reloading test\n", argv[0]);
if (!bus_activation_service_reload_test (&test_data_dir))
die ("service reload");
test_post_hook ();
printf ("%s: Success\n", argv[0]);
return 0;
#else /* DBUS_BUILD_TESTS */
printf ("Not compiled with test support\n");
return 0;
#endif
}
int
main (int argc, char **argv)
{
#ifdef DBUS_BUILD_TESTS
const char *dir;
DBusString test_data_dir;
progname = argv[0];
if (argc > 1)
dir = argv[1];
else
dir = _dbus_getenv ("DBUS_TEST_DATA");
dir = "c:\\data\\dbus";
if (dir == NULL)
{
fprintf (stderr, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "Must specify test data directory as argv[1] or in DBUS_TEST_DATA env variable\n");
#endif
return 1;
}
_dbus_string_init_const (&test_data_dir, dir);
if (!_dbus_threads_init_debug ())
die ("initializing debug threads");
test_pre_hook ();
printf ("%s: Running expire list test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running expire list test\n", argv[0]);
#endif
if (!bus_expire_list_test (&test_data_dir))
die ("expire list");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running config file parser test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running config file parser test\n", argv[0]);
#endif
if (!bus_config_parser_test (&test_data_dir))
die ("parser");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running policy test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running policy test\n", argv[0]);
#endif
if (!bus_policy_test (&test_data_dir))
die ("policy");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running signals test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running signals test\n", argv[0]);
#endif
if (!bus_signals_test (&test_data_dir))
die ("signals");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running SHA1 connection test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running SHA1 connection test\n", argv[0]);
#endif
if (!bus_dispatch_sha1_test (&test_data_dir))
die ("sha1");
test_post_hook ();
test_pre_hook ();
printf ("%s: Running service files reloading test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running service files reloading test\n", argv[0]);
#endif
if (!bus_activation_service_reload_test (&test_data_dir))
die ("service reload");
test_post_hook ();
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running message dispatch test\n", argv[0]);
#endif
test_pre_hook ();
printf ("%s: Running message dispatch test\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Running message dispatch test\n", argv[0]);
#endif
if (!bus_dispatch_test (&test_data_dir))
die ("dispatch");
/*2 bytes of memory leak to be investigated*/
//test_post_hook ();
printf ("%s: Success\n", argv[0]);
#ifdef __SYMBIAN32__
std_log(LOG_FILENAME_LINE, "%s: Success\n", argv[0]);
create_xml(0);
#endif
return 0;
#else /* DBUS_BUILD_TESTS */
printf ("Not compiled with test support\n");
return 0;
#endif
}
DBusServer *
_dbus_server_new_for_launchd (const char *launchd_env_var, DBusError * error)
{
#ifdef DBUS_ENABLE_LAUNCHD
DBusServer *server;
DBusString address;
int launchd_fd;
launch_data_t sockets_dict, checkin_response;
launch_data_t checkin_request;
launch_data_t listening_fd_array, listening_fd;
launch_data_t environment_dict, environment_param;
const char *launchd_socket_path, *display;
launchd_socket_path = _dbus_getenv (launchd_env_var);
display = _dbus_getenv ("DISPLAY");
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
if (launchd_socket_path == NULL || *launchd_socket_path == '\0')
{
dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
"launchd's environment variable %s is empty, but should contain a socket path.\n", launchd_env_var);
return NULL;
}
if (!_dbus_string_init (&address))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
if (!_dbus_string_append (&address, "unix:path="))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto l_failed_0;
}
if (!_dbus_string_append (&address, launchd_socket_path))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto l_failed_0;
}
if ((checkin_request = launch_data_new_string (LAUNCH_KEY_CHECKIN)) == NULL)
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
"launch_data_new_string(\"%s\") Unable to create string.\n",
LAUNCH_KEY_CHECKIN);
goto l_failed_0;
}
if ((checkin_response = launch_msg (checkin_request)) == NULL)
{
dbus_set_error (error, DBUS_ERROR_IO_ERROR,
"launch_msg(\"%s\") IPC failure: %s\n",
LAUNCH_KEY_CHECKIN, strerror (errno));
goto l_failed_0;
}
if (LAUNCH_DATA_ERRNO == launch_data_get_type (checkin_response))
{
dbus_set_error (error, DBUS_ERROR_FAILED, "Check-in failed: %s\n",
strerror (launch_data_get_errno (checkin_response)));
goto l_failed_0;
}
sockets_dict =
launch_data_dict_lookup (checkin_response, LAUNCH_JOBKEY_SOCKETS);
if (NULL == sockets_dict)
{
dbus_set_error (error, DBUS_ERROR_IO_ERROR,
"No sockets found to answer requests on!\n");
goto l_failed_0;
}
listening_fd_array =
launch_data_dict_lookup (sockets_dict, "unix_domain_listener");
if (NULL == listening_fd_array)
{
dbus_set_error (error, DBUS_ERROR_IO_ERROR,
"No known sockets found to answer requests on!\n");
goto l_failed_0;
}
if (launch_data_array_get_count (listening_fd_array) != 1)
{
dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
"Expected 1 socket from launchd, got %d.\n",
launch_data_array_get_count (listening_fd_array));
goto l_failed_0;
}
listening_fd = launch_data_array_get_index (listening_fd_array, 0);
launchd_fd = launch_data_get_fd (listening_fd);
_dbus_fd_set_close_on_exec (launchd_fd);
if (launchd_fd < 0)
{
_DBUS_ASSERT_ERROR_IS_SET (error);
goto l_failed_0;
if (display == NULL || *display == '\0')
{
environment_dict = launch_data_dict_lookup (checkin_response, LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES);
if (NULL == environment_dict)
{
_dbus_warn ("Unable to retrieve user environment from launchd.");
}
else
{
environment_param = launch_data_dict_lookup (environment_dict, "DISPLAY");
if (NULL == environment_param)
{
_dbus_warn ("Unable to retrieve DISPLAY from launchd.");
}
else
{
display = launch_data_get_string(environment_param);
dbus_setenv ("DISPLAY", display);
}
}
}
}
server = _dbus_server_new_for_socket (&launchd_fd, 1, &address, 0);
if (server == NULL)
{
dbus_set_error (error, DBUS_ERROR_NO_SERVER,
"Unable to listen on launchd fd %d.", launchd_fd);
goto l_failed_0;
}
_dbus_string_free (&address);
return server;
l_failed_0:
_dbus_string_free (&address);
return NULL;
#else /* DBUS_ENABLE_LAUNCHD */
dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
"address type 'launchd' requested, but launchd support not compiled in");
return NULL;
#endif
}
static dbus_bool_t
init_connections_unlocked (void)
{
if (!initialized)
{
const char *s;
int i;
i = 0;
while (i < N_BUS_TYPES)
{
bus_connections[i] = NULL;
++i;
}
/* Don't init these twice, we may run this code twice if
* init_connections_unlocked() fails midway through.
* In practice, each block below should contain only one
* "return FALSE" or running through twice may not
* work right.
*/
if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
{
_dbus_verbose ("Filling in system bus address...\n");
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM],
"DBUS_SYSTEM_BUS_ADDRESS"))
return FALSE;
}
if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
{
/* Use default system bus address if none set in environment */
bus_connection_addresses[DBUS_BUS_SYSTEM] =
_dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS);
if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
return FALSE;
_dbus_verbose (" used default system bus \"%s\"\n",
bus_connection_addresses[DBUS_BUS_SYSTEM]);
}
else
_dbus_verbose (" used env var system bus \"%s\"\n",
bus_connection_addresses[DBUS_BUS_SYSTEM]);
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
{
_dbus_verbose ("Filling in session bus address...\n");
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION],
"DBUS_SESSION_BUS_ADDRESS"))
return FALSE;
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
bus_connection_addresses[DBUS_BUS_SESSION] =
_dbus_strdup (DBUS_SESSION_BUS_DEFAULT_ADDRESS);
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
return FALSE;
_dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?
bus_connection_addresses[DBUS_BUS_SESSION] : "none set");
}
if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)
{
_dbus_verbose ("Filling in activation bus address...\n");
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_STARTER],
"DBUS_STARTER_ADDRESS"))
return FALSE;
_dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_STARTER] ?
bus_connection_addresses[DBUS_BUS_STARTER] : "none set");
}
if (bus_connection_addresses[DBUS_BUS_STARTER] != NULL)
{
s = _dbus_getenv ("DBUS_STARTER_BUS_TYPE");
if (s != NULL)
{
_dbus_verbose ("Bus activation type was set to \"%s\"\n", s);
if (strcmp (s, "system") == 0)
activation_bus_type = DBUS_BUS_SYSTEM;
else if (strcmp (s, "session") == 0)
activation_bus_type = DBUS_BUS_SESSION;
}
}
else
{
/* Default to the session bus instead if available */
if (bus_connection_addresses[DBUS_BUS_SESSION] != NULL)
{
bus_connection_addresses[DBUS_BUS_STARTER] =
_dbus_strdup (bus_connection_addresses[DBUS_BUS_SESSION]);
if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)
return FALSE;
}
}
/* If we return FALSE we have to be sure that restarting
* the above code will work right
*/
if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", NULL))
return FALSE;
if (!_dbus_setenv ("DBUS_ACTIVATION_BUS_TYPE", NULL))
return FALSE;
if (!_dbus_register_shutdown_func (addresses_shutdown_func,
NULL))
return FALSE;
initialized = TRUE;
}
return initialized;
}
void
_dbus_trace_ref (const char *obj_name,
void *obj,
int old_refcount,
int new_refcount,
const char *why,
const char *env_var,
int *enabled)
{
_dbus_assert (obj_name != NULL);
_dbus_assert (obj != NULL);
_dbus_assert (old_refcount >= -1);
_dbus_assert (new_refcount >= -1);
if (old_refcount == -1)
{
_dbus_assert (new_refcount == -1);
}
else
{
_dbus_assert (new_refcount >= 0);
_dbus_assert (old_refcount >= 0);
_dbus_assert (old_refcount > 0 || new_refcount > 0);
}
_dbus_assert (why != NULL);
_dbus_assert (env_var != NULL);
_dbus_assert (enabled != NULL);
if (*enabled < 0)
{
const char *s = _dbus_getenv (env_var);
*enabled = FALSE;
if (s && *s)
{
if (*s == '0')
*enabled = FALSE;
else if (*s == '1')
*enabled = TRUE;
else
_dbus_warn ("%s should be 0 or 1 if set, not '%s'", env_var, s);
}
}
if (*enabled)
{
if (old_refcount == -1)
{
VALGRIND_PRINTF_BACKTRACE ("%s %p ref stolen (%s)",
obj_name, obj, why);
_dbus_verbose ("%s %p ref stolen (%s)\n",
obj_name, obj, why);
}
else
{
VALGRIND_PRINTF_BACKTRACE ("%s %p %d -> %d refs (%s)",
obj_name, obj,
old_refcount, new_refcount, why);
_dbus_verbose ("%s %p %d -> %d refs (%s)\n",
obj_name, obj, old_refcount, new_refcount, why);
}
}
}
/**
* Does the chdir, fork, setsid, etc. to become a daemon process.
*
* @param pidfile #NULL, or pidfile to create
* @param print_pid_pipe pipe to print daemon's pid to, or -1 for none
* @param error return location for errors
* @param keep_umask #TRUE to keep the original umask
* @returns #FALSE on failure
*/
dbus_bool_t
_dbus_become_daemon (const DBusString *pidfile,
DBusPipe *print_pid_pipe,
DBusError *error,
dbus_bool_t keep_umask)
{
const char *s;
pid_t child_pid;
int dev_null_fd;
_dbus_verbose ("Becoming a daemon...\n");
_dbus_verbose ("chdir to /\n");
if (chdir ("/") < 0)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
"Could not chdir() to root directory");
return FALSE;
}
_dbus_verbose ("forking...\n");
switch ((child_pid = fork ()))
{
case -1:
_dbus_verbose ("fork failed\n");
dbus_set_error (error, _dbus_error_from_errno (errno),
"Failed to fork daemon: %s", _dbus_strerror (errno));
return FALSE;
break;
case 0:
_dbus_verbose ("in child, closing std file descriptors\n");
/* silently ignore failures here, if someone
* doesn't have /dev/null we may as well try
* to continue anyhow
*/
dev_null_fd = open ("/dev/null", O_RDWR);
if (dev_null_fd >= 0)
{
dup2 (dev_null_fd, 0);
dup2 (dev_null_fd, 1);
s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
if (s == NULL || *s == '\0')
dup2 (dev_null_fd, 2);
else
_dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
close (dev_null_fd);
}
if (!keep_umask)
{
/* Get a predictable umask */
_dbus_verbose ("setting umask\n");
umask (022);
}
_dbus_verbose ("calling setsid()\n");
if (setsid () == -1)
_dbus_assert_not_reached ("setsid() failed");
break;
default:
if (!_dbus_write_pid_to_file_and_pipe (pidfile, print_pid_pipe,
child_pid, error))
{
_dbus_verbose ("pid file or pipe write failed: %s\n",
error->message);
kill (child_pid, SIGTERM);
return FALSE;
}
_dbus_verbose ("parent exiting\n");
_exit (0);
break;
}
return TRUE;
}
dbus_bool_t
_dbus_become_daemon (const DBusString *pidfile,
int print_pid_fd,
DBusError *error)
{
const char *s;
pid_t child_pid;
int dev_null_fd;
_dbus_verbose ("Becoming a daemon...\n");
_dbus_verbose ("chdir to /\n");
if (chdir ("/") < 0)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
"Could not chdir() to root directory");
return FALSE;
}
_dbus_verbose ("forking...\n");
switch ((child_pid = fork ()))
{
case -1:
_dbus_verbose ("fork failed\n");
dbus_set_error (error, _dbus_error_from_errno (errno),
"Failed to fork daemon: %s", _dbus_strerror (errno));
return FALSE;
break;
case 0:
_dbus_verbose ("in child, closing std file descriptors\n");
/* silently ignore failures here, if someone
* doesn't have /dev/null we may as well try
* to continue anyhow
*/
dev_null_fd = open ("/dev/null", O_RDWR);
if (dev_null_fd >= 0)
{
dup2 (dev_null_fd, 0);
dup2 (dev_null_fd, 1);
s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
if (s == NULL || *s == '\0')
dup2 (dev_null_fd, 2);
else
_dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
}
/* Get a predictable umask */
_dbus_verbose ("setting umask\n");
umask (022);
break;
default:
if (pidfile)
{
_dbus_verbose ("parent writing pid file\n");
if (!_dbus_write_pid_file (pidfile,
child_pid,
error))
{
_dbus_verbose ("pid file write failed, killing child\n");
kill (child_pid, SIGTERM);
return FALSE;
}
}
/* Write PID if requested */
if (print_pid_fd >= 0)
{
DBusString pid;
int bytes;
if (!_dbus_string_init (&pid))
{
_DBUS_SET_OOM (error);
kill (child_pid, SIGTERM);
return FALSE;
}
if (!_dbus_string_append_int (&pid, child_pid) ||
!_dbus_string_append (&pid, "\n"))
{
_dbus_string_free (&pid);
_DBUS_SET_OOM (error);
kill (child_pid, SIGTERM);
return FALSE;
}
bytes = _dbus_string_get_length (&pid);
if (_dbus_write_socket (print_pid_fd, &pid, 0, bytes) != bytes)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
"Printing message bus PID: %s\n",
_dbus_strerror (errno));
_dbus_string_free (&pid);
kill (child_pid, SIGTERM);
return FALSE;
}
_dbus_string_free (&pid);
}
_dbus_verbose ("parent exiting\n");
_exit (0);
break;
}
_dbus_verbose ("calling setsid()\n");
if (setsid () == -1)
_dbus_assert_not_reached ("setsid() failed");
return TRUE;
}
static dbus_bool_t
get_correct_parser (BusConfigParser **parser, DBusError *error)
{
DBusString config_file;
dbus_bool_t retval;
#ifdef ACTIVATION_LAUNCHER_TEST
const char *test_config_file;
#endif
retval = FALSE;
#ifdef ACTIVATION_LAUNCHER_TEST
test_config_file = NULL;
/* there is no _way_ we should be setuid if this define is set.
* but we should be doubly paranoid and check... */
if (getuid() != geteuid())
_dbus_assert_not_reached ("dbus-daemon-launch-helper-test binary is setuid!");
/* this is not a security hole. The environment variable is only passed in the
* dbus-daemon-lauch-helper-test NON-SETUID launcher */
test_config_file = _dbus_getenv ("TEST_LAUNCH_HELPER_CONFIG");
if (test_config_file == NULL)
{
dbus_set_error (error, DBUS_ERROR_SPAWN_SETUP_FAILED,
"the TEST_LAUNCH_HELPER_CONFIG env variable is not set");
goto out;
}
#endif
/* we _only_ use the predefined system config file */
if (!_dbus_string_init (&config_file))
{
BUS_SET_OOM (error);
goto out;
}
#ifndef ACTIVATION_LAUNCHER_TEST
if (!_dbus_string_append (&config_file, DBUS_SYSTEM_CONFIG_FILE))
{
BUS_SET_OOM (error);
goto out_free_config;
}
#else
if (!_dbus_string_append (&config_file, test_config_file))
{
BUS_SET_OOM (error);
goto out_free_config;
}
#endif
/* where are we pointing.... */
_dbus_verbose ("dbus-daemon-activation-helper: using config file: %s\n",
_dbus_string_get_const_data (&config_file));
/* get the dbus user */
*parser = bus_config_load (&config_file, TRUE, NULL, error);
if (*parser == NULL)
{
goto out_free_config;
}
/* woot */
retval = TRUE;
out_free_config:
_dbus_string_free (&config_file);
out:
return retval;
}
