int recursive_rmdir(char* dir) { DIR * dirh; struct dirent * dire; struct stat statbuf; char fname[PATH_MAX]; int ret; dirh = opendir(dir); if(!dirh) { fprintf(stderr, "Error: failed to open dir: %s\n", dir); return -1; } while((dire = readdir(dirh)) != NULL) { if(strcmp(dire->d_name, ".") == 0 || strcmp(dire->d_name, "..") == 0) { continue; } sprintf(fname, "%s/%s", dir, dire->d_name); ret = stat(fname, &statbuf); if(ret == -1) { perror("stat"); return -1; } if(S_ISDIR(statbuf.st_mode)) { ret = recursive_rmdir(fname); if(ret < 0) { return ret; } } else if(S_ISREG(statbuf.st_mode)) { unlink(fname); } } ret = closedir(dirh); if(ret < 0) { perror("closedir"); return -1; } ret = rmdir(dir); if(ret < 0) { perror("rmdir"); } return 0; }
/* recursive rmdir to remove the left-overs from unstuff */ static void recursive_rmdir (const char *path) { GDir *dir; const char *dirname; dir = g_dir_open (path, 0, NULL); if (dir == NULL) return; dirname = g_dir_read_name (dir); while (dirname != NULL) { char *full_path; if (strcmp (dirname, ".") == 0 || strcmp (dirname, "..") == 0) continue; full_path = g_build_filename (path, dirname, NULL); recursive_rmdir (full_path); g_free (full_path); dirname = g_dir_read_name (dir); } rmdir (path); g_dir_close (dir); }
static int recursive_rmdir (char *dirpath) { DIR *dir; struct dirent *de; char pathbuf[MAXPATHLEN]; struct stat sb; int err; dir = opendir(dirpath); if (!dir) return 1; while ((de = readdir(dir))) { if (de->d_name[0] == '.' && ((de->d_name[1] == '.' && !de->d_name[2]) || !de->d_name[1])) continue; snprintf(pathbuf, MAXPATHLEN, "%s/%s", dirpath, de->d_name); if ((err = SYS_lstat(pathbuf, &sb))) goto ret; if (S_ISDIR(sb.st_mode) && !S_ISLNK(sb.st_mode)) err = recursive_rmdir(pathbuf); else err = unlink(pathbuf); if (err) goto ret; } closedir(dir); return rmdir(dirpath); ret: closedir(dir); return err; }
static void create_user_full(struct user *user) { char trace_path[] = "/tmp/ctfwriter_XXXXXX"; struct bt_ctf_field_type *ft; struct bt_ctf_field *field; struct bt_ctf_clock *clock; int ret; if (!bt_mkdtemp(trace_path)) { perror("# perror"); } user->writer = bt_ctf_writer_create(trace_path); assert(user->writer); user->tc = bt_ctf_writer_get_trace(user->writer); assert(user->tc); user->sc = bt_ctf_stream_class_create("sc"); assert(user->sc); clock = bt_ctf_clock_create("the_clock"); assert(clock); ret = bt_ctf_stream_class_set_clock(user->sc, clock); assert(!ret); ret = bt_ctf_clock_set_value(clock, 23); assert(!ret); BT_PUT(clock); user->stream = bt_ctf_writer_create_stream(user->writer, user->sc); assert(user->stream); user->ec = bt_ctf_event_class_create("ec"); assert(user->ec); ft = create_integer_struct(); assert(ft); ret = bt_ctf_event_class_set_payload_type(user->ec, ft); BT_PUT(ft); assert(!ret); ret = bt_ctf_stream_class_add_event_class(user->sc, user->ec); assert(!ret); user->event = bt_ctf_event_create(user->ec); assert(user->event); field = bt_ctf_event_get_payload(user->event, "payload_8"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 10); assert(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_16"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 20); assert(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_32"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 30); assert(!ret); BT_PUT(field); ret = bt_ctf_stream_append_event(user->stream, user->event); assert(!ret); recursive_rmdir(trace_path); }
static bool recursive_rmdir(const char *dirname) { struct dirent dirent, *direntp; DIR *dir; bool ret = false; char pathname[MAXPATHLEN]; dir = opendir(dirname); if (!dir) { fprintf(stderr, "%s: failed to open %s: %s\n", __func__, dirname, strerror(errno)); return false; } while (!readdir_r(dir, &dirent, &direntp)) { struct stat mystat; int rc; if (!direntp) break; if (!strcmp(direntp->d_name, ".") || !strcmp(direntp->d_name, "..")) continue; rc = snprintf(pathname, MAXPATHLEN, "%s/%s", dirname, direntp->d_name); if (rc < 0 || rc >= MAXPATHLEN) { fprintf(stderr, "pathname too long\n"); continue; } ret = lstat(pathname, &mystat); if (ret) { fprintf(stderr, "%s: failed to stat %s: %s\n", __func__, pathname, strerror(errno)); continue; } if (S_ISDIR(mystat.st_mode)) { if (!recursive_rmdir(pathname)) fprintf(stderr, "Error removing %s\n", pathname); } } ret = true; if (closedir(dir) < 0) { fprintf(stderr, "%s: failed to close directory %s: %s\n", __func__, dirname, strerror(errno)); ret = false; } if (rmdir(dirname) < 0) { fprintf(stderr, "%s: failed to delete %s: %s\n", __func__, dirname, strerror(errno)); ret = false; } return ret; }
bool cgfs_remove(const char *controller, const char *cg) { size_t len; char *dirnam, *tmpc = find_mounted_controller(controller); if (!tmpc) return false; /* basedir / tmpc / cg \0 */ len = strlen(basedir) + strlen(tmpc) + strlen(cg) + 3; dirnam = alloca(len); snprintf(dirnam, len, "%s/%s/%s", basedir,tmpc, cg); return recursive_rmdir(dirnam); }
/* * Remove the provided directory totally from the filesystem. This * is done in a recursive fashion for any files and directories * contained within that directory. Any problem in this operation * should cause -1 to be returned and errno to contain the error. */ int recursive_rmdir(char *directory) { DIR *d = NULL; struct dirent *dir = NULL; char *name = NULL; int i = 0; struct stat s; unsigned int size = 0; if (directory == NULL) { errno = EINVAL; return -1; } if ((d = opendir(directory)) == NULL) return -1; while ((dir = readdir(d)) != NULL) { if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) continue; size = strlen(directory) + strlen(dir->d_name) + 2; name = (char *)malloc(size * sizeof(char)); if (name == NULL) { closedir(d); errno = ENOMEM; return -1; } snprintf(name, size, "%s%c%s", directory, FILE_SEPARATOR, dir->d_name); if (lstat(name, &s) == -1) { closedir(d); free(name); return -1; } if (S_ISDIR(s.st_mode)) { i = recursive_rmdir(name); } else { i = unlink(name); } free(name); if (i == -1) { closedir(d); return -1; } } closedir(d); rmdir(directory); return 0; }
/* * Recursively delete a cgroup. * Cgroup files can't be deleted, but are cleaned up when you remove the * containing directory. A directory cannot be removed until all its * children are removed, and can't be removed if any tasks remain. * * We allow any task which may write under /a/b to delete any cgroups * under that, even if, say, it technically is not allowed to remove * /a/b/c/d/. */ static int recursive_rmdir(char *path) { struct dirent dirent, *direntp; DIR *dir; char pathname[MAXPATHLEN]; int failed = 0; dir = opendir(path); if (!dir) { nih_error("%s: Failed to open dir %s for recursive deletion", __func__, path); return -1; } while (!readdir_r(dir, &dirent, &direntp)) { struct stat mystat; int rc; if (!direntp) break; if (!strcmp(direntp->d_name, ".") || !strcmp(direntp->d_name, "..")) continue; rc = snprintf(pathname, MAXPATHLEN, "%s/%s", path, direntp->d_name); if (rc < 0 || rc >= MAXPATHLEN) { failed = 1; continue; } rc = lstat(pathname, &mystat); if (rc) { failed = 1; continue; } if (S_ISDIR(mystat.st_mode)) { if (recursive_rmdir(pathname) < 0) failed = 1; } } if (closedir(dir) < 0) failed = 1; if (rmdir(path) < 0) failed = 1; return failed ? -1 : 0; }
int recursive_rmdir(char *dirname) { struct dirent dirent, *direntp; DIR *dir; int ret; char pathname[MAXPATHLEN]; dir = opendir(dirname); if (!dir) { WARN("failed to open directory: %m"); return -1; } while (!readdir_r(dir, &dirent, &direntp)) { struct stat mystat; int rc; if (!direntp) break; if (!strcmp(direntp->d_name, ".") || !strcmp(direntp->d_name, "..")) continue; rc = snprintf(pathname, MAXPATHLEN, "%s/%s", dirname, direntp->d_name); if (rc < 0 || rc >= MAXPATHLEN) { ERROR("pathname too long"); continue; } ret = stat(pathname, &mystat); if (ret) continue; if (S_ISDIR(mystat.st_mode)) recursive_rmdir(pathname); } ret = rmdir(dirname); if (closedir(dir)) ERROR("failed to close directory"); return ret; }
static int lxc_one_cgroup_destroy(struct mntent *mntent, const char *cgpath) { char cgname[MAXPATHLEN]; char *cgmnt = mntent->mnt_dir; int rc; rc = snprintf(cgname, MAXPATHLEN, "%s/%s", cgmnt, cgpath); if (rc < 0 || rc >= MAXPATHLEN) { ERROR("name too long"); return -1; } DEBUG("destroying %s\n", cgname); if (recursive_rmdir(cgname)) { SYSERROR("failed to remove cgroup '%s'", cgname); return -1; } DEBUG("'%s' unlinked", cgname); return 0; }
int lxc_one_cgroup_destroy(struct mntent *mntent, const char *name) { char cgname[MAXPATHLEN], initcgroup[MAXPATHLEN]; char *cgmnt = mntent->mnt_dir; int flags = get_cgroup_flags(mntent); int rc; rc = snprintf(cgname, MAXPATHLEN, "%s%s%s/%s", cgmnt, get_init_cgroup(NULL, mntent, initcgroup), (flags & CGROUP_NS_CGROUP) ? "" : "/lxc", name); if (rc < 0 || rc >= MAXPATHLEN) { ERROR("name too long"); return -1; } DEBUG("destroying %s\n", cgname); if (recursive_rmdir(cgname)) { SYSERROR("failed to remove cgroup '%s'", cgname); return -1; } DEBUG("'%s' unlinked", cgname); return 0; }
int remove_main(const char *controller, const char *cgroup, struct ucred p, struct ucred r, int recursive, int32_t *existed) { char rcgpath[MAXPATHLEN]; size_t cgroup_len; nih_local char *working = NULL, *copy = NULL, *wcgroup = NULL; char *p1; *existed = 1; if (!sane_cgroup(cgroup)) { nih_error("%s: unsafe cgroup", __func__); return -1; } // Get r's current cgroup in rcgpath if (!compute_pid_cgroup(r.pid, controller, "", rcgpath, NULL)) { nih_error("%s: Could not determine the requested cgroup", __func__); return -1; } cgroup_len = strlen(cgroup); if (strlen(rcgpath) + cgroup_len > MAXPATHLEN) { nih_error("%s: Path name too long", __func__); return -1; } wcgroup = NIH_MUST( nih_strdup(NULL, cgroup) ); if (!normalize_path(wcgroup)) return -1; working = NIH_MUST( nih_strdup(NULL, rcgpath) ); NIH_MUST( nih_strcat(&working, NULL, "/") ); NIH_MUST( nih_strcat(&working, NULL, wcgroup) ); if (!dir_exists(working)) { *existed = -1; return 0; } // must have write access to the parent dir copy = NIH_MUST( nih_strdup(NULL, working) ); if (!(p1 = strrchr(copy, '/'))) return -1; *p1 = '\0'; if (!may_access(r.pid, r.uid, r.gid, copy, O_WRONLY)) { nih_error("%s: pid %d (%u:%u) may not remove %s", __func__, r.pid, r.uid, r.gid, copy); return -1; } if (!recursive) { if (rmdir(working) < 0) { nih_error("%s: Failed to remove %s: %s", __func__, working, strerror(errno)); return -1; } } else if (recursive_rmdir(working) < 0) return -1; nih_info(_("Removed %s for %d (%u:%u)"), working, r.pid, r.uid, r.gid); return 0; }
static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp) { connection_struct *conn = fsp->conn; struct smb_filename *smb_dname = fsp->fsp_name; int ret; SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname)); /* Might be a symlink. */ if(SMB_VFS_LSTAT(conn, smb_dname) != 0) { return map_nt_error_from_unix(errno); } if (S_ISLNK(smb_dname->st.st_ex_mode)) { /* Is what it points to a directory ? */ if(SMB_VFS_STAT(conn, smb_dname) != 0) { return map_nt_error_from_unix(errno); } if (!(S_ISDIR(smb_dname->st.st_ex_mode))) { return NT_STATUS_NOT_A_DIRECTORY; } ret = SMB_VFS_UNLINK(conn, smb_dname); } else { ret = SMB_VFS_RMDIR(conn, smb_dname->base_name); } if (ret == 0) { notify_fname(conn, NOTIFY_ACTION_REMOVED, FILE_NOTIFY_CHANGE_DIR_NAME, smb_dname->base_name); return NT_STATUS_OK; } if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(talloc_tos(), SNUM(conn))) { /* * Check to see if the only thing in this directory are * vetoed files/directories. If so then delete them and * retry. If we fail to delete any of them (and we *don't* * do a recursive delete) then fail the rmdir. */ SMB_STRUCT_STAT st; const char *dname = NULL; char *talloced = NULL; long dirpos = 0; struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0); if(dir_hnd == NULL) { errno = ENOTEMPTY; goto err; } while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced)) != NULL) { if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) { TALLOC_FREE(talloced); continue; } if (!is_visible_file(conn, smb_dname->base_name, dname, &st, false)) { TALLOC_FREE(talloced); continue; } if(!IS_VETO_PATH(conn, dname)) { TALLOC_FREE(dir_hnd); TALLOC_FREE(talloced); errno = ENOTEMPTY; goto err; } TALLOC_FREE(talloced); } /* We only have veto files/directories. * Are we allowed to delete them ? */ if(!lp_delete_veto_files(SNUM(conn))) { TALLOC_FREE(dir_hnd); errno = ENOTEMPTY; goto err; } /* Do a recursive delete. */ RewindDir(dir_hnd,&dirpos); while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced)) != NULL) { struct smb_filename *smb_dname_full = NULL; char *fullname = NULL; bool do_break = true; if (ISDOT(dname) || ISDOTDOT(dname)) { TALLOC_FREE(talloced); continue; } if (!is_visible_file(conn, smb_dname->base_name, dname, &st, false)) { TALLOC_FREE(talloced); continue; } fullname = talloc_asprintf(ctx, "%s/%s", smb_dname->base_name, dname); if(!fullname) { errno = ENOMEM; goto err_break; } smb_dname_full = synthetic_smb_fname( talloc_tos(), fullname, NULL, NULL); if (smb_dname_full == NULL) { errno = ENOMEM; goto err_break; } if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) { goto err_break; } if(smb_dname_full->st.st_ex_mode & S_IFDIR) { if(!recursive_rmdir(ctx, conn, smb_dname_full)) { goto err_break; } if(SMB_VFS_RMDIR(conn, smb_dname_full->base_name) != 0) { goto err_break; } } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) { goto err_break; } /* Successful iteration. */ do_break = false; err_break: TALLOC_FREE(fullname); TALLOC_FREE(smb_dname_full); TALLOC_FREE(talloced); if (do_break) break; } TALLOC_FREE(dir_hnd); /* Retry the rmdir */ ret = SMB_VFS_RMDIR(conn, smb_dname->base_name); } err: if (ret != 0) { DEBUG(3,("rmdir_internals: couldn't remove directory %s : " "%s\n", smb_fname_str_dbg(smb_dname), strerror(errno))); return map_nt_error_from_unix(errno); } notify_fname(conn, NOTIFY_ACTION_REMOVED, FILE_NOTIFY_CHANGE_DIR_NAME, smb_dname->base_name); return NT_STATUS_OK; }
bool recursive_rmdir(TALLOC_CTX *ctx, connection_struct *conn, struct smb_filename *smb_dname) { const char *dname = NULL; char *talloced = NULL; bool ret = True; long offset = 0; SMB_STRUCT_STAT st; struct smb_Dir *dir_hnd; SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname)); dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0); if(dir_hnd == NULL) return False; while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) { struct smb_filename *smb_dname_full = NULL; char *fullname = NULL; bool do_break = true; if (ISDOT(dname) || ISDOTDOT(dname)) { TALLOC_FREE(talloced); continue; } if (!is_visible_file(conn, smb_dname->base_name, dname, &st, false)) { TALLOC_FREE(talloced); continue; } /* Construct the full name. */ fullname = talloc_asprintf(ctx, "%s/%s", smb_dname->base_name, dname); if (!fullname) { errno = ENOMEM; goto err_break; } smb_dname_full = synthetic_smb_fname(talloc_tos(), fullname, NULL, NULL); if (smb_dname_full == NULL) { errno = ENOMEM; goto err_break; } if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) { goto err_break; } if(smb_dname_full->st.st_ex_mode & S_IFDIR) { if(!recursive_rmdir(ctx, conn, smb_dname_full)) { goto err_break; } if(SMB_VFS_RMDIR(conn, smb_dname_full->base_name) != 0) { goto err_break; } } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) { goto err_break; } /* Successful iteration. */ do_break = false; err_break: TALLOC_FREE(smb_dname_full); TALLOC_FREE(fullname); TALLOC_FREE(talloced); if (do_break) { ret = false; break; } } TALLOC_FREE(dir_hnd); return ret; }
void rcv_file_delete (struct htlc_conn *htlc) { u_int16_t fnlen = 0; char dir[MAXPATHLEN], filename[NAME_MAX], oldbuf[MAXPATHLEN]; char rsrcpath_old[MAXPATHLEN]; struct stat sb, rsb; int err; dir[0] = 0; dh_start(htlc) switch (dh_type) { case HTLC_DATA_FILE_NAME: fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len; read_filename(filename, dh_data, fnlen); break; case HTLC_DATA_DIR: if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) { snd_strerror(htlc, err); return; } break; } dh_end() if (!fnlen && !dir[0]) { hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?"); return; } if (dir[0]) { if (fnlen) snprintf(oldbuf, sizeof(oldbuf), "%s/%s", dir, filename); else strcpy(oldbuf, dir); } else { snprintf(oldbuf, sizeof(oldbuf), "%s/%s", ROOTDIR, filename); } if (check_dropbox(htlc, oldbuf)) { snd_strerror(htlc, EPERM); return; } if (log_delete) hxd_log("%s:%s:%u - delete %s", htlc->name, htlc->login, htlc->uid, oldbuf); if (SYS_lstat(oldbuf, &sb)) { snd_strerror(htlc, errno); return; } #if defined(CONFIG_HFS) if (!hxd_cfg.operation.hfs) goto skiphfs; if (hxd_cfg.files.fork == HFS_FORK_CAP) { if (!S_ISDIR(sb.st_mode) && !resource_path(rsrcpath_old, oldbuf, &rsb) && !S_ISDIR(rsb.st_mode)) { if (unlink(rsrcpath_old)) { snd_strerror(htlc, errno); return; } } } if (!finderinfo_path(rsrcpath_old, oldbuf, &rsb)) { if (unlink(rsrcpath_old)) { snd_strerror(htlc, errno); return; } } skiphfs: #endif /* CONFIG_HFS */ if (S_ISDIR(sb.st_mode) && !S_ISLNK(sb.st_mode)) err = recursive_rmdir(oldbuf); else err = unlink(oldbuf); if (err) snd_strerror(htlc, errno); else hlwrite(htlc, HTLS_HDR_TASK, 0, 0); }
int migrate_collection(void * config, void * sconfig) { char old_coll_path[PATH_MAX]; char version[256]; int ret; struct filesystem_configuration_s * fs_config = (struct filesystem_configuration_s *) config; struct server_configuration_s * server_config = (struct server_configuration_s *) sconfig; memset(version, 0, 256); /* find version of source storage space */ ret = src_get_version( server_config->storage_path, fs_config->coll_id, fs_config->file_system_name, version, 254); if(ret < 0) { fprintf(stderr, "Error: failed to read version of src storage space\n" " for filesystem: %s (%08x)\n", fs_config->file_system_name, fs_config->coll_id); return ret; } /* call the appropriate translation routine based on the version */ if(strncmp(version, "0.0.1", 5) == 0) { sprintf(old_coll_path, "%s/%08x-old-%s", server_config->storage_path, fs_config->coll_id, version); ret = access(old_coll_path, F_OK); if(ret == 0) { if(opts.cleanup_set) { /* user asked to remove this old collection instead * of creating it */ if(verbose) printf("VERBOSE Removing old collection at: %s\n", old_coll_path); ret = recursive_rmdir(old_coll_path); if(ret < 0) { fprintf(stderr, "Error: failed to remove %s\n", old_coll_path); return -1; } return 0; } if(verbose) printf("VERBOSE %s already exists.\n", old_coll_path); fprintf(stderr, "Error: unable to confirm availability of backup subdirectory (%s)\n" " for migration of fs: %s (%08x).\n", old_coll_path, fs_config->file_system_name, fs_config->coll_id); fprintf(stderr, "Error: please make sure that the migration " "has not already been performed.\n"); return -1; } ret = translate_0_0_1( server_config->storage_path, old_coll_path, fs_config->file_system_name, fs_config->coll_id); if(ret < 0) { fprintf(stderr, "Error: failed to translate from %s collection\n" " for fs: %s (%08x).\n", version, fs_config->file_system_name, fs_config->coll_id); return -1; } if(opts.cleanup_set) { /* user asked to remove this old collection instead * of creating it */ if(verbose) printf("VERBOSE Removing old collection at: %s\n", old_coll_path); ret = unlink(old_coll_path); if(ret < 0) { perror("unlink"); return -1; } } } else { if(opts.cleanup_set) { /* user asked to remove this old collection instead * of creating it, but we don't know what the version * is anymore */ DIR * storage_dir; struct dirent * next_dirent; char collname[PATH_MAX]; int collname_length; int removed_olddirs = 0; collname_length = sprintf(collname, "%08x-old", fs_config->coll_id); storage_dir = opendir(server_config->storage_path); if(!storage_dir) { fprintf(stderr, "Error: failed to open directory: %s\n", server_config->storage_path); return -1; } while((next_dirent = readdir(storage_dir)) != NULL) { int d_namelen = strlen(next_dirent->d_name); if(collname_length < d_namelen && strncmp(next_dirent->d_name, collname, collname_length) == 0) { char old_coll_path[PATH_MAX]; sprintf(old_coll_path, "%s/%s", server_config->storage_path, next_dirent->d_name); /* found an old version, delete it */ if(verbose) printf("VERBOSE Removing old collection at: %s\n", old_coll_path); ret = recursive_rmdir(old_coll_path); if(ret < 0) { fprintf( stderr, "Error: failed to remove old collection at: %s\n", old_coll_path); closedir(storage_dir); return -1; } removed_olddirs = 1; } } if(removed_olddirs == 0) { printf("\nWARNING: No old collections with name \"%s\" " "were found to cleanup.\n", fs_config->file_system_name); } closedir(storage_dir); } else { /* complain if we don't recognize the version */ fprintf(stderr, "Error: unknown collection version: %s\n" " for fs: %s (%08x).\n", version, fs_config->file_system_name, fs_config->coll_id); return -1; } } return 0; }