void moveResource(char *resource, char *destination) {
if (!isNull(resource) && !isNull(destination)) {
dir_t *destinationDir = filesystem_resolveDirPath(destination, currentDirId, currentDirPrompt, NULL);
if (!destinationDir) {
printf("Cannot move: dir '%s' not found.\n", destination);
return;
}
dir_t *dirToMove = filesystem_resolveDirPath(resource, currentDirId, currentDirPrompt, NULL);
if (dirToMove) {
filesystem_moveDir(dirToMove, destinationDir->id);
dir_free(dirToMove);
} else {
// If couldn't find a dir, then try to find a file:
file_t *fileToMove = filesystem_resolveFilePath(resource, currentDirId, currentDirPrompt);
if (fileToMove) {
filesystem_moveFile(fileToMove, destinationDir->id);
file_free(fileToMove);
} else {
printf("Cannot move '%s': No such file or directory.\n", resource);
}
}
dir_free(destinationDir);
}
}
void db_free(struct db *db)
{
worker_free(db->worker);
dir_free(db->log_dir);
dir_free(db->index_dir);
close(db->log_fd);
free(db);
}
struct db *db_new(const char *directory)
{
struct db *db = _db_new(directory);
struct file *logfile = file_open_append(db->log_dir, "ydb.log");
if (logfile == NULL) {
goto error;
}
int fd = file_rind(logfile);
if (fd == -1) {
goto error;
}
db->log_fd = fd;
db->index_dir = dir_openat(db->log_dir, "index");
if (db->index_dir == NULL) {
db_free(db);
return NULL;
}
return db;
error:;
dir_free(db->log_dir);
free(db);
return NULL;
}
void changeDir(char *dirName) {
char *newDirPrompt;
dir_t *changeToDir = filesystem_resolveDirPath(dirName ? dirName : "/", currentDirId, currentDirPrompt, &newDirPrompt);
if (changeToDir) {
strcpy(currentDirId, changeToDir->id);
strcpy(currentDirPrompt, newDirPrompt);
free(newDirPrompt);
dir_free(changeToDir);
} else {
printf("cd %s: No such directory.\n", dirName);
}
}
void makeDir(char *dirName) {
if (!isNull(dirName)) {
dir_t *dir = dir_create();
dir->name = strdup(dirName);
strcpy(dir->parentId, currentDirId);
if (!filesystem_addDir(dir)) {
printf("Cannot create directory '%s': Directory or file already exists with that name.\n", dirName);
}
dir_free(dir);
}
}
static void add_archives(const char *path)
{
Array archives;
int i;
if ((archives = dir_scan(path, is_archive, NULL, NULL)))
{
array_sort(archives, cmp_dir_items);
for (i = 0; i < array_len(archives); i++)
fs_add_path(DIR_ITEM_GET(archives, i)->path);
dir_free(archives);
}
}
void renameResource(char *resource, char *newName) {
if (!isNull(resource) && !isNull(newName)) {
dir_t *dirToMove = filesystem_resolveDirPath(resource, currentDirId, currentDirPrompt, NULL);
if (dirToMove) {
filesystem_renameDir(dirToMove, newName);
dir_free(dirToMove);
} else {
// If couldn't find a dir, then try to find a file:
file_t *fileToMove = filesystem_resolveFilePath(resource, currentDirId, currentDirPrompt);
if (fileToMove) {
filesystem_renameFile(fileToMove, newName);
file_free(fileToMove);
} else {
printf("Cannot rename '%s': No such file or directory.\n", resource);
}
}
}
}
static struct db *_db_new(const char *directory)
{
struct db *db = malloc(sizeof(struct db));
memset(db, 0, sizeof(struct db));
db->log_fd = 2; /* stderr */
db->log_dir = dir_open(db, directory);
if (db->log_dir == NULL) {
free(db);
return NULL;
}
db->worker = worker_new(db);
if (db->worker == NULL) {
dir_free(db->log_dir);
free(db);
return NULL;
}
return db;
}
struct dir *dir_open(struct db *db, const char *pathname)
{
struct dir *dir = _dir_new(db, NULL, pathname);
dir->dir = opendir(pathname);
int r = (dir->dir != NULL) ? 0 : -1;
if (r == -1) {
r = mkdir(pathname, 0700);
DIRTRACE(dir, r, "mkdirat(\"%s\")", dir->pathname);
if (r == 0) {
dir->dir = opendir(pathname);
r = (dir->dir != NULL) ? 0 : -1;
DIRTRACE(dir, r, "opendir(\"%s\")", pathname);
}
if (r == -1) {
dir_free(dir);
return NULL;
}
}
return dir;
}
signed int fs_read_dir(FileSelector *fs, char *path) {
fs->offset = 0;
fs->current = 0;
fs->selectedfile = NULL;
if (fs->numentries) {
dir_free(fs->dir);
fs->numentries = 0;
}
if ((fs->dir = dir_read(path)) == NULL) {
/* couldn't read device... */
puts("fs_read_dir failed!");
return(-1);
}
if (fs->dir->numentries) {
fs->numentries = fs->dir->numentries;
} else {
free(fs->dir);
fs->numentries = 0;
}
return(fs->numentries);
}
struct dir *dir_openat(struct dir *top_dir, const char *dirname)
{
struct dir *dir = _dir_new(top_dir->db, top_dir->pathname, dirname);
dir->dir = opendirat(top_dir->dir, dirname);
int r = (dir->dir != NULL) ? 0 : -1;
DIRTRACE(dir, r, "opendirat(\"%s\")", dir->pathname);
if (r == -1) {
r = mkdirat(dirfd(top_dir->dir), dirname, 0700);
DIRTRACE(dir, r, "mkdirat(\"%s\")", dir->pathname);
if (r == 0) {
dir->dir = opendirat(top_dir->dir, dirname);
r = (dir->dir != NULL) ? 0 : -1;
DIRTRACE(dir, r, "opendirat(\"%s\")", dir->pathname);
}
if (r == -1) {
dir_free(dir);
return NULL;
}
}
return dir;
}
void deleteResource(char **parameters) {
if (!isNull(parameters[1])) {
if (string_equals_ignore_case(parameters[1], "-r")) {
dir_t *dir = filesystem_resolveDirPath(parameters[2], currentDirId, currentDirPrompt, NULL);
if (dir) {
filesystem_deleteDir(dir);
dir_free(dir);
} else {
printf("Cannot remove '%s': No such directory.\n", parameters[2]);
}
} else {
file_t *file = filesystem_resolveFilePath(parameters[1], currentDirId, currentDirPrompt);
if (file) {
filesystem_deleteFile(file);
file_free(file);
} else {
printf("Cannot remove '%s': No such file.\n", parameters[1]);
}
}
}
}
DIR *opendir(const TCHAR *path)
{
DIR *d;
UINT sem = SetErrorMode(SEM_FAILCRITICALERRORS); // disable 'no-disk' message box
DWORD fa = GetFileAttributes(path);
if ((fa != INVALID_FILE_ATTRIBUTES) && (fa & FILE_ATTRIBUTE_DIRECTORY)) {
d = dir_calloc();
if (d != NULL) {
TCHAR search_path[MAX_PATH];
bool slash = path[_tcslen(path) - 1] == '\\';
/* build search path for FindFirstFile, try not to append additional slashes
* as it throws Win9x off its groove for root directories */
_sntprintf(search_path, lengthof(search_path), _T("%s%s*"), path, slash ? _T("") : _T("\\"));
*lastof(search_path) = '\0';
d->hFind = FindFirstFile(search_path, &d->fd);
if (d->hFind != INVALID_HANDLE_VALUE ||
GetLastError() == ERROR_NO_MORE_FILES) { // the directory is empty
d->ent.dir = d;
d->at_first_entry = true;
} else {
dir_free(d);
d = NULL;
}
} else {
errno = ENOMEM;
}
} else {
/* path not found or not a directory */
d = NULL;
errno = ENOENT;
}
SetErrorMode(sem); // restore previous setting
return d;
}
void fs_dir_free(Array items)
{
dir_free(items);
}
/* Deallocate FileSelector object */
void fs_free(FileSelector *fs) {
if (fs->dir) {
dir_free(fs->dir);
}
free(fs);
}
int closedir(DIR *d)
{
FindClose(d->hFind);
dir_free(d);
return 0;
}
