/* convenience function, do not reuse outside of TEST */
static dbus_bool_t
make_full_path (const DBusString *test_data_dir,
const char *subdir,
const char *file,
DBusString *full_path)
{
DBusString filename;
dbus_bool_t retval;
retval = FALSE;
if (!_dbus_string_init (full_path))
{
_dbus_warn ("couldn't allocate full path");
goto finish;
}
if (!_dbus_string_copy (test_data_dir, 0, full_path, 0))
{
_dbus_warn ("couldn't allocate full path");
goto finish;
}
_dbus_string_init_const (&filename, subdir);
if (!_dbus_concat_dir_and_file (full_path, &filename))
{
_dbus_warn ("couldn't allocate full path");
goto finish;
}
_dbus_string_free (&filename);
_dbus_string_init_const (&filename, file);
if (!_dbus_concat_dir_and_file (full_path, &filename))
{
_dbus_warn ("couldn't allocate full path");
goto finish;
}
/* woot! */
retval = TRUE;
finish:
_dbus_string_free (&filename);
return retval;
}
BusContext*
bus_context_new_test (const DBusString *test_data_dir,
const char *filename)
{
DBusError error;
DBusString config_file;
DBusString relative;
BusContext *context;
if (!_dbus_string_init (&config_file))
{
_dbus_warn ("No memory\n");
return NULL;
}
if (!_dbus_string_copy (test_data_dir, 0,
&config_file, 0))
{
_dbus_warn ("No memory\n");
_dbus_string_free (&config_file);
return NULL;
}
_dbus_string_init_const (&relative, filename);
if (!_dbus_concat_dir_and_file (&config_file, &relative))
{
_dbus_warn ("No memory\n");
_dbus_string_free (&config_file);
return NULL;
}
dbus_error_init (&error);
context = bus_context_new (&config_file, BUS_CONTEXT_FLAG_NONE, NULL, NULL, NULL, &error);
if (context == NULL)
{
_DBUS_ASSERT_ERROR_IS_SET (&error);
_dbus_warn ("Failed to create debug bus context from configuration file %s: %s\n",
filename, error.message);
dbus_error_free (&error);
_dbus_string_free (&config_file);
return NULL;
}
_dbus_string_free (&config_file);
return context;
}
/** Checks if user is at the console
*
* @param username user to check
* @param error return location for errors
* @returns #TRUE is the user is at the consolei and there are no errors
*/
dbus_bool_t
_dbus_user_at_console (const char *username,
DBusError *error)
{
DBusString u, f;
dbus_bool_t result;
result = FALSE;
if (!_dbus_string_init (&f))
{
_DBUS_SET_OOM (error);
return FALSE;
}
if (!_dbus_string_append (&f, DBUS_CONSOLE_AUTH_DIR))
{
_DBUS_SET_OOM (error);
goto out;
}
_dbus_string_init_const (&u, username);
if (!_dbus_concat_dir_and_file (&f, &u))
{
_DBUS_SET_OOM (error);
goto out;
}
result = _dbus_file_exists (_dbus_string_get_const_data (&f));
out:
_dbus_string_free (&f);
return result;
}
static dbus_bool_t
process_test_subdir (const DBusString *test_base_dir,
const char *subdir,
DBusValidity expected_validity,
DBusForeachMessageFileFunc function,
void *user_data)
{
DBusString test_directory;
DBusString filename;
DBusDirIter *dir;
dbus_bool_t retval;
DBusError error = DBUS_ERROR_INIT;
retval = FALSE;
dir = NULL;
if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
_dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
_dbus_warn ("Could not open %s: %s\n",
_dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
}
printf ("Testing %s:\n", subdir);
next:
while (_dbus_directory_get_next_file (dir, &filename, &error))
{
DBusString full_path;
if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
_dbus_assert_not_reached ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
_dbus_assert_not_reached ("couldn't concat file to dir");
if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
;
else
{
if (_dbus_string_ends_with_c_str (&filename, ".message"))
{
_dbus_warn ("Could not load %s, message builder language no longer supported\n",
_dbus_string_get_const_data (&filename));
}
_dbus_verbose ("Skipping non-.message file %s\n",
_dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
printf (" %s\n",
_dbus_string_get_const_data (&filename));
if (! (*function) (&full_path,
expected_validity, user_data))
{
_dbus_string_free (&full_path);
goto failed;
}
else
_dbus_string_free (&full_path);
}
if (dbus_error_is_set (&error))
{
_dbus_warn ("Could not get next file in %s: %s\n",
_dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
}
retval = TRUE;
failed:
if (dir)
_dbus_directory_close (dir);
_dbus_string_free (&test_directory);
_dbus_string_free (&filename);
return retval;
}
/**
* Split paths into a list of char strings
*
* @param dirs string with pathes
* @param suffix string concated to each path in dirs
* @param dir_list contains a list of splitted pathes
* return #TRUE is pathes could be splittes,#FALSE in oom case
*/
dbus_bool_t
_dbus_split_paths_and_append (DBusString *dirs,
const char *suffix,
DBusList **dir_list)
{
int start;
int i;
int len;
char *cpath;
DBusString file_suffix;
start = 0;
i = 0;
_dbus_string_init_const (&file_suffix, suffix);
len = _dbus_string_get_length (dirs);
while (_dbus_string_find (dirs, start, _DBUS_PATH_SEPARATOR, &i))
{
DBusString path;
if (!_dbus_string_init (&path))
goto oom;
if (!_dbus_string_copy_len (dirs,
start,
i - start,
&path,
0))
{
_dbus_string_free (&path);
goto oom;
}
_dbus_string_chop_white (&path);
/* check for an empty path */
if (_dbus_string_get_length (&path) == 0)
goto next;
if (!_dbus_concat_dir_and_file (&path,
&file_suffix))
{
_dbus_string_free (&path);
goto oom;
}
if (!_dbus_string_copy_data(&path, &cpath))
{
_dbus_string_free (&path);
goto oom;
}
if (!_dbus_list_append (dir_list, cpath))
{
_dbus_string_free (&path);
dbus_free (cpath);
goto oom;
}
next:
_dbus_string_free (&path);
start = i + 1;
}
if (start != len)
{
DBusString path;
if (!_dbus_string_init (&path))
goto oom;
if (!_dbus_string_copy_len (dirs,
start,
len - start,
&path,
0))
{
_dbus_string_free (&path);
goto oom;
}
if (!_dbus_concat_dir_and_file (&path,
&file_suffix))
{
_dbus_string_free (&path);
goto oom;
}
if (!_dbus_string_copy_data(&path, &cpath))
{
_dbus_string_free (&path);
goto oom;
}
if (!_dbus_list_append (dir_list, cpath))
{
_dbus_string_free (&path);
dbus_free (cpath);
goto oom;
}
_dbus_string_free (&path);
}
return TRUE;
oom:
_dbus_list_foreach (dir_list, (DBusForeachFunction)dbus_free, NULL);
_dbus_list_clear (dir_list);
return FALSE;
}
/**
* Tries to interpret the address entry in a platform-specific
* way, creating a platform-specific server type if appropriate.
* Sets error if the result is not OK.
*
* @param entry an address entry
* @param server_p location to store a new DBusServer, or #NULL on failure.
* @param error location to store rationale for failure on bad address
* @returns the outcome
*
*/
DBusServerListenResult
_dbus_server_listen_platform_specific (DBusAddressEntry *entry,
DBusServer **server_p,
DBusError *error)
{
const char *method;
*server_p = NULL;
method = dbus_address_entry_get_method (entry);
if (strcmp (method, "unix") == 0)
{
const char *path = dbus_address_entry_get_value (entry, "path");
const char *tmpdir = dbus_address_entry_get_value (entry, "tmpdir");
const char *abstract = dbus_address_entry_get_value (entry, "abstract");
if (path == NULL && tmpdir == NULL && abstract == NULL)
{
_dbus_set_bad_address(error, "unix",
"path or tmpdir or abstract",
NULL);
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
if ((path && tmpdir) ||
(path && abstract) ||
(tmpdir && abstract))
{
_dbus_set_bad_address(error, NULL, NULL,
"cannot specify two of \"path\" and \"tmpdir\" and \"abstract\" at the same time");
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
if (tmpdir != NULL)
{
DBusString full_path;
DBusString filename;
if (!_dbus_string_init (&full_path))
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
if (!_dbus_string_init (&filename))
{
_dbus_string_free (&full_path);
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
if (!_dbus_string_append (&filename,
"dbus-") ||
!_dbus_generate_random_ascii (&filename, 10) ||
!_dbus_string_append (&full_path, tmpdir) ||
!_dbus_concat_dir_and_file (&full_path, &filename))
{
_dbus_string_free (&full_path);
_dbus_string_free (&filename);
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
/* Always use abstract namespace if possible with tmpdir */
*server_p =
_dbus_server_new_for_domain_socket (_dbus_string_get_const_data (&full_path),
#ifdef HAVE_ABSTRACT_SOCKETS
TRUE,
#else
FALSE,
#endif
error);
_dbus_string_free (&full_path);
_dbus_string_free (&filename);
}
else
{
if (path)
*server_p = _dbus_server_new_for_domain_socket (path, FALSE, error);
else
*server_p = _dbus_server_new_for_domain_socket (abstract, TRUE, error);
}
if (*server_p != NULL)
{
_DBUS_ASSERT_ERROR_IS_CLEAR(error);
return DBUS_SERVER_LISTEN_OK;
}
else
{
_DBUS_ASSERT_ERROR_IS_SET(error);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
}
else if (strcmp (method, "systemd") == 0)
{
int i, n, *fds;
DBusString address;
n = _dbus_listen_systemd_sockets (&fds, error);
if (n < 0)
{
_DBUS_ASSERT_ERROR_IS_SET (error);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
if(!_dbus_string_init(&address))
goto oom;
for (i = 0; i < n; i++)
{
if ( i > 0)
{
if(!_dbus_string_append (&address, ";"))
goto oom;
}
if(!_dbus_append_address_from_socket (fds[i], &address))
goto oom;
}
*server_p = _dbus_server_new_for_socket (fds, n, &address, NULL);
if (*server_p == NULL)
goto oom;
dbus_free (fds);
return DBUS_SERVER_LISTEN_OK;
oom:
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
for (i = 0; i < n; i++)
{
_dbus_close_socket (fds[i], NULL);
}
dbus_free (fds);
_dbus_string_free (&address);
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
#ifdef DBUS_ENABLE_LAUNCHD
else if (strcmp (method, "launchd") == 0)
{
const char *launchd_env_var = dbus_address_entry_get_value (entry, "env");
if (launchd_env_var == NULL)
{
_dbus_set_bad_address (error, "launchd", "env", NULL);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
*server_p = _dbus_server_new_for_launchd (launchd_env_var, error);
if (*server_p != NULL)
{
_DBUS_ASSERT_ERROR_IS_CLEAR(error);
return DBUS_SERVER_LISTEN_OK;
}
else
{
_DBUS_ASSERT_ERROR_IS_SET(error);
return DBUS_SERVER_LISTEN_DID_NOT_CONNECT;
}
}
#endif
else
{
/* If we don't handle the method, we return NULL with the
* error unset
*/
_DBUS_ASSERT_ERROR_IS_CLEAR(error);
return DBUS_SERVER_LISTEN_NOT_HANDLED;
}
}
static BusDesktopFile *
desktop_file_for_name (BusConfigParser *parser,
const char *name,
DBusError *error)
{
BusDesktopFile *desktop_file;
DBusList **service_dirs;
DBusList *link;
DBusError tmp_error;
DBusString full_path;
DBusString filename;
const char *dir;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
desktop_file = NULL;
if (!_dbus_string_init (&filename))
{
BUS_SET_OOM (error);
goto out_all;
}
if (!_dbus_string_init (&full_path))
{
BUS_SET_OOM (error);
goto out_filename;
}
if (!_dbus_string_append (&filename, name) ||
!_dbus_string_append (&filename, ".service"))
{
BUS_SET_OOM (error);
goto out;
}
service_dirs = bus_config_parser_get_service_dirs (parser);
for (link = _dbus_list_get_first_link (service_dirs);
link != NULL;
link = _dbus_list_get_next_link (service_dirs, link))
{
dir = link->data;
_dbus_verbose ("Looking at '%s'\n", dir);
dbus_error_init (&tmp_error);
/* clear the path from last time */
_dbus_string_set_length (&full_path, 0);
/* build the full path */
if (!_dbus_string_append (&full_path, dir) ||
!_dbus_concat_dir_and_file (&full_path, &filename))
{
BUS_SET_OOM (error);
goto out;
}
_dbus_verbose ("Trying to load file '%s'\n", _dbus_string_get_data (&full_path));
desktop_file = bus_desktop_file_load (&full_path, &tmp_error);
if (desktop_file == NULL)
{
_DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
_dbus_verbose ("Could not load %s: %s: %s\n",
_dbus_string_get_const_data (&full_path),
tmp_error.name, tmp_error.message);
/* we may have failed if the file is not found; this is not fatal */
if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
{
dbus_move_error (&tmp_error, error);
/* we only bail out on OOM */
goto out;
}
dbus_error_free (&tmp_error);
}
/* did we find the desktop file we want? */
if (desktop_file != NULL)
break;
}
/* Didn't find desktop file; set error */
if (desktop_file == NULL)
{
dbus_set_error (error, DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND,
"The name %s was not provided by any .service files",
name);
}
out:
_dbus_string_free (&full_path);
out_filename:
_dbus_string_free (&filename);
out_all:
return desktop_file;
}
static dbus_bool_t
process_test_subdir (const DBusString *test_base_dir,
const char *subdir)
{
DBusString test_directory;
DBusString filename;
DBusDirIter *dir;
dbus_bool_t retval;
DBusError error;
retval = FALSE;
dir = NULL;
if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
_dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
_dbus_warn ("Could not open %s: %s\n",
_dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
}
printf ("Testing %s:\n", subdir);
next:
while (_dbus_directory_get_next_file (dir, &filename, &error))
{
DBusString full_path;
if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
_dbus_assert_not_reached ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
_dbus_assert_not_reached ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&filename, ".auth-script"))
{
_dbus_verbose ("Skipping non-.auth-script file %s\n",
_dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
printf (" %s\n", _dbus_string_get_const_data (&filename));
if (!_dbus_auth_script_run (&full_path))
{
_dbus_string_free (&full_path);
goto failed;
}
else
_dbus_string_free (&full_path);
}
if (dbus_error_is_set (&error))
{
_dbus_warn ("Could not get next file in %s: %s\n",
_dbus_string_get_const_data (&test_directory), error.message);
dbus_error_free (&error);
goto failed;
}
retval = TRUE;
failed:
if (dir)
_dbus_directory_close (dir);
_dbus_string_free (&test_directory);
_dbus_string_free (&filename);
return retval;
}
static dbus_bool_t
process_test_valid_subdir (const DBusString *test_base_dir,
const char *subdir,
Validity validity)
{
DBusString test_directory;
DBusString filename;
DBusDirIter *dir;
dbus_bool_t retval;
DBusError error;
retval = FALSE;
dir = NULL;
if (!_dbus_string_init (&test_directory))
_dbus_assert_not_reached ("didn't allocate test_directory\n");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
_dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
_dbus_assert_not_reached ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
_dbus_assert_not_reached ("didn't allocate filename string\n");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
{
_dbus_warn ("Could not open %s: %s\n",
_dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
}
if (validity == VALID)
printf ("Testing valid files:\n");
else if (validity == INVALID)
printf ("Testing invalid files:\n");
else
printf ("Testing unknown files:\n");
next:
while (_dbus_directory_get_next_file (dir, &filename, &error))
{
DBusString full_path;
LoaderOomData d;
if (!_dbus_string_init (&full_path))
_dbus_assert_not_reached ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
_dbus_assert_not_reached ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
_dbus_assert_not_reached ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
_dbus_verbose ("Skipping non-.conf file %s\n",
_dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
goto next;
}
printf (" %s\n", _dbus_string_get_const_data (&filename));
_dbus_verbose (" expecting %s\n",
validity == VALID ? "valid" :
(validity == INVALID ? "invalid" :
(validity == UNKNOWN ? "unknown" : "???")));
d.full_path = &full_path;
d.validity = validity;
/* FIXME hackaround for an expat problem, see
* https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=124747
* http://freedesktop.org/pipermail/dbus/2004-May/001153.html
*/
/* if (!_dbus_test_oom_handling ("config-loader", check_loader_oom_func, &d)) */
if (!check_loader_oom_func (&d))
_dbus_assert_not_reached ("test failed");
_dbus_string_free (&full_path);
}
if (dbus_error_is_set (&error))
{
_dbus_warn ("Could not get next file in %s: %s\n",
_dbus_string_get_const_data (&test_directory),
error.message);
dbus_error_free (&error);
goto failed;
}
retval = TRUE;
failed:
if (dir)
_dbus_directory_close (dir);
_dbus_string_free (&test_directory);
_dbus_string_free (&filename);
return retval;
}
int
main (int argc,
char **argv)
{
DBusString filename;
DBusString dirname;
DBusError tmp_error;
DBusDirIter *dir;
if (argc != 2)
die ("syntax: manual-dir-iter <path>");
dbus_error_init (&tmp_error);
if (!_dbus_string_init (&filename))
oom ("init filename");
if (!_dbus_string_init (&dirname))
oom ("init dirname");
_dbus_string_append (&dirname, argv[1]);
dir = _dbus_directory_open (&dirname, &tmp_error);
if (dir == NULL)
{
fprintf (stderr, "could not open directory: %s: %s\n",
tmp_error.name, tmp_error.message);
exit(1);
}
while (_dbus_directory_get_next_file (dir, &filename, &tmp_error))
{
DBusString full_path;
if (!_dbus_string_init (&full_path))
{
oom ("init full_path");
}
if (!_dbus_string_copy (&dirname, 0, &full_path, 0))
{
oom ("copying full_path to dirname");
}
if (!_dbus_concat_dir_and_file (&full_path, &filename))
{
oom ("concat full_path");
}
debug (_dbus_string_get_const_data (&filename));
_dbus_string_free (&full_path);
}
if (dbus_error_is_set (&tmp_error))
die (tmp_error.message);
_dbus_string_free (&filename);
if (dir)
_dbus_directory_close (dir);
_dbus_verbose ("*** Test dir name exiting\n");
return 0;
}
