void test_create_xdg_dirs_when_dotlocal_and_dotconfig_have_not_been_created(void **param)
{
//set temporary directory as HOME in order to ensure that .local and .config do not exist
char *previous_home_dir = strdup(getenv("HOME"));
char temp_home_dir[] = "/tmp/flybyXXXXXXXX";
mkdtemp(temp_home_dir);
setenv("HOME", temp_home_dir, 1);
assert_true(directory_exists(temp_home_dir));
//ensure XDG_*_HOME are empty
setenv("XDG_DATA_HOME", "", 1);
setenv("XDG_CONFIG_HOME", "", 1);
char *data_home_path = xdg_data_home();
char *config_home_path = xdg_config_home();
assert_false(directory_exists(data_home_path));
assert_false(directory_exists(config_home_path));
//ensure that XDG_DATA_HOME and XDG_CONFIG_HOME are as expected
char *expected_data_home_path = add_to_path(temp_home_dir, DEFAULT_XDG_DATA_HOME);
char *expected_config_home_path = add_to_path(temp_home_dir, DEFAULT_XDG_CONFIG_HOME);
assert_string_equal(data_home_path, expected_data_home_path);
assert_string_equal(config_home_path, expected_config_home_path);
free(expected_data_home_path);
free(expected_config_home_path);
//test directory creation
test_create_xdg_dirs();
//revert HOME variable
setenv("HOME", previous_home_dir, 1);
free(previous_home_dir);
//clean up directories
char *data_home_base_path = add_to_path(temp_home_dir, DEFAULT_XDG_DATA_HOME_BASE); //corresponds to (...)/.local
rmdir(data_home_path);
rmdir(data_home_base_path);
rmdir(config_home_path);
rmdir(temp_home_dir);
assert_false(directory_exists(temp_home_dir));
free(data_home_base_path);
free(data_home_path);
free(config_home_path);
}
void TempDir::attach(const string& path)
{
if (!m_path.empty())
remove_directory(m_path);
ASSERT(directory_exists(path));
m_path = path;
}
void create_directory(std::string dir)
{
if (!directory_exists(dir)) {
if (mkdir(dir.c_str(), 0777) == -1) {
LOG(FATAL) << "could not create directory";
}
}
}
TEST(adb_utils, directory_exists) {
#ifdef _WIN32
char profiles_dir[MAX_PATH];
DWORD cch = arraysize(profiles_dir);
// On typical Windows 7, returns C:\Users
ASSERT_TRUE(GetProfilesDirectory(profiles_dir, &cch));
ASSERT_TRUE(directory_exists(profiles_dir));
// On modern (English?) Windows, this is a directory symbolic link to
// C:\ProgramData. Symbolic links are rare on Windows and the user requires
// a special permission (by default granted to Administrative users) to
// create symbolic links.
ASSERT_FALSE(directory_exists(subdir(profiles_dir, "All Users")));
// On modern (English?) Windows, this is a directory junction to
// C:\Users\Default. Junctions are used throughout user profile directories
// for backwards compatibility and they don't require any special permissions
// to create.
ASSERT_FALSE(directory_exists(subdir(profiles_dir, "Default User")));
ASSERT_FALSE(directory_exists(subdir(profiles_dir, "does-not-exist")));
#else
ASSERT_TRUE(directory_exists("/proc"));
ASSERT_FALSE(directory_exists("/proc/self")); // Symbolic link.
ASSERT_FALSE(directory_exists("/proc/does-not-exist"));
#endif
}
static void assert_cache_directory_existence()
{
// We do not consider the cache directory's mode yet. Must be considerd regarding it later.
if(!directory_exists(CACHE_DIRECTORY_PATH))
{
if(!make_directory(CACHE_DIRECTORY_PATH, CACHE_DIRECTORY_PERMISSION_MODE))
int_error("Creating a cache directory failed");
}
}
bool confirm_directory( const std::string &base, const std::string &sub )
{
if ( !directory_exists( base ) )
#ifdef SFML_SYSTEM_WINDOWS
mkdir( base.c_str() );
#else
mkdir( base.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
#endif // SFML_SYSTEM_WINDOWS
if ( (!sub.empty()) && (!directory_exists( base + sub )) )
#ifdef SFML_SYSTEM_WINDOWS
mkdir( (base + sub).c_str() );
#else
mkdir( (base + sub).c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
#endif // SFML_SYSTEM_WINDOWS
return true;
}
int ensure_directory(char *directory) {
if (!directory_exists(directory)) {
if (mkdir(directory, 0777) == -1) {
directory_could_not_be_created_error();
return -1;
}
}
return 0;
}
void PoseEstimator::init()
{
if (!directory_exists(pose_database_path))
create_directory(pose_database_path);
load();
console_log("pose estimator initialized");
}
/* =============== GPL HEADER =====================
* TuxStrings.c is part of TuxDroidServer
* Copyleft (C) 2012 - Joel Matteotti <joel _DOT_ matteotti _AT_ free _DOT_ fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*
* ====================================================
*/
#include <stdlib.h>
#include <unistd.h>
#include <unity.h>
#include "TuxUtils.h"
#define SHELL_COMMAND_LEN 256
#define PATH_LEN 256
char old_cwd[PATH_LEN];
void _saveCWD();
void _restoreCWD();
void _createTemporaryDirectory(char *directory_path);
void _createTemporaryFile(char *file_path);
void _generateTemporaryPath(char *path);
void _createDirectory(char *directory_path);
void _deleteDirectory(char *directory_path);
void _createFile(char *file_path);
void _deleteFile(char *file_path);
void setUp(void)
{
_saveCWD();
}
void tearDown(void)
{
_restoreCWD();
}
#ifndef _WIN32 /* TODO: make windows compatible */
void testGetCurrentDir(void)
{
char current_working_directory[PATH_LEN];
_createTemporaryDirectory(current_working_directory);
chdir(current_working_directory);
char *expected = current_working_directory;
char *result = getCurrentDir();
TEST_ASSERT_EQUAL_STRING(expected, result);
free(result);
_deleteDirectory(current_working_directory);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testFileExistsTrue(void)
{
char temporary_file[PATH_LEN];
_createTemporaryFile(temporary_file);
bool result = file_exists(temporary_file);
TEST_ASSERT_TRUE(result);
_deleteFile(temporary_file);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testFileExistsFalse(void)
{
char temporary_file[PATH_LEN];
_generateTemporaryPath(temporary_file);
bool result = file_exists(temporary_file);
TEST_ASSERT_FALSE(result);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testDirectoryExistsTrue(void)
{
char temporary_directory[PATH_LEN];
_createTemporaryFile(temporary_directory);
bool result = directory_exists(temporary_directory);
TEST_ASSERT_TRUE(result);
_deleteDirectory(temporary_directory);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testDirectoryExistsFalse(void)
{
char temporary_directory[PATH_LEN];
_generateTemporaryPath(temporary_directory);
bool result = directory_exists(temporary_directory);
TEST_ASSERT_FALSE(result);
}
// -----------------------------------------------------------------------------
int main()
{
try
{
auto reference_datum_path = get__reference_datum_path ();
auto action_logs_path = reference_datum_path + L"test-results\\C\\";
wprintf(L"m3_hron - running test cases\r\n");
if (!directory_exists (reference_datum_path))
{
wprintf(L"Exiting due to missing reference datum directory (%s)\r\n", reference_datum_path.c_str ());
return 999;
}
if (!directory_exists (action_logs_path) && !create_directory (action_logs_path))
{
wprintf(L"Exiting due to missing action log directory couldn't be created (%s)\r\n", action_logs_path.c_str ());
return 999;
}
unit_test (reference_datum_path, action_logs_path);
correctness_test (reference_datum_path, action_logs_path);
performance_test (reference_datum_path, action_logs_path);
return 0;
}
catch (exitcode_exception const & e)
{
return e.exitcode;
}
catch (std::exception const & e)
{
wprintf(L"Exiting due to error: %S\r\n", e.what ());
return 999;
}
catch (...)
{
wprintf(L"Exiting due to unrecognized error\r\n");
return 999;
}
}
std::string FileUtils::system_temporary_dir()
{
#ifdef _WIN32
const wchar_t *value;
std::wstring w_path;
std::string path;
if ((value = _wgetenv(L"TMP")) && directory_exists(value)) {
w_path = value;
goto done;
}
if ((value = _wgetenv(L"TEMP")) && directory_exists(value)) {
w_path = value;
goto done;
}
if ((value = _wgetenv(L"LOCALAPPDATA"))) {
w_path = value;
w_path += L"\\Temp";
if (directory_exists(w_path.c_str())) {
goto done;
}
}
if ((value = _wgetenv(L"USERPROFILE"))) {
w_path = value;
w_path += L"\\Temp";
if (directory_exists(w_path.c_str())) {
goto done;
}
}
done:
auto result = wcs_to_utf8(w_path);
return result ? std::move(result.value()) : std::string();
#else
const char *value;
if ((value = getenv("TMPDIR")) && directory_exists(value)) {
return value;
}
if ((value = getenv("TMP")) && directory_exists(value)) {
return value;
}
if ((value = getenv("TEMP")) && directory_exists(value)) {
return value;
}
if ((value = getenv("TEMPDIR")) && directory_exists(value)) {
return value;
}
return "/tmp";
#endif
}
bool install_in_shell(bool global) {
// keep track of the number of files
// that we've written to (should end up being 2)
int wrote_files = 0;
char* script = bash_script();
if (script) {
print_verbose("Writing \"%s\"\n", script);
char *profile_filename = NULL;
if (global) {
//global mode - install in /etc/profile and /etc/bash.bashrc
if (directory_exists("/etc/profile.d")) {
profile_filename = "/etc/profile.d/path.sh";
} else if (file_exists("/etc/profile")) {
profile_filename = "/etc/profile";
}
if (profile_filename) {
if (write_script(profile_filename, script)) wrote_files++;
}
if (file_exists("/etc/bash.bashrc")) {
if (write_script("/etc/bash.bashrc", script)) wrote_files++;
}
} else {
//user mode - install in profile, rc file
char* home_dir = get_home_directory();
int i;
char* profile_search_list[] = {".bash_profile", ".bash_login", ".profile"};
for (i = 0; i < 3; i++) {
char* filename = file_join(home_dir, profile_search_list[i]);
if (file_exists(filename)) {
profile_filename = filename;
break;
}
free(filename);
}
if (!profile_filename) {
profile_filename = file_join(home_dir, profile_search_list[0]);
}
if (write_script(profile_filename, script)) wrote_files++;
free(profile_filename);
char* rc_filename = file_join(home_dir, ".bashrc");
if (write_script(rc_filename, script)) wrote_files++;
free(rc_filename);
free(home_dir);
}
free(script);
}
return wrote_files == 2;
}
// Given a relative or absolute filepath, create the directory hierarchy
// as needed. Returns true if the hierarchy is/was setup.
bool mkdirs(const std::string& path) {
// TODO: all the callers do unlink && mkdirs && adb_creat ---
// that's probably the operation we should expose.
// Implementation Notes:
//
// Pros:
// - Uses dirname, so does not need to deal with OS_PATH_SEPARATOR.
// - On Windows, uses mingw dirname which accepts '/' and '\\', drive letters
// (C:\foo), UNC paths (\\server\share\dir\dir\file), and Unicode (when
// combined with our adb_mkdir() which takes UTF-8).
// - Is optimistic wrt thinking that a deep directory hierarchy will exist.
// So it does as few stat()s as possible before doing mkdir()s.
// Cons:
// - Recursive, so it uses stack space relative to number of directory
// components.
// If path points to a symlink to a directory, that's fine.
struct stat sb;
if (stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) {
return true;
}
const std::string parent(adb_dirname(path));
// If dirname returned the same path as what we passed in, don't go recursive.
// This can happen on Windows when walking up the directory hierarchy and not
// finding anything that already exists (unlike POSIX that will eventually
// find . or /).
if (parent == path) {
errno = ENOENT;
return false;
}
// Recursively make parent directories of 'path'.
if (!mkdirs(parent)) {
return false;
}
// Now that the parent directory hierarchy of 'path' has been ensured,
// create path itself.
if (adb_mkdir(path, 0775) == -1) {
const int saved_errno = errno;
// If someone else created the directory, that is ok.
if (directory_exists(path)) {
return true;
}
// There might be a pre-existing file at 'path', or there might have been some other error.
errno = saved_errno;
return false;
}
return true;
}
/* =============== GPL HEADER =====================
* TuxStrings.c is part of TuxDroidServer
* Copyleft (C) 2012 - Joel Matteotti <joel _DOT_ matteotti _AT_ free _DOT_ fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*
* ====================================================
*/
#include <stdlib.h>
#include <unistd.h>
#include <unity.h>
#include "TuxUtils.h"
#define SHELL_COMMAND_LEN 256
#define PATH_LEN 256
char old_cwd[PATH_LEN];
void _saveCWD();
void _restoreCWD();
void _createTemporaryDirectory(char *directory_path);
void _createTemporaryFile(char *file_path);
void _generateTemporaryPath(char *path);
void _createDirectory(char *directory_path);
void _deleteDirectory(char *directory_path);
void _createFile(char *file_path);
void _deleteFile(char *file_path);
void setUp(void)
{
_saveCWD();
}
void tearDown(void)
{
_restoreCWD();
}
#ifndef _WIN32 /* TODO: make windows compatible */
void testGetCurrentDir(void)
{
char current_working_directory[PATH_LEN];
_createTemporaryDirectory(current_working_directory);
chdir(current_working_directory);
char *expected = current_working_directory;
char *result = getCurrentDir();
TEST_ASSERT_EQUAL_STRING(expected, result);
free(result);
_deleteDirectory(current_working_directory);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testFileExistsTrue(void)
{
char temporary_file[PATH_LEN];
_createTemporaryFile(temporary_file);
bool result = file_exists(temporary_file);
TEST_ASSERT_TRUE(result);
_deleteFile(temporary_file);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testFileExistsFalse(void)
{
char temporary_file[PATH_LEN];
_generateTemporaryPath(temporary_file);
bool result = file_exists(temporary_file);
TEST_ASSERT_FALSE(result);
}
#endif
#ifndef _WIN32 /* TODO: make windows compatible */
void testDirectoryExistsTrue(void)
{
char temporary_directory[PATH_LEN];
_createTemporaryFile(temporary_directory);
bool result = directory_exists(temporary_directory);
TEST_ASSERT_TRUE(result);
_deleteDirectory(temporary_directory);
}
TempDir::TempDir(const string& appName)
{
for (int i=(std::rand()%0xffff); ; ++i) {
m_path = join_path(get_temp_path(),
appName + convert_to<string>(i));
if (!directory_exists(m_path)) {
make_directory(m_path);
break;
}
}
}
void test_create_xdg_dirs_when_xdg_directories_are_arbitrary_and_missing(void **param)
{
//create temporary base directory
char temp_base[] = "/tmp/flybyXXXXXXXX";
mkdtemp(temp_base);
assert_true(directory_exists(temp_base));
//specify XDG directories to something arbitrary in the base directory
char *expected_data_home = add_to_path(temp_base, "arbitrarydata/data/directory");
char *expected_config_home = add_to_path(temp_base, "arbitraryconf/config/directory");
setenv("XDG_DATA_HOME", expected_data_home, 1);
setenv("XDG_CONFIG_HOME", expected_config_home, 1);
assert_false(directory_exists(expected_data_home));
assert_false(directory_exists(expected_config_home));
//test directory creation
test_create_xdg_dirs();
assert_true(directory_exists(expected_data_home));
assert_true(directory_exists(expected_config_home));
free(expected_data_home);
free(expected_config_home);
//cleanup
char *dir;
dir = add_to_path(temp_base, "arbitrarydata/data/directory"); rmdir(dir); free(dir);
dir = add_to_path(temp_base, "arbitrarydata/data"); rmdir(dir); free(dir);
dir = add_to_path(temp_base, "arbitrarydata"); rmdir(dir); free(dir);
dir = add_to_path(temp_base, "arbitraryconf/config/directory"); rmdir(dir); free(dir);
dir = add_to_path(temp_base, "arbitraryconf/config"); rmdir(dir); free(dir);
dir = add_to_path(temp_base, "arbitraryconf"); rmdir(dir); free(dir);
rmdir(temp_base);
assert_false(directory_exists(temp_base));
}
bool check_regression(
std::string const& prefix, Mesh* mesh, Real tol, Real floor) {
auto comm = mesh->comm();
auto goldpath = prefix + ".osh";
if (!directory_exists(goldpath.c_str())) {
if (comm->size() == 1) {
binary::write(goldpath, mesh);
std::cout << "gold path \"" << goldpath << "\" did not exist yet,\n";
std::cout << "created it from this run.\n";
return true;
} else {
auto tmppath = prefix + "_tmp.osh";
binary::write(tmppath, mesh);
if (comm->rank() == 0) {
std::cout << "gold path \"" << goldpath;
std::cout << "\" does not exist and this run is parallel.\n";
std::cout << "If you really want to use this run as the gold, do:\n";
std::cout << " mv \"" << tmppath << "\" \"" << goldpath << "\"\n";
}
return false;
}
}
Mesh gold_mesh(mesh->library());
binary::read(goldpath, comm, &gold_mesh);
auto res = compare_meshes(&gold_mesh, mesh, tol, floor, true);
if (res == OMEGA_H_SAME) {
if (comm->rank() == 0) {
std::cout << "This run matches gold \"" << goldpath << "\"\n";
}
return true;
}
if (res == OMEGA_H_MORE) {
auto newpath = prefix + "_new.osh";
binary::write(newpath, mesh);
if (comm->rank() == 0) {
std::cout << "This run, stored at \"" << newpath << "\",\n";
std::cout << "has more tags than \"" << goldpath << "\"\n";
std::cout << "It should probably be made the new gold, like this:\n";
std::cout << " rm -rf \"" << goldpath << "\"\n";
std::cout << " mv \"" << newpath << "\" \"" << goldpath << "\"\n";
}
return false;
}
auto badpath = prefix + "_bad.osh";
binary::write(badpath, mesh);
if (comm->rank() == 0) {
std::cout << "This run, stored at \"" << badpath << "\",\n";
std::cout << "does not match the gold at \"" << goldpath << "\"\n";
}
return false;
}
/* initialise the settings */
int init_settings()
{
char directory[BLOCK_SIZE];
char command[BLOCK_SIZE];
char subdir[BLOCK_SIZE];
int retval;
settings_directory_name(directory);
if (directory_exists(directory) != 0) return 0;
/* create a .config directory */
sprintf(subdir,"%s%c.config",
getenv("HOME"), DIRECTORY_SEPARATOR);
if (directory_exists(subdir) == 0) {
sprintf(command,"%s %s", COMMAND_MKDIR, subdir);
retval = system(command);
}
sprintf(command,"%s %s", COMMAND_MKDIR, directory);
retval = system(command);
return retval;
}
int main(string args)
{
string file, refrence;
if(!args) return(notify_fail("Syntax: ln <original file> <new refrence>\n"));
if(sscanf(args, "%s %s", file, refrence) != 2)
return(notify_fail("Syntax: ln <original file> <new refrence>\n"));
file = resolve_path(this_player()->query("cwd"), file);
refrence = resolve_path(this_player()->query("cwd"), refrence);
if(!file_exists(file)) return(notify_fail("Error [ln]: File '" + file + "' does not exist.\n"));
if(file_exists(refrence)) return(notify_fail("Error [ln]: File '" + refrence + "' already exists.\n"));
if(directory_exists(file)) return(notify_fail("Error [ln]: '" + file + "' is a directory.\n"));
if(directory_exists(refrence)) return(notify_fail("Error [ln]: '" + refrence + "' is a directory.\n"));
if(!master()->valid_link(file, refrence)) return(notify_fail("Error [ln]: Permission denied.\n"));
write((link(file, refrence) ? "Error [ln]: Linking of file '" + refrence + "' to '" + file + "' was unsuccesful.\n"
: "Success [ln]: File '" + refrence + "' now linked to '" + file + "'.\n" ));
return 1;
}
void test_create_xdg_dirs_when_xdg_directories_are_welldefined(void **param)
{
//create temporary directory for XDG_DATA_HOME and XDG_CONFIG_HOME
char temp_xdg_data_home[] = "/tmp/flybyXXXXXXXX";
mkdtemp(temp_xdg_data_home);
setenv("XDG_DATA_HOME", temp_xdg_data_home, 1);
assert_true(directory_exists(temp_xdg_data_home));
char temp_xdg_config_home[] = "/tmp/flybyXXXXXXXX";
mkdtemp(temp_xdg_config_home);
setenv("XDG_CONFIG_HOME", temp_xdg_config_home, 1);
assert_true(directory_exists(temp_xdg_config_home));
//check that directories can be created correctly
test_create_xdg_dirs();
//cleanup
rmdir(temp_xdg_data_home);
rmdir(temp_xdg_config_home);
assert_false(directory_exists(temp_xdg_data_home));
assert_false(directory_exists(temp_xdg_config_home));
}
static void
removeDeletedFromDirectory(struct directory *directory)
{
int i;
struct dirvec *dv = &directory->children;
for (i = dv->nr; --i >= 0; ) {
if (directory_exists(dv->base[i]))
continue;
g_debug("removing directory: %s", dv->base[i]->path);
delete_directory(dv->base[i]);
modified = true;
}
songvec_for_each(&directory->songs, delete_song_if_removed, directory);
}
void sysfs_export(struct sysfs_def *def, int gpio)
{
static char path[PATH_MAX];
// ensure not already opened (soft_pwm crashes if reopen ??)
snprintf(path, PATH_MAX, "/sys/class/%s/%d", def->class, gpio);
path[PATH_MAX-1] = '\0';
log_assert(!directory_exists(path));
snprintf(path, PATH_MAX, "/sys/class/%s/export", def->class);
path[PATH_MAX-1] = '\0';
static char buffer[15];
sprintf(buffer, "%d", gpio);
write_value(path, buffer);
}
/**
* Check that full flyby config/data directories (XDG_DATA_HOME/flyby/tles,
* XDG_CONFIG_HOME/flyby) can be created given the current definitions of
* XDG_DATA_HOME and XDG_CONFIG_HOME and remove the directories again. Called
* from the test_create_xdg_dirs_when_*-functions.
**/
void test_create_xdg_dirs()
{
//construct expected paths
char *xdg_data_home_basepath = xdg_data_home();
char *xdg_config_home_basepath = xdg_config_home();
char *flyby_config_dir = add_to_path(xdg_config_home_basepath, FLYBY_RELATIVE_ROOT_PATH);
char *flyby_data_dir = add_to_path(xdg_data_home_basepath, FLYBY_RELATIVE_ROOT_PATH);
char *flyby_tle_dir = add_to_path(xdg_data_home_basepath, TLE_RELATIVE_DIR_PATH);
//check that paths do not exist yet
assert_false(directory_exists(flyby_config_dir));
assert_false(directory_exists(flyby_data_dir));
assert_false(directory_exists(flyby_tle_dir));
create_xdg_dirs();
//check that paths have been created
assert_true(directory_exists(flyby_config_dir));
assert_true(directory_exists(flyby_data_dir));
assert_true(directory_exists(flyby_tle_dir));
//cleanup
rmdir(flyby_tle_dir);
rmdir(flyby_data_dir);
rmdir(flyby_config_dir);
assert_false(directory_exists(flyby_config_dir));
assert_false(directory_exists(flyby_data_dir));
assert_false(directory_exists(flyby_tle_dir));
free(flyby_config_dir);
free(flyby_data_dir);
free(flyby_tle_dir);
free(xdg_data_home_basepath);
free(xdg_config_home_basepath);
}
/* Expand a file into a convenient location, nuking it each time */
static char *
expand(char *fname)
{
char *gunzip = "/usr/bin/gunzip";
if (!directory_exists(DOC_TMP_DIR)) {
Mkdir(DOC_TMP_DIR);
if (chown(DOC_TMP_DIR, 0, 0) < 0)
return NULL;
if (chmod(DOC_TMP_DIR, S_IRWXU) < 0)
return NULL;
}
else
unlink(DOC_TMP_FILE);
if (!file_readable(fname) || vsystem("%s < %s > %s", gunzip, fname, DOC_TMP_FILE))
return NULL;
return DOC_TMP_FILE;
}
std::string clean_path( const std::string &path, bool add_trailing_slash )
{
std::string retval = path;
if ( retval.empty() )
return retval;
#ifdef SFML_SYSTEM_WINDOWS
// substitute systemroot leading %SYSTEMROOT%
if (( retval.size() >= 12 )
&& ( retval.compare( 0, 12, "%SYSTEMROOT%" ) == 0 ))
{
std::string sysroot;
str_from_c( sysroot, getenv( "SystemRoot" ) );
retval.replace( 0, 12, sysroot );
}
else if (( retval.size() >= 14 )
&& ( retval.compare( 0, 14, "%PROGRAMFILES%" ) == 0 ))
{
std::string pf;
str_from_c( pf, getenv( "ProgramFiles" ) );
retval.replace( 0, 14, pf );
}
#endif
// substitute home dir for leading ~
if (( retval.size() >= 1 ) && ( retval.compare( 0, 1, "~" ) == 0 ))
retval.replace( 0, 1, get_home_dir() );
// substitute home dir for leading $HOME
if (( retval.size() >= 5 ) && ( retval.compare( 0, 5, "$HOME" ) == 0 ))
retval.replace( 0, 5, get_home_dir() );
if (( add_trailing_slash )
#ifdef SFML_SYSTEM_WINDOWS
&& (retval[retval.size()-1] != '\\')
#endif
&& (retval[retval.size()-1] != '/')
&& (directory_exists(retval)) )
retval += '/';
return retval;
}
mixed GoHome(string str) {
object ob, prev;
string who, room;
prev = environment(this_player());
if( !str || str == "" || !creatorp(this_player())){
who = this_player()->GetKeyName();
}
else who = lower_case(str);
if(!user_exists(who)) return "There's no such user.";
room = PLAYERS_D->GetHomeRoom(who);
if(!room || !strsrch(room, "/tmp/")){
str = user_path(who, 1);
if(!directory_exists(str)) return "That person has no home dir.";
str = user_path(who, 1)+"workroom.c";
arg = str;
if(!unguarded((: file_exists(arg) :)))
return capitalize(who)+" has no active workroom.";
}
static bool remount_partition(int fd, const char* dir) {
if (!directory_exists(dir)) {
return true;
}
std::string dev = find_mount(dir);
if (dev.empty()) {
return true;
}
if (!make_block_device_writable(dev)) {
WriteFdFmt(fd, "remount of %s failed; couldn't make block device %s writable: %s\n",
dir, dev.c_str(), strerror(errno));
return false;
}
if (mount(dev.c_str(), dir, "none", MS_REMOUNT, nullptr) == -1) {
WriteFdFmt(fd, "remount of %s failed: %s\n", dir, strerror(errno));
return false;
}
return true;
}
static LPWSTR make_unpack_dir() {
WCHAR buf[4*MAX_PATH] = {0};
LPWSTR ans = NULL;
if (directory_exists(L"_unpack_calibre_portable"))
rmtree(L"_unpack_calibre_portable");
if (!CreateDirectory(L"_unpack_calibre_portable", NULL) && GetLastError() != ERROR_ALREADY_EXISTS) {
show_last_error(L"Failed to create temporary folder to unpack into");
return ans;
}
if (!GetFullPathName(L"_unpack_calibre_portable", 4*MAX_PATH, buf, NULL)) {
show_last_error(L"Failed to resolve path");
return NULL;
}
ans = _wcsdup(buf);
if (ans == NULL) show_error(L"Out of memory");
return ans;
}
static int sweep_dir(string dir, int when, int verbose, int flag, int test) {
string *contents;
int loop, dinged;
if(!directory_exists(dir)) return 0;
if(verbose) write(bold("Sweeping: " + dir) + "\n");
dinged = 0 ;
contents = get_dir(dir);
if(!contents || !sizeof(contents)) return 0;
// Loop through contents of the subdirectory check for compliance.
for(loop=0; loop<sizeof(contents); loop++) {
if(fail_test(dir, contents[loop], when, flag)) {
dinged ++ ;
call_out( "remove_user", dinged * USER_CALL_TIME, contents[loop],
verbose, flag, test );
}
}
return 1; }
int save_arch()
{
char directory[BLOCK_SIZE];
char arch_directory[BLOCK_SIZE];
char commandstr[BLOCK_SIZE];
int retval=0;
get_setting("directory",directory);
sprintf(arch_directory,"%s%c%s",
directory, DIRECTORY_SEPARATOR,
ARCH_SUBDIR);
/* create a directory for building arch packages */
if (directory_exists(arch_directory)==0) {
sprintf(commandstr,"%s %s",
COMMAND_MKDIR, arch_directory);
retval = system(commandstr);
}
save_PKGBUILD(arch_directory);
save_script(directory);
return retval;
}