TarPull* tar_pull_unref(TarPull *i) { if (!i) return NULL; if (i->tar_pid > 1) { (void) kill_and_sigcont(i->tar_pid, SIGKILL); (void) wait_for_terminate(i->tar_pid, NULL); } pull_job_unref(i->tar_job); pull_job_unref(i->settings_job); pull_job_unref(i->checksum_job); pull_job_unref(i->signature_job); curl_glue_unref(i->glue); sd_event_unref(i->event); if (i->temp_path) { (void) rm_rf(i->temp_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME); free(i->temp_path); } if (i->settings_temp_path) { (void) unlink(i->settings_temp_path); free(i->settings_temp_path); } free(i->final_path); free(i->settings_path); free(i->image_root); free(i->local); return mfree(i); }
static void test_readlink_and_make_absolute(void) { char tempdir[] = "/tmp/test-readlink_and_make_absolute"; char name[] = "/tmp/test-readlink_and_make_absolute/original"; char name2[] = "test-readlink_and_make_absolute/original"; char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias"; char *r = NULL; assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0); assert_se(touch(name) >= 0); assert_se(symlink(name, name_alias) >= 0); assert_se(readlink_and_make_absolute(name_alias, &r) >= 0); assert_se(streq(r, name)); free(r); assert_se(unlink(name_alias) >= 0); assert_se(chdir(tempdir) >= 0); assert_se(symlink(name2, name_alias) >= 0); assert_se(readlink_and_make_absolute(name_alias, &r) >= 0); assert_se(streq(r, name)); free(r); assert_se(unlink(name_alias) >= 0); assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); }
static void rm_rf (const char * killme) { struct stat sb; if (!stat (killme, &sb)) { DIR * odir; if (S_ISDIR (sb.st_mode) && ((odir = opendir (killme)))) { struct dirent *d; for (d = readdir(odir); d != NULL; d=readdir(odir)) { if (d->d_name && strcmp(d->d_name,".") && strcmp(d->d_name,"..")) { char * tmp = tr_buildPath (killme, d->d_name, NULL); rm_rf (tmp); tr_free (tmp); } } closedir (odir); } if (verbose) fprintf (stderr, "cleanup: removing %s\n", killme); tr_remove (killme); } }
static int tar_import_finish(TarImport *i) { int r; assert(i); assert(i->tar_fd >= 0); assert(i->temp_path); assert(i->final_path); i->tar_fd = safe_close(i->tar_fd); if (i->tar_pid > 0) { r = wait_for_terminate_and_warn("tar", i->tar_pid, true); i->tar_pid = 0; if (r < 0) return r; } if (i->read_only) { r = import_make_read_only(i->temp_path); if (r < 0) return r; } if (i->force_local) (void) rm_rf(i->final_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME); r = rename_noreplace(AT_FDCWD, i->temp_path, AT_FDCWD, i->final_path); if (r < 0) return log_error_errno(r, "Failed to move image into place: %m"); free(i->temp_path); i->temp_path = NULL; return 0; }
static int setup_test(Manager **m) { char **tests_path = STRV_MAKE("exists", "existsglobFOOBAR", "changed", "modified", "unit", "directorynotempty", "makedirectory"); char **test_path; Manager *tmp = NULL; int r; assert_se(m); r = manager_new(MANAGER_USER, true, &tmp); if (IN_SET(r, -EPERM, -EACCES, -EADDRINUSE, -EHOSTDOWN, -ENOENT, -ENOEXEC)) { printf("Skipping test: manager_new: %s", strerror(-r)); return -EXIT_TEST_SKIP; } assert_se(r >= 0); assert_se(manager_startup(tmp, NULL, NULL) >= 0); STRV_FOREACH(test_path, tests_path) { _cleanup_free_ char *p = NULL; p = strjoin("/tmp/test-path_", *test_path, NULL); assert_se(p); (void) rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL); }
TarImport* tar_import_unref(TarImport *i) { if (!i) return NULL; sd_event_source_unref(i->input_event_source); if (i->tar_pid > 1) { (void) kill_and_sigcont(i->tar_pid, SIGKILL); (void) wait_for_terminate(i->tar_pid, NULL); } if (i->temp_path) { (void) rm_rf(i->temp_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME); free(i->temp_path); } import_compress_free(&i->compress); sd_event_unref(i->event); safe_close(i->tar_fd); free(i->final_path); free(i->image_root); free(i->local); free(i); return NULL; }
static void rm_rf (const char * killme) { tr_sys_path_info info; if (tr_sys_path_get_info (killme, 0, &info, NULL)) { tr_sys_dir_t odir; if (info.type == TR_SYS_PATH_IS_DIRECTORY && (odir = tr_sys_dir_open (killme, NULL)) != TR_BAD_SYS_DIR) { const char * name; while ((name = tr_sys_dir_read_name (odir, NULL)) != NULL) { if (strcmp (name, ".") != 0 && strcmp (name, "..") != 0) { char * tmp = tr_buildPath (killme, name, NULL); rm_rf (tmp); tr_free (tmp); } } tr_sys_dir_close (odir, NULL); } if (verbose) fprintf (stderr, "cleanup: removing %s\n", killme); tr_sys_path_remove (killme, NULL); } }
/* * Given a local directory, do the equivalent of `rm -rf` * on it, but using the actual filesystem API. * You can't just use dir->Remove() because that * gives an error if the directory is not empty. */ void rm_rf(BDirectory *dir) { status_t err; BEntry entry; err = dir->GetNextEntry(&entry); while(err==B_OK) { BFile file = BFile(&entry, B_READ_ONLY); if(file.IsDirectory()) { BDirectory ndir = BDirectory(&entry); rm_rf(&ndir); } err = entry.Remove(); if(err != B_OK) { BPath path; entry.GetPath(&path); printf("Remove Error: %s on %s\n",strerror(err),path.Path()); //what to do if I can't remove something? } err = dir->GetNextEntry(&entry); } err = dir->GetEntry(&entry); err = entry.Remove(); if(err != B_OK) printf("Folder Removal Error: %s\n", strerror(err)); }
static void test_exec_workingdirectory(Manager *m) { assert_se(mkdir_p("/tmp/test-exec_workingdirectory", 0755) >= 0); test(m, "exec-workingdirectory.service", 0, CLD_EXITED); (void) rm_rf("/tmp/test-exec_workingdirectory", REMOVE_ROOT|REMOVE_PHYSICAL); }
static void rm_rf(const char *path) { DIR *d; struct dirent *e; struct stat st; char filepath[MAXPATHLEN]; if ((d = opendir(path)) == NULL) { pkg_emit_errno("opendir", path); return; } while ((e = readdir(d)) != NULL) { if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue; snprintf(filepath, sizeof(filepath), "%s/%s", path, e->d_name); if (lstat(filepath, &st) != 0) { pkg_emit_errno("lstat", filepath); continue; } if (S_ISDIR(st.st_mode)) rm_rf(filepath); remove(filepath); } closedir(d); }
static int setup_test(Manager **m) { char **tests_path = STRV_MAKE("exists", "existsglobFOOBAR", "changed", "modified", "unit", "directorynotempty", "makedirectory"); char **test_path; Manager *tmp = NULL; int r; assert_se(m); r = enter_cgroup_subroot(); if (r == -ENOMEDIUM) { log_notice_errno(r, "Skipping test: cgroupfs not available"); return -EXIT_TEST_SKIP; } r = manager_new(UNIT_FILE_USER, MANAGER_TEST_RUN_BASIC, &tmp); if (MANAGER_SKIP_TEST(r)) { log_notice_errno(r, "Skipping test: manager_new: %m"); return -EXIT_TEST_SKIP; } assert_se(r >= 0); assert_se(manager_startup(tmp, NULL, NULL) >= 0); STRV_FOREACH(test_path, tests_path) { _cleanup_free_ char *p = NULL; p = strjoin("/tmp/test-path_", *test_path); assert_se(p); (void) rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL); }
static void test_copy_tree(void) { char original_dir[] = "/tmp/test-copy_tree/"; char copy_dir[] = "/tmp/test-copy_tree-copy/"; char **files = STRV_MAKE("file", "dir1/file", "dir1/dir2/file", "dir1/dir2/dir3/dir4/dir5/file"); char **links = STRV_MAKE("link", "file", "link2", "dir1/file"); char **p, **link; (void) rm_rf(copy_dir, REMOVE_ROOT|REMOVE_PHYSICAL); (void) rm_rf(original_dir, REMOVE_ROOT|REMOVE_PHYSICAL); STRV_FOREACH(p, files) { char *f = strjoina(original_dir, *p); assert_se(mkdir_parents(f, 0755) >= 0); assert_se(write_string_file(f, "file") == 0); }
static void test_skip(void (*setup)(void)) { char t[] = "/tmp/journal-skip-XXXXXX"; sd_journal *j; int r; assert_se(mkdtemp(t)); assert_se(chdir(t) >= 0); setup(); /* Seek to head, iterate down. */ assert_ret(sd_journal_open_directory(&j, t, 0)); assert_ret(sd_journal_seek_head(j)); assert_ret(sd_journal_next(j)); test_check_numbers_down(j, 4); sd_journal_close(j); /* Seek to tail, iterate up. */ assert_ret(sd_journal_open_directory(&j, t, 0)); assert_ret(sd_journal_seek_tail(j)); assert_ret(sd_journal_previous(j)); test_check_numbers_up(j, 4); sd_journal_close(j); /* Seek to tail, skip to head, iterate down. */ assert_ret(sd_journal_open_directory(&j, t, 0)); assert_ret(sd_journal_seek_tail(j)); assert_ret(r = sd_journal_previous_skip(j, 4)); assert_se(r == 4); test_check_numbers_down(j, 4); sd_journal_close(j); /* Seek to head, skip to tail, iterate up. */ assert_ret(sd_journal_open_directory(&j, t, 0)); assert_ret(sd_journal_seek_head(j)); assert_ret(r = sd_journal_next_skip(j, 4)); assert_se(r == 4); test_check_numbers_up(j, 4); sd_journal_close(j); log_info("Done..."); if (arg_keep) log_info("Not removing %s", t); else { journal_directory_vacuum(".", 3000000, 0, NULL, true); assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); } puts("------------------------------------------------------------"); }
static void test_conf_files_list(bool use_root) { char tmp_dir[] = "/tmp/test-conf-files-XXXXXX"; _cleanup_strv_free_ char **found_files = NULL, **found_files2 = NULL; const char *root_dir, *search_1, *search_2, *expect_a, *expect_b, *expect_c, *mask; log_debug("/* %s(%s) */", __func__, yes_no(use_root)); setup_test_dir(tmp_dir, "/dir1/a.conf", "/dir2/a.conf", "/dir2/b.conf", "/dir2/c.foo", "/dir2/d.conf", NULL); mask = strjoina(tmp_dir, "/dir1/d.conf"); assert_se(symlink("/dev/null", mask) >= 0); if (use_root) { root_dir = tmp_dir; search_1 = "/dir1"; search_2 = "/dir2"; } else { root_dir = NULL; search_1 = strjoina(tmp_dir, "/dir1"); search_2 = strjoina(tmp_dir, "/dir2"); } expect_a = strjoina(tmp_dir, "/dir1/a.conf"); expect_b = strjoina(tmp_dir, "/dir2/b.conf"); expect_c = strjoina(tmp_dir, "/dir2/c.foo"); log_debug("/* Check when filtered by suffix */"); assert_se(conf_files_list(&found_files, ".conf", root_dir, CONF_FILES_FILTER_MASKED, search_1, search_2, NULL) == 0); strv_print(found_files); assert_se(found_files); assert_se(streq_ptr(found_files[0], expect_a)); assert_se(streq_ptr(found_files[1], expect_b)); assert_se(!found_files[2]); log_debug("/* Check when unfiltered */"); assert_se(conf_files_list(&found_files2, NULL, root_dir, CONF_FILES_FILTER_MASKED, search_1, search_2, NULL) == 0); strv_print(found_files2); assert_se(found_files2); assert_se(streq_ptr(found_files2[0], expect_a)); assert_se(streq_ptr(found_files2[1], expect_b)); assert_se(streq_ptr(found_files2[2], expect_c)); assert_se(!found_files2[3]); assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0); }
void pkg_cache_full_clean(void) { const char *cachedir; if (!pkg_object_bool(pkg_config_get("AUTOCLEAN"))) return; pkg_debug(1, "Cleaning up cachedir"); cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); return (rm_rf(cachedir)); }
static void test_copy_tree(void) { char original_dir[] = "/tmp/test-copy_tree/"; char copy_dir[] = "/tmp/test-copy_tree-copy/"; char **files = STRV_MAKE("file", "dir1/file", "dir1/dir2/file", "dir1/dir2/dir3/dir4/dir5/file"); char **links = STRV_MAKE("link", "file", "link2", "dir1/file"); char **p, **link; const char *unixsockp; struct stat st; log_info("%s", __func__); (void) rm_rf(copy_dir, REMOVE_ROOT|REMOVE_PHYSICAL); (void) rm_rf(original_dir, REMOVE_ROOT|REMOVE_PHYSICAL); STRV_FOREACH(p, files) { _cleanup_free_ char *f; assert_se(f = strappend(original_dir, *p)); assert_se(mkdir_parents(f, 0755) >= 0); assert_se(write_string_file(f, "file", WRITE_STRING_FILE_CREATE) == 0); }
int cg_trim(const char *controller, const char *path, bool delete_root) { char *fs; int r; assert(controller); assert(path); if ((r = cg_get_path(controller, path, NULL, &fs)) < 0) return r; r = rm_rf(fs, true, delete_root); free(fs); return r == -ENOENT ? 0 : r; }
static TWindow *browser_do_delete (ttk_menu_item *item) { #define PATHSIZ 512 struct stat st; const char *filename = item->data; if (stat (filename, &st) < 0) { pz_perror (filename); return TTK_MENU_UPONE; } if (S_ISDIR (st.st_mode)) { /* we change the current directory here in order to find the * absolute path of the specified directory with getcwd. this * removes the need to check for references to the parent * directory or follow along a path until we find the end * result. in addition, opening the current directory and using * its file descriptor to return to it is faster than storing * its path */ if (filename[0]) { int fd; char full_path[PATHSIZ]; if ((fd = open(".", O_RDONLY)) == -1) return TTK_MENU_UPONE; chdir(filename); getcwd(full_path, PATHSIZ); fchdir(fd); close(fd); if (full_path[0] && full_path[1] && strchr(full_path + 2, '/')) rm_rf (filename); // not "" or "/" or a root dir else pz_error (_("Dangerous rm -rf aborted.\n")); } } else { unlink (filename); } /* hide the top two windows */ if (ttk_hide_window (ttk_windows->w) != -1 && ttk_hide_window (ttk_windows->w) != -1) { /* -ttk_windows->w->widgets->v- is the top window's menu */ ttk_menu_remove_by_ptr(ttk_windows->w->widgets->v, ttk_menu_get_selected_item(ttk_windows->w->widgets->v)); } else { pz_error("Unable to close windows"); } return TTK_MENU_DONOTHING; /* we are now back at the directory */ }
int rm_rf(char *path) { DIR *dir; int ret = 0; struct dirent *d; char namebuf[PATH_MAX]; dir = opendir(path); if (dir == NULL) return 0; while ((d = readdir(dir)) != NULL && !ret) { struct stat statbuf; if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) continue; scnprintf(namebuf, sizeof(namebuf), "%s/%s", path, d->d_name); ret = stat(namebuf, &statbuf); if (ret < 0) { pr_debug("stat failed: %s\n", namebuf); break; } if (S_ISREG(statbuf.st_mode)) ret = unlink(namebuf); else if (S_ISDIR(statbuf.st_mode)) ret = rm_rf(namebuf); else { pr_debug("unknown file: %s\n", namebuf); ret = -1; } } closedir(dir); if (ret < 0) return ret; return rmdir(path); }
static int remove_binaries(const char *esp_path) { char *p; int r, q; unsigned i; p = strjoina(esp_path, "/EFI/systemd"); r = rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL); q = remove_boot_efi(esp_path); if (q < 0 && r == 0) r = q; for (i = ELEMENTSOF(efi_subdirs); i > 0; i--) { q = rmdir_one(esp_path, efi_subdirs[i-1]); if (q < 0 && r == 0) r = q; } return r; }
/* clean then recreate temporary folder for tar renames */ static int create_staging_renamedir(char *rename_tmpdir) { int ret; if (rm_rf(rename_tmpdir) != 0) { /* Not fatal but pretty scary, likely to really fail at the * next command too. Pass for now as printing may just cause * confusion */ ; } ret = mkdir(rename_tmpdir, S_IRWXU); if (ret == -1 && errno != EEXIST) { ret = -errno; } else { ret = 0; } return ret; }
static void test_empty(void) { JournalFile *f1, *f2, *f3, *f4; char t[] = "/tmp/journal-XXXXXX"; test_setup_logging(LOG_DEBUG); assert_se(mkdtemp(t)); assert_se(chdir(t) >= 0); assert_se(journal_file_open(-1, "test.journal", O_RDWR|O_CREAT, 0666, false, (uint64_t) -1, false, NULL, NULL, NULL, NULL, &f1) == 0); assert_se(journal_file_open(-1, "test-compress.journal", O_RDWR|O_CREAT, 0666, true, (uint64_t) -1, false, NULL, NULL, NULL, NULL, &f2) == 0); assert_se(journal_file_open(-1, "test-seal.journal", O_RDWR|O_CREAT, 0666, false, (uint64_t) -1, true, NULL, NULL, NULL, NULL, &f3) == 0); assert_se(journal_file_open(-1, "test-seal-compress.journal", O_RDWR|O_CREAT, 0666, true, (uint64_t) -1, true, NULL, NULL, NULL, NULL, &f4) == 0); journal_file_print_header(f1); puts(""); journal_file_print_header(f2); puts(""); journal_file_print_header(f3); puts(""); journal_file_print_header(f4); puts(""); log_info("Done..."); if (arg_keep) log_info("Not removing %s", t); else { journal_directory_vacuum(".", 3000000, 0, 0, NULL, true); assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); } (void) journal_file_close(f1); (void) journal_file_close(f2); (void) journal_file_close(f3); (void) journal_file_close(f4); }
static int raw_import_finish(RawImport *i) { int r; assert(i); assert(i->output_fd >= 0); assert(i->temp_path); assert(i->final_path); /* In case this was a sparse file, make sure the file system is right */ if (i->written_uncompressed > 0) { if (ftruncate(i->output_fd, i->written_uncompressed) < 0) return log_error_errno(errno, "Failed to truncate file: %m"); } r = raw_import_maybe_convert_qcow2(i); if (r < 0) return r; if (S_ISREG(i->st.st_mode)) { (void) copy_times(i->input_fd, i->output_fd); (void) copy_xattr(i->input_fd, i->output_fd); } if (i->read_only) { r = import_make_read_only_fd(i->output_fd); if (r < 0) return r; } if (i->force_local) (void) rm_rf(i->final_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME); r = rename_noreplace(AT_FDCWD, i->temp_path, AT_FDCWD, i->final_path); if (r < 0) return log_error_errno(r, "Failed to move image into place: %m"); free(i->temp_path); i->temp_path = NULL; return 0; }
int rm_rf(const char *path) { DIR *dir; int ret = 0; struct dirent *d; char namebuf[PATH_MAX]; dir = opendir(path); if (dir == NULL) return 0; while ((d = readdir(dir)) != NULL && !ret) { struct stat statbuf; if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) continue; scnprintf(namebuf, sizeof(namebuf), "%s/%s", path, d->d_name); /* We have to check symbolic link itself */ ret = lstat(namebuf, &statbuf); if (ret < 0) { pr_debug("stat failed: %s\n", namebuf); break; } if (S_ISDIR(statbuf.st_mode)) ret = rm_rf(namebuf); else ret = unlink(namebuf); } closedir(dir); if (ret < 0) return ret; return rmdir(path); }
int main(int argc, char *argv[]) { sd_journal *j; int r, i, I = 100; char t[] = "/var/tmp/journal-stream-XXXXXX"; test_setup_logging(LOG_DEBUG); if (argc >= 2) { r = safe_atoi(argv[1], &I); if (r < 0) log_info("Could not parse loop count argument. Using default."); } log_info("Running %d loops", I); assert_se(mkdtemp(t)); (void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL, NULL); for (i = 0; i < I; i++) { r = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY); assert_se(r == 0); sd_journal_close(j); r = sd_journal_open_directory(&j, t, 0); assert_se(r == 0); sd_journal_close(j); j = NULL; r = sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY); assert_se(r == -EINVAL); assert_se(j == NULL); } assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); return 0; }
static int remove_binaries(const char *esp_path) { char *p; int r, q; if (asprintf(&p, "%s/EFI/systemd-boot", esp_path) < 0) { fprintf(stderr, "Out of memory.\n"); return -ENOMEM; } r = rm_rf(p, false, false, false); free(p); q = remove_boot_efi(esp_path); if (q < 0 && r == 0) r = q; q = rmdir_one(esp_path, "loader/entries"); if (q < 0 && r == 0) r = q; q = rmdir_one(esp_path, "loader"); if (q < 0 && r == 0) r = q; q = rmdir_one(esp_path, "EFI/Boot"); if (q < 0 && r == 0) r = q; q = rmdir_one(esp_path, "EFI/systemd-boot"); if (q < 0 && r == 0) r = q; q = rmdir_one(esp_path, "EFI"); if (q < 0 && r == 0) r = q; return r; }
static void rm_rf (const char *path) { struct stat st; DIR *dp; stat (path, &st); if (!S_ISDIR (st.st_mode)) { unlink (path); } else { struct dirent *d; chdir (path); dp = opendir ("."); if (!dp) return; while ((d = readdir (dp)) != 0) { if ((strcmp (d->d_name, ".") != 0) && (strcmp (d->d_name, "..") != 0)) rm_rf (d->d_name); } closedir (dp); chdir (".."); rmdir (path); } }
/* Remove a directory and all of its subdirectories */ static void rm_rf(const char *dir) { struct stat st; smartlist_t *elements; elements = tor_listdir(dir); if (elements) { SMARTLIST_FOREACH_BEGIN(elements, const char *, cp) { char *tmp = NULL; tor_asprintf(&tmp, "%s"PATH_SEPARATOR"%s", dir, cp); if (0 == stat(tmp,&st) && (st.st_mode & S_IFDIR)) { rm_rf(tmp); } else { if (unlink(tmp)) { fprintf(stderr, "Error removing %s: %s\n", tmp, strerror(errno)); } } tor_free(tmp); } SMARTLIST_FOREACH_END(cp); SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp)); smartlist_free(elements); }
DkrPull* dkr_pull_unref(DkrPull *i) { if (!i) return NULL; if (i->tar_pid > 1) { (void) kill_and_sigcont(i->tar_pid, SIGKILL); (void) wait_for_terminate(i->tar_pid, NULL); } pull_job_unref(i->images_job); pull_job_unref(i->tags_job); pull_job_unref(i->ancestry_job); pull_job_unref(i->json_job); pull_job_unref(i->layer_job); curl_glue_unref(i->glue); sd_event_unref(i->event); if (i->temp_path) { (void) rm_rf(i->temp_path, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_SUBVOLUME); free(i->temp_path); } free(i->name); free(i->reference); free(i->id); free(i->response_token); free(i->response_registries); strv_free(i->ancestry); free(i->final_path); free(i->index_url); free(i->image_root); free(i->local); free(i); return NULL; }
size_t DummyUnixSandbox::create_box(size_t box_limit) { //TODO: fix this for the many weird things that could possibly happen for (size_t box_id = 1; box_id < box_limit; box_id++) { std::string current_attempt = box_base_path(base_path, box_id); if (mkdir(current_attempt.c_str(), box_mode) == -1 && errno != EEXIST) { error(4, serror("Error creating sandbox " + current_attempt)); return 0; } struct stat statbuf; stat(current_attempt.c_str(), &statbuf); if (!S_ISDIR(statbuf.st_mode)) continue; current_attempt += "lock"; int res = open(current_attempt.c_str(), O_RDWR | O_CREAT | O_EXCL, file_mode); if (res == -1 && errno == EEXIST) continue; if (res == -1) { warning(4, serror("Something weird happened creating sandbox " + current_attempt)); continue; } current_attempt = box_base_path(base_path, box_id) + "file_root/"; int err = rm_rf(current_attempt); if (err && err != ENOENT) { error(4, serror("Error deleting old file_root " + current_attempt, err)); return 0; } if (mkdir(current_attempt.c_str(), box_mode) == -1) { error(4, serror("Error creating file_root " + current_attempt)); return 0; } id_ = box_id; return id_; } error(4, "Could not find a free box id!"); return 0; }