653 lines
14 KiB
C
653 lines
14 KiB
C
#include "misc.h"
|
|
#include "posix.h"
|
|
|
|
#include <blue/core/error.h>
|
|
#include <blue/ds/string.h>
|
|
#include <blue/io/directory.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <fts.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
/*** PRIVATE DATA *************************************************************/
|
|
|
|
enum directory_flags {
|
|
DIRECTORY_DELETE_ON_CLOSE = 0x01u,
|
|
};
|
|
|
|
struct b_directory_p {
|
|
enum directory_flags d_flags;
|
|
int d_fd;
|
|
b_path *d_path_rel;
|
|
b_path *d_path_abs;
|
|
};
|
|
|
|
struct z__b_directory_iterator {
|
|
FTS *fts;
|
|
FTSENT *ent;
|
|
};
|
|
|
|
/*** PRIVATE FUNCTIONS ********************************************************/
|
|
static const b_path *directory_get_path(const struct b_directory_p *dir)
|
|
{
|
|
return dir->d_path_abs;
|
|
}
|
|
|
|
static const b_path *directory_get_rel_path(const struct b_directory_p *dir)
|
|
{
|
|
return dir->d_path_rel;
|
|
}
|
|
|
|
static const char *directory_get_path_cstr(const struct b_directory_p *dir)
|
|
{
|
|
return b_path_ptr(dir->d_path_abs);
|
|
}
|
|
|
|
static const char *directory_get_rel_path_cstr(const struct b_directory_p *dir)
|
|
{
|
|
return b_path_ptr(dir->d_path_rel);
|
|
}
|
|
|
|
static b_result directory_delete(b_directory *dir, struct b_directory_p *dir_p)
|
|
{
|
|
enum b_status status = B_SUCCESS;
|
|
|
|
struct b_directory_iterator it;
|
|
b_directory_iterator_begin(dir, &it, B_DIRECTORY_ITERATE_PARENT_LAST);
|
|
while (b_directory_iterator_is_valid(&it)) {
|
|
status = b_directory_iterator_erase(&it);
|
|
if (!B_OK(status)) {
|
|
return B_RESULT_STATUS(status);
|
|
}
|
|
}
|
|
|
|
status = b_path_unlink(dir_p->d_path_abs);
|
|
if (!B_OK(status)) {
|
|
return B_RESULT_STATUS(status);
|
|
}
|
|
|
|
return B_RESULT_SUCCESS;
|
|
}
|
|
|
|
static bool directory_path_exists(
|
|
const struct b_directory_p *root, const b_path *path)
|
|
{
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : NULL,
|
|
path,
|
|
};
|
|
|
|
b_path *abs_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!abs_path) {
|
|
return false;
|
|
}
|
|
|
|
bool result = b_path_exists(abs_path);
|
|
b_path_unref(abs_path);
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool directory_path_is_file(
|
|
const struct b_directory_p *root, const b_path *path)
|
|
{
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : NULL,
|
|
path,
|
|
};
|
|
|
|
b_path *abs_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!abs_path) {
|
|
return false;
|
|
}
|
|
|
|
bool result = b_path_is_file(abs_path);
|
|
b_path_unref(abs_path);
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool directory_path_is_directory(
|
|
const struct b_directory_p *root, const b_path *path)
|
|
{
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : NULL,
|
|
path,
|
|
};
|
|
|
|
b_path *abs_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!abs_path) {
|
|
return false;
|
|
}
|
|
|
|
bool result = b_path_is_directory(abs_path);
|
|
b_path_unref(abs_path);
|
|
|
|
return result;
|
|
}
|
|
|
|
static b_result directory_path_stat(
|
|
const struct b_directory_p *root, const b_path *path,
|
|
struct b_file_info *out)
|
|
{
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : NULL,
|
|
path,
|
|
};
|
|
|
|
b_path *abs_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!abs_path) {
|
|
return B_RESULT_ERR(NO_MEMORY);
|
|
}
|
|
|
|
enum b_status status = b_path_stat(abs_path, out);
|
|
b_path_unref(abs_path);
|
|
|
|
return B_RESULT_STATUS(status);
|
|
}
|
|
|
|
static b_result directory_path_unlink(
|
|
const struct b_directory_p *root, const b_path *path)
|
|
{
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : NULL,
|
|
path,
|
|
};
|
|
|
|
b_path *abs_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!abs_path) {
|
|
return B_RESULT_ERR(NO_MEMORY);
|
|
}
|
|
|
|
enum b_status status = b_path_unlink(abs_path);
|
|
b_path_unref(abs_path);
|
|
|
|
return B_RESULT_STATUS(status);
|
|
}
|
|
|
|
static b_result create_directory(struct b_directory_p *root, const char *path)
|
|
{
|
|
int root_fd = root ? root->d_fd : -1;
|
|
int err;
|
|
|
|
if (root_fd == -1) {
|
|
err = mkdir(path, 0755);
|
|
} else {
|
|
err = mkdirat(root_fd, path, 0755);
|
|
}
|
|
|
|
if (err == 0 || errno == EEXIST) {
|
|
return B_RESULT_SUCCESS;
|
|
}
|
|
|
|
return b_result_from_errno_with_subfilepath(
|
|
errno, path, directory_get_rel_path_cstr(root), B_ERR_IO_FAILURE);
|
|
}
|
|
|
|
static b_result create_directory_hierarchy(
|
|
struct b_directory_p *root, const char *path)
|
|
{
|
|
int root_fd = root->d_fd;
|
|
|
|
char *path_buf = b_strdup(path);
|
|
if (!path_buf) {
|
|
return B_RESULT_ERR(NO_MEMORY);
|
|
}
|
|
|
|
b_result result = B_RESULT_SUCCESS;
|
|
for (size_t i = 0; path_buf[i]; i++) {
|
|
if (path_buf[i] != '/') {
|
|
continue;
|
|
}
|
|
|
|
path_buf[i] = 0;
|
|
|
|
int err = mkdirat(root_fd, path_buf, 0755);
|
|
if (err != 0 && errno != EEXIST) {
|
|
result = b_result_from_errno_with_subfilepath(
|
|
errno, path_buf, directory_get_rel_path_cstr(root),
|
|
B_ERR_IO_FAILURE);
|
|
break;
|
|
}
|
|
|
|
path_buf[i] = '/';
|
|
}
|
|
|
|
int err = mkdirat(root_fd, path_buf, 0755);
|
|
if (err != 0 && errno != EEXIST) {
|
|
result = b_result_from_errno_with_subfilepath(
|
|
errno, path_buf, directory_get_rel_path_cstr(root),
|
|
B_ERR_IO_FAILURE);
|
|
}
|
|
|
|
free(path_buf);
|
|
return result;
|
|
}
|
|
|
|
static b_result directory_open(
|
|
struct b_directory_p *root, const b_path *path,
|
|
b_directory_open_flags flags, b_directory **out)
|
|
{
|
|
enum b_status status = B_SUCCESS;
|
|
|
|
int root_fd = root ? root->d_fd : AT_FDCWD;
|
|
|
|
const char *path_cstr = b_path_ptr(path);
|
|
if (root) {
|
|
while (*path_cstr == '/') {
|
|
path_cstr++;
|
|
}
|
|
}
|
|
|
|
b_result result = B_RESULT_SUCCESS;
|
|
if ((flags & B_DIRECTORY_OPEN_CREATE_INTERMEDIATE)
|
|
== B_DIRECTORY_OPEN_CREATE_INTERMEDIATE) {
|
|
result = create_directory_hierarchy(root, path_cstr);
|
|
} else if ((flags & B_DIRECTORY_OPEN_CREATE) == B_DIRECTORY_OPEN_CREATE) {
|
|
result = create_directory(root, path_cstr);
|
|
}
|
|
|
|
if (b_result_is_error(result)) {
|
|
return b_result_propagate(result);
|
|
}
|
|
|
|
int fd = openat(root_fd, path_cstr, O_DIRECTORY);
|
|
|
|
if (fd == -1) {
|
|
status = b_status_from_errno(errno, B_ERR_IO_FAILURE);
|
|
return B_RESULT_STATUS(status);
|
|
}
|
|
|
|
b_directory *dir = b_object_create(B_TYPE_DIRECTORY);
|
|
b_path *cwd = NULL;
|
|
struct b_directory_p *p = b_object_get_private(dir, B_TYPE_DIRECTORY);
|
|
|
|
if (!root) {
|
|
cwd = b_path_create_cwd();
|
|
}
|
|
|
|
const b_path *parts[] = {
|
|
root ? root->d_path_abs : cwd,
|
|
path,
|
|
};
|
|
|
|
b_path *new_path = b_path_join(parts, sizeof parts / sizeof parts[0]);
|
|
if (!new_path) {
|
|
return B_RESULT_ERR(NO_MEMORY);
|
|
}
|
|
|
|
if (cwd) {
|
|
b_path_unref(cwd);
|
|
}
|
|
|
|
p->d_path_abs = new_path;
|
|
p->d_path_rel = b_path_duplicate(path);
|
|
p->d_fd = fd;
|
|
|
|
if (flags & B_DIRECTORY_OPEN_DELETE_ON_CLOSE) {
|
|
p->d_flags = DIRECTORY_DELETE_ON_CLOSE;
|
|
}
|
|
|
|
*out = dir;
|
|
|
|
return B_RESULT_SUCCESS;
|
|
}
|
|
|
|
/*** PUBLIC FUNCTIONS *********************************************************/
|
|
|
|
b_result b_directory_open(
|
|
b_directory *root, const b_path *path, b_directory_open_flags flags,
|
|
b_directory **out)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(
|
|
B_TYPE_DIRECTORY, directory_open, root, path, flags, out);
|
|
}
|
|
|
|
b_result b_directory_open_temp(b_directory **out)
|
|
{
|
|
char name[16];
|
|
char path[128];
|
|
|
|
while (1) {
|
|
z__b_io_generate_tmp_filename(name, sizeof name);
|
|
snprintf(path, sizeof path, "/tmp/%s", name);
|
|
b_path *rpath = b_path_create_from_cstr(path);
|
|
|
|
b_directory *dir = NULL;
|
|
b_result status = b_directory_open(
|
|
B_DIRECTORY_ROOT, rpath, B_DIRECTORY_OPEN_CREATE, &dir);
|
|
struct b_directory_p *p
|
|
= b_object_get_private(dir, B_TYPE_DIRECTORY);
|
|
|
|
if (b_error_get_status_code(status) == B_ERR_NAME_EXISTS) {
|
|
b_path_unref(rpath);
|
|
continue;
|
|
}
|
|
|
|
if (dir) {
|
|
p->d_flags |= DIRECTORY_DELETE_ON_CLOSE;
|
|
}
|
|
|
|
b_path_unlink(rpath);
|
|
b_path_unref(rpath);
|
|
|
|
return status;
|
|
}
|
|
}
|
|
|
|
const b_path *b_directory_get_path(const b_directory *dir)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_DIRECTORY, directory_get_path, dir);
|
|
}
|
|
|
|
const b_path *b_directory_get_rel_path(const b_directory *dir)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_DIRECTORY, directory_get_rel_path, dir);
|
|
}
|
|
|
|
const char *b_directory_get_path_cstr(const b_directory *dir)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_DIRECTORY, directory_get_path_cstr, dir);
|
|
}
|
|
|
|
const char *b_directory_get_rel_path_cstr(const b_directory *dir)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(
|
|
B_TYPE_DIRECTORY, directory_get_rel_path_cstr, dir);
|
|
}
|
|
|
|
b_result b_directory_delete(b_directory *dir)
|
|
{
|
|
struct b_directory_p *p = b_object_get_private(dir, B_TYPE_DIRECTORY);
|
|
p->d_flags |= DIRECTORY_DELETE_ON_CLOSE;
|
|
/* TODO allow object release functions to return a b_result value */
|
|
b_directory_unref(dir);
|
|
return B_RESULT_SUCCESS;
|
|
}
|
|
|
|
bool b_directory_path_exists(const b_directory *root, const b_path *path)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_DIRECTORY, directory_path_exists, root, path);
|
|
}
|
|
|
|
bool b_directory_path_is_file(const b_directory *root, const b_path *path)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(
|
|
B_TYPE_DIRECTORY, directory_path_is_file, root, path);
|
|
}
|
|
|
|
bool b_directory_path_is_directory(const b_directory *root, const b_path *path)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(
|
|
B_TYPE_DIRECTORY, directory_path_is_directory, root, path);
|
|
}
|
|
|
|
b_result b_directory_path_stat(
|
|
const b_directory *root, const b_path *path, struct b_file_info *out)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(
|
|
B_TYPE_DIRECTORY, directory_path_stat, root, path, out);
|
|
}
|
|
|
|
b_result b_directory_path_unlink(const b_directory *root, const b_path *path)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_DIRECTORY, directory_path_unlink, root, path);
|
|
}
|
|
|
|
/*** VIRTUAL FUNCTIONS ********************************************************/
|
|
|
|
static void directory_init(b_object *obj, void *priv)
|
|
{
|
|
struct b_directory_p *dir = priv;
|
|
}
|
|
|
|
static void directory_fini(b_object *obj, void *priv)
|
|
{
|
|
struct b_directory_p *dir = priv;
|
|
|
|
close(dir->d_fd);
|
|
|
|
if (dir->d_flags & DIRECTORY_DELETE_ON_CLOSE) {
|
|
directory_delete(obj, dir);
|
|
}
|
|
|
|
b_path_unref(dir->d_path_abs);
|
|
}
|
|
|
|
/*** CLASS DEFINITION *********************************************************/
|
|
|
|
B_TYPE_CLASS_DEFINITION_BEGIN(b_directory)
|
|
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
|
|
B_INTERFACE_ENTRY(to_string) = NULL;
|
|
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
|
|
B_TYPE_CLASS_DEFINITION_END(b_directory)
|
|
|
|
B_TYPE_DEFINITION_BEGIN(b_directory)
|
|
B_TYPE_ID(0x10d36546, 0x7f96, 0x464b, 0xbc4d, 0xe504b283fa45);
|
|
B_TYPE_CLASS(b_directory_class);
|
|
B_TYPE_INSTANCE_PRIVATE(struct b_directory_p);
|
|
B_TYPE_INSTANCE_INIT(directory_init);
|
|
B_TYPE_INSTANCE_FINI(directory_fini);
|
|
B_TYPE_DEFINITION_END(b_directory)
|
|
|
|
/*** ITERATOR FUNCTIONS *******************************************************/
|
|
|
|
static int ftsent_compare(const FTSENT **one, const FTSENT **two)
|
|
{
|
|
return (strcmp((*one)->fts_name, (*two)->fts_name));
|
|
}
|
|
|
|
static void update_iterator_data(struct b_directory_iterator *it)
|
|
{
|
|
struct z__b_directory_iterator *it_data = it->_z;
|
|
|
|
if (it->filepath) {
|
|
b_path_unref((b_path *)it->filepath);
|
|
it->filepath = NULL;
|
|
}
|
|
|
|
FTSENT *ent = it_data->ent;
|
|
|
|
b_path *path = b_path_create_from_cstr(
|
|
ent->fts_path + b_path_length(it->_p->d_path_abs) + 1);
|
|
|
|
it->filename = ent->fts_name;
|
|
it->filepath = path;
|
|
|
|
memset(&it->info, 0x0, sizeof it->info);
|
|
|
|
it->info.length = ent->fts_statp->st_size;
|
|
|
|
if (S_ISREG(ent->fts_statp->st_mode)) {
|
|
it->info.attrib |= B_FILE_ATTRIB_NORMAL;
|
|
}
|
|
|
|
if (S_ISDIR(ent->fts_statp->st_mode)) {
|
|
it->info.attrib |= B_FILE_ATTRIB_DIRECTORY;
|
|
}
|
|
|
|
if (S_ISBLK(ent->fts_statp->st_mode)) {
|
|
it->info.attrib |= B_FILE_ATTRIB_BLOCK_DEVICE;
|
|
}
|
|
|
|
if (S_ISCHR(ent->fts_statp->st_mode)) {
|
|
it->info.attrib |= B_FILE_ATTRIB_CHAR_DEVICE;
|
|
}
|
|
|
|
if (S_ISLNK(ent->fts_statp->st_mode)) {
|
|
it->info.attrib |= B_FILE_ATTRIB_SYMLINK;
|
|
}
|
|
}
|
|
|
|
static void cleanup_iterator(struct b_directory_iterator *it)
|
|
{
|
|
if (it->filepath) {
|
|
b_path_unref((b_path *)it->filepath);
|
|
it->filepath = NULL;
|
|
}
|
|
|
|
struct z__b_directory_iterator *it_data = it->_z;
|
|
memset(it, 0x0, sizeof *it);
|
|
|
|
if (!it_data) {
|
|
return;
|
|
}
|
|
|
|
if (it_data->fts) {
|
|
fts_close(it_data->fts);
|
|
}
|
|
|
|
free(it_data);
|
|
}
|
|
|
|
int b_directory_iterator_begin(
|
|
b_directory *directory, struct b_directory_iterator *it,
|
|
enum b_directory_iterator_flags flags)
|
|
{
|
|
memset(it, 0x0, sizeof *it);
|
|
|
|
it->flags = flags;
|
|
it->root = directory;
|
|
it->_p = b_object_get_private(directory, B_TYPE_DIRECTORY);
|
|
|
|
struct z__b_directory_iterator *it_data = malloc(sizeof *it_data);
|
|
|
|
if (!it_data) {
|
|
return -1;
|
|
}
|
|
|
|
memset(it_data, 0x0, sizeof *it_data);
|
|
|
|
it->_z = it_data;
|
|
|
|
int fts_flags = FTS_COMFOLLOW | FTS_NOCHDIR;
|
|
|
|
const char *path_list[] = {
|
|
b_path_ptr(it->_p->d_path_abs),
|
|
NULL,
|
|
};
|
|
|
|
it_data->fts
|
|
= fts_open((char *const *)path_list, fts_flags, ftsent_compare);
|
|
|
|
bool done = false;
|
|
|
|
while (!done) {
|
|
it_data->ent = fts_read(it_data->fts);
|
|
|
|
if (!it_data->ent) {
|
|
cleanup_iterator(it);
|
|
return -1;
|
|
}
|
|
|
|
if (it_data->ent->fts_level == 0) {
|
|
continue;
|
|
}
|
|
|
|
switch (it_data->ent->fts_info) {
|
|
case FTS_DOT:
|
|
continue;
|
|
case FTS_F:
|
|
done = true;
|
|
break;
|
|
case FTS_D:
|
|
if (it->flags & B_DIRECTORY_ITERATE_PARENT_LAST) {
|
|
continue;
|
|
}
|
|
|
|
done = true;
|
|
break;
|
|
case FTS_DP:
|
|
if (it->flags & B_DIRECTORY_ITERATE_PARENT_FIRST) {
|
|
continue;
|
|
}
|
|
done = true;
|
|
break;
|
|
default:
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
update_iterator_data(it);
|
|
return 0;
|
|
}
|
|
|
|
bool b_directory_iterator_next(struct b_directory_iterator *it)
|
|
{
|
|
struct z__b_directory_iterator *it_data = it->_z;
|
|
if (!it_data || !it_data->fts) {
|
|
return false;
|
|
}
|
|
|
|
bool done = false;
|
|
|
|
while (!done) {
|
|
it_data->ent = fts_read(it_data->fts);
|
|
|
|
if (!it_data->ent) {
|
|
cleanup_iterator(it);
|
|
return false;
|
|
}
|
|
|
|
if (it_data->ent->fts_level == 0) {
|
|
continue;
|
|
}
|
|
|
|
switch (it_data->ent->fts_info) {
|
|
case FTS_DOT:
|
|
continue;
|
|
case FTS_F:
|
|
done = true;
|
|
break;
|
|
case FTS_D:
|
|
if (it->flags & B_DIRECTORY_ITERATE_PARENT_LAST) {
|
|
continue;
|
|
}
|
|
done = true;
|
|
break;
|
|
case FTS_DP:
|
|
if (it->flags & B_DIRECTORY_ITERATE_PARENT_FIRST) {
|
|
continue;
|
|
}
|
|
done = true;
|
|
break;
|
|
default:
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
update_iterator_data(it);
|
|
return true;
|
|
}
|
|
|
|
enum b_status b_directory_iterator_erase(struct b_directory_iterator *it)
|
|
{
|
|
b_result result = b_directory_path_unlink(it->root, it->filepath);
|
|
if (b_result_is_error(result)) {
|
|
enum b_status status = b_error_get_status_code(result);
|
|
b_error_release(result);
|
|
return status;
|
|
}
|
|
|
|
b_directory_iterator_next(it);
|
|
return B_SUCCESS;
|
|
}
|
|
|
|
bool b_directory_iterator_is_valid(const struct b_directory_iterator *it)
|
|
{
|
|
if (!it->_z) {
|
|
return false;
|
|
}
|
|
|
|
if (!it->_z->ent) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|