static void test_mkdir_twice(abts_case *tc, void *data)
{
apr_status_t rv;
rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EEXIST(rv));
rv = apr_dir_remove("data/testdir", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
/* Test for a (fixed) bug in apr_dir_read(). This bug only happened
in threadless cases. */
static void test_uncleared_errno(abts_case *tc, void *data)
{
apr_file_t *thefile = NULL;
apr_finfo_t finfo;
apr_int32_t finfo_flags = APR_FINFO_TYPE | APR_FINFO_NAME;
apr_dir_t *this_dir;
apr_status_t rv;
rv = apr_dir_make("dir1", APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_make("dir2", APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&thefile, "dir1/file1",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_close(thefile);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Try to remove dir1. This should fail because it's not empty.
However, on a platform with threads disabled (such as FreeBSD),
`errno' will be set as a result. */
rv = apr_dir_remove("dir1", p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOTEMPTY(rv));
/* Read `.' and `..' out of dir2. */
rv = apr_dir_open(&this_dir, "dir2", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Now, when we attempt to do a third read of empty dir2, and the
underlying system readdir() returns NULL, the old value of
errno shouldn't cause a false alarm. We should get an ENOENT
back from apr_dir_read, and *not* the old errno. */
rv = apr_dir_read(&finfo, finfo_flags, this_dir);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOENT(rv));
rv = apr_dir_close(this_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Cleanup */
rv = apr_file_remove("dir1/file1", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_remove("dir1", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_dir_remove("dir2", p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
/*
* change directory for gprof to plop the gmon.out file
* configure in httpd.conf:
* GprofDir $RuntimeDir/ -> $ServerRoot/$RuntimeDir/gmon.out
* GprofDir $RuntimeDir/% -> $ServerRoot/$RuntimeDir/gprof.$pid/gmon.out
*/
static void chdir_for_gprof(void)
{
core_server_config *sconf =
ap_get_module_config(ap_server_conf->module_config, &core_module);
char *dir = sconf->gprof_dir;
const char *use_dir;
if(dir) {
apr_status_t res;
char buf[512];
int len = strlen(sconf->gprof_dir) - 1;
if(*(dir + len) == '%') {
dir[len] = '\0';
apr_snprintf(buf, sizeof(buf), "%sgprof.%d", dir, (int)getpid());
}
use_dir = ap_server_root_relative(pconf, buf[0] ? buf : dir);
res = apr_dir_make(use_dir, 0755, pconf);
if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
ap_log_error(APLOG_MARK, APLOG_ERR, errno, ap_server_conf,
"gprof: error creating directory %s", dir);
}
}
else {
use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
}
chdir(use_dir);
}
static int resource_manager_atached(request_rec *r)
{
mrm_config_t *conf = ap_get_module_config(r->server->module_config, &resource_manager_module);
if (strcmp(apr_table_get(r->headers_in, "HOST"), conf->host) == 0) {
manage_dir = apr_psprintf(r->pool, "%s/%s", CGROUP_APACHE_ROOT, conf->host);
manage_file = apr_psprintf(r->pool, "%s/tasks", manage_dir);
manage_cpu = apr_psprintf(r->pool, "%s/cpu.cfs_quota_us", manage_dir);
apr_dir_make(manage_dir, APR_OS_DEFAULT, r->pool);
if(apr_file_open(&manage_fp, manage_file, APR_WRITE, APR_OS_DEFAULT, r->pool) != APR_SUCCESS){
return OK;
}
apr_file_printf(manage_fp, "%d\n", getpid());
apr_file_flush(manage_fp);
apr_file_close(manage_fp);
if(apr_file_open(&manage_fp, manage_cpu, APR_WRITE, APR_OS_DEFAULT, r->pool) != APR_SUCCESS){
return OK;
}
cpurate_from_mruby(r);
apr_file_printf(manage_fp, "%ld\n", conf->cpurate);
apr_file_flush(manage_fp);
apr_file_close(manage_fp);
}
return DECLINED;
}
/*
* change directory for gprof to plop the gmon.out file
* configure in httpd.conf:
* GprofDir $RuntimeDir/ -> $ServerRoot/$RuntimeDir/gmon.out
* GprofDir $RuntimeDir/% -> $ServerRoot/$RuntimeDir/gprof.$pid/gmon.out
*/
static void chdir_for_gprof(void)
{
core_server_config *sconf =
ap_get_module_config(ap_server_conf->module_config, &core_module);
char *dir = sconf->gprof_dir;
const char *use_dir;
if(dir) {
apr_status_t res;
char *buf = NULL ;
int len = strlen(sconf->gprof_dir) - 1;
if(*(dir + len) == '%') {
dir[len] = '\0';
buf = ap_append_pid(pconf, dir, "gprof.");
}
use_dir = ap_server_root_relative(pconf, buf ? buf : dir);
res = apr_dir_make(use_dir,
APR_UREAD | APR_UWRITE | APR_UEXECUTE |
APR_GREAD | APR_GEXECUTE |
APR_WREAD | APR_WEXECUTE, pconf);
if(res != APR_SUCCESS && !APR_STATUS_IS_EEXIST(res)) {
ap_log_error(APLOG_MARK, APLOG_ERR, res, ap_server_conf,
"gprof: error creating directory %s", dir);
}
}
else {
use_dir = ap_server_root_relative(pconf, DEFAULT_REL_RUNTIMEDIR);
}
chdir(use_dir);
}
void test_client_setup(CuTest *tc) {
aos_pool_t *p;
aos_pool_create(&p, NULL);
apr_dir_make(TEST_DIR"/data/", APR_OS_DEFAULT, p);
aos_pool_destroy(p);
}
/* ### does this belong here or in dav_fs_repos.c ?? */
void dav_fs_ensure_state_dir(apr_pool_t * p, const char *dirname)
{
const char *pathname = apr_pstrcat(p, dirname, "/" DAV_FS_STATE_DIR, NULL);
/* ### do we need to deal with the umask? */
/* just try to make it, ignoring any resulting errors */
(void) apr_dir_make(pathname, APR_OS_DEFAULT, p);
}
bool make(const std::string& path, int perms, bool recursive){
apr_fileperms_t apr_perms = APR_FPROT_UREAD | APR_FPROT_UWRITE | APR_FPROT_UEXECUTE;
if(recursive){
return APR_SUCCESS == check_apr(apr_dir_make_recursive(path.c_str(), apr_perms, mPool));
}
else {
return APR_SUCCESS == check_apr(apr_dir_make(path.c_str(), apr_perms, mPool));
}
}
static void test_mkdir(abts_case *tc, void *data)
{
apr_status_t rv;
apr_finfo_t finfo;
rv = apr_dir_make("data/testdir", APR_UREAD | APR_UWRITE | APR_UEXECUTE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_stat(&finfo, "data/testdir", APR_FINFO_TYPE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, APR_DIR, finfo.filetype);
}
bool ll_apr_dir_make(const std::string& dirname, apr_pool_t* pool)
{
apr_status_t s;
if (pool == NULL) pool = gAPRPoolp;
s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool);
if (s != APR_SUCCESS)
{
LL_DEBUGS("APR") << "ll_apr_dir_make failed on file: " << dirname << LL_ENDL;
ll_apr_warn_status(s);
return false;
}
return true;
}
int lua_apr_dir_make(lua_State *L)
{
apr_status_t status;
apr_pool_t *memory_pool;
const char *filepath;
apr_fileperms_t permissions;
memory_pool = to_pool(L);
filepath = luaL_checkstring(L, 1);
permissions = check_permissions(L, 2, 0);
status = apr_dir_make(filepath, permissions, memory_pool);
return push_status(L, status);
}
//static
bool LLAPRFile::makeDir(const std::string& dirname)
{
apr_status_t s;
LLScopedVolatileAPRFilePool pool;
s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool);
if (s != APR_SUCCESS)
{
ll_apr_warn_status(s);
LL_WARNS("APR") << " while attempting to make directory: " << dirname << LL_ENDL;
return false;
}
return true;
}
//static
bool LLAPRFile::makeDir(const std::string& dirname, LLVolatileAPRPool* pool)
{
apr_status_t s;
pool = pool ? pool : LLAPRFile::sAPRFilePoolp ;
s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool->getVolatileAPRPool());
pool->clearVolatileAPRPool() ;
if (s != APR_SUCCESS)
{
LL_DEBUGS("APR") << "LLAPRFile::makeDir failed on file: " << dirname << LL_ENDL;
ll_apr_warn_status(s);
return false;
}
return true;
}
//static
bool LLAPRFile::makeDir(const std::string& dirname, LLVolatileAPRPool* pool)
{
apr_status_t s;
pool = pool ? pool : LLAPRFile::sAPRFilePoolp ;
s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool->getVolatileAPRPool());
pool->clearVolatileAPRPool() ;
if (s != APR_SUCCESS)
{
ll_apr_warn_status(s);
LL_WARNS("APR") << " Attempting to make directory: " << dirname << LL_ENDL;
return false;
}
return true;
}
void UploadItemIO::prepare_subdir(apr_pool_t *pool, const char *dir_path,
apr_size_t item_id)
{
apr_finfo_t info;
const char *sub_dir_path;
sub_dir_path = get_sub_dir_path(pool, dir_path, item_id);
if (!APR_STATUS_IS_ENOENT(apr_stat(&info, sub_dir_path, APR_FINFO_MIN,
pool))) {
return;
}
if (apr_dir_make(sub_dir_path, APR_OS_DEFAULT, pool) != APR_SUCCESS) {
THROW(MESSAGE_UPLOAD_ITEM_SUB_DIR_CREATION_FAILED);
}
}
static void test_rmkdir_nocwd(abts_case *tc, void *data)
{
char *cwd, *path;
APR_ASSERT_SUCCESS(tc, "make temp dir",
apr_dir_make("dir3", APR_OS_DEFAULT, p));
APR_ASSERT_SUCCESS(tc, "obtain cwd", apr_filepath_get(&cwd, 0, p));
APR_ASSERT_SUCCESS(tc, "determine path to temp dir",
apr_filepath_merge(&path, cwd, "dir3", 0, p));
APR_ASSERT_SUCCESS(tc, "change to temp dir", apr_filepath_set(path, p));
APR_ASSERT_SUCCESS(tc, "restore cwd", apr_filepath_set(cwd, p));
APR_ASSERT_SUCCESS(tc, "remove cwd", apr_dir_remove(path, p));
}
static void mkdir_structure(disk_cache_conf *conf, const char *file, apr_pool_t *pool)
{
apr_status_t rv;
char *p;
for (p = (char*)file + conf->cache_root_len + 1;;) {
p = strchr(p, '/');
if (!p)
break;
*p = '\0';
rv = apr_dir_make(file,
APR_UREAD|APR_UWRITE|APR_UEXECUTE, pool);
if (rv != APR_SUCCESS && !APR_STATUS_IS_EEXIST(rv)) {
/* XXX */
}
*p = '/';
++p;
}
}
term_t bif_make_dir1(term_t Dir, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *tmp;
const char *path;
if (!is_string(Dir))
return A_BADARG;
apr_pool_create(&tmp, 0);
path = ltoz(Dir, tmp);
rs = apr_dir_make(path, APR_OS_DEFAULT, tmp);
if (rs == 0)
result(A_OK);
else
result(make_tuple2(A_ERROR, decipher_status(rs), proc_gc_pool(ctx)));
apr_pool_destroy(tmp);
return AI_OK;
}
static void * APR_THREAD_FUNC deploymentAdmin_poll(apr_thread_t *thd, void *deploymentAdmin) {
deployment_admin_pt admin = deploymentAdmin;
/*first poll send framework started audit event, note this will register the target in Apache ACE*/
deploymentAdmin_updateAuditPool(admin, DEPLOYMENT_ADMIN_AUDIT_EVENT__FRAMEWORK_STARTED);
while (admin->running) {
//poll ace
array_list_pt versions = NULL;
deploymentAdmin_readVersions(admin, &versions);
char *last = arrayList_get(versions, arrayList_size(versions) - 1);
if (last != NULL) {
if (admin->current == NULL || strcmp(last, admin->current) > 0) {
char *request = NULL;
if (admin->current == NULL) {
request = apr_pstrcat(admin->pool, admin->pollUrl, "/", last, NULL);
} else {
// We do not yet support fix packages
//request = apr_pstrcat(admin->pool, VERSIONS, "/", last, "?current=", admin->current, NULL);
request = apr_pstrcat(admin->pool, admin->pollUrl, "/", last, NULL);
}
char inputFile[256];
inputFile[0] = '\0';
char *test = inputFile;
celix_status_t status = deploymentAdmin_download(request, &test);
if (status == CELIX_SUCCESS) {
bundle_pt bundle = NULL;
bundleContext_getBundle(admin->context, &bundle);
char *entry = NULL;
bundle_getEntry(bundle, "/", &entry);
// Handle file
char tmpDir[256];
char uuidStr[128];
apr_uuid_t tmpUuid;
apr_uuid_get(&tmpUuid);
apr_uuid_format(uuidStr, &tmpUuid);
sprintf(tmpDir, "%s%s", entry, uuidStr);
apr_dir_make(tmpDir, APR_UREAD|APR_UWRITE|APR_UEXECUTE, admin->pool);
// TODO: update to use bundle cache DataFile instead of module entries.
unzip_extractDeploymentPackage(test, tmpDir);
char *manifest = apr_pstrcat(admin->pool, tmpDir, "/META-INF/MANIFEST.MF", NULL);
manifest_pt mf = NULL;
manifest_createFromFile(manifest, &mf);
deployment_package_pt source = NULL;
deploymentPackage_create(admin->pool, admin->context, mf, &source);
char *name = NULL;
deploymentPackage_getName(source, &name);
char *repoDir = apr_pstrcat(admin->pool, entry, "repo", NULL);
apr_dir_make(repoDir, APR_UREAD|APR_UWRITE|APR_UEXECUTE, admin->pool);
char *repoCache = apr_pstrcat(admin->pool, entry, "repo/", name, NULL);
deploymentAdmin_deleteTree(repoCache, admin->pool);
apr_status_t stat = apr_file_rename(tmpDir, repoCache, admin->pool);
if (stat != APR_SUCCESS) {
printf("No success\n");
}
deployment_package_pt target = hashMap_get(admin->packages, name);
if (target == NULL) {
// target = empty package
}
deploymentAdmin_stopDeploymentPackageBundles(admin, target);
deploymentAdmin_updateDeploymentPackageBundles(admin, source);
deploymentAdmin_startDeploymentPackageCustomizerBundles(admin, source, target);
deploymentAdmin_processDeploymentPackageResources(admin, source);
deploymentAdmin_dropDeploymentPackageResources(admin, source, target);
deploymentAdmin_dropDeploymentPackageBundles(admin, source, target);
deploymentAdmin_startDeploymentPackageBundles(admin, source);
deploymentAdmin_deleteTree(repoCache, admin->pool);
deploymentAdmin_deleteTree(tmpDir, admin->pool);
remove(test);
admin->current = strdup(last);
hashMap_put(admin->packages, name, source);
}
}
}
sleep(5);
}
apr_thread_exit(thd, APR_SUCCESS);
return NULL;
}
SWITCH_DECLARE(switch_status_t) switch_dir_make(const char *path, switch_fileperms_t perm, switch_memory_pool_t *pool)
{
return apr_dir_make(path, perm, pool);
}