446 lines
14 KiB
C
446 lines
14 KiB
C
/*************************************************************************
|
|
*
|
|
* Orca
|
|
* Copyright 2023 Martin Fouilleul and the Orca project contributors
|
|
* See LICENSE.txt for licensing information
|
|
*
|
|
**************************************************************************/
|
|
#include "app/app.h"
|
|
#include "platform/platform_io_internal.h"
|
|
#include "platform/platform_path.h"
|
|
|
|
oc_file_table oc_globalFileTable = { 0 };
|
|
|
|
oc_file_table* oc_file_table_get_global()
|
|
{
|
|
return (&oc_globalFileTable);
|
|
}
|
|
|
|
oc_file_slot* oc_file_slot_alloc(oc_file_table* table)
|
|
{
|
|
oc_file_slot* slot = oc_list_pop_entry(&table->freeList, oc_file_slot, freeListElt);
|
|
if(!slot && table->nextSlot < OC_IO_MAX_FILE_SLOTS)
|
|
{
|
|
slot = &table->slots[table->nextSlot];
|
|
slot->generation = 1;
|
|
table->nextSlot++;
|
|
}
|
|
|
|
u32 tmpGeneration = slot->generation;
|
|
memset(slot, 0, sizeof(oc_file_slot));
|
|
slot->generation = tmpGeneration;
|
|
|
|
return (slot);
|
|
}
|
|
|
|
void oc_file_slot_recycle(oc_file_table* table, oc_file_slot* slot)
|
|
{
|
|
slot->generation++;
|
|
oc_list_push(&table->freeList, &slot->freeListElt);
|
|
}
|
|
|
|
oc_file oc_file_from_slot(oc_file_table* table, oc_file_slot* slot)
|
|
{
|
|
u64 index = slot - table->slots;
|
|
u64 generation = slot->generation;
|
|
oc_file handle = { .h = (generation << 32) | index };
|
|
return (handle);
|
|
}
|
|
|
|
oc_file_slot* oc_file_slot_from_handle(oc_file_table* table, oc_file handle)
|
|
{
|
|
oc_file_slot* slot = 0;
|
|
|
|
u64 index = handle.h & 0xffffffff;
|
|
u64 generation = handle.h >> 32;
|
|
|
|
if(index < table->nextSlot)
|
|
{
|
|
oc_file_slot* candidate = &table->slots[index];
|
|
if(candidate->generation == generation)
|
|
{
|
|
slot = candidate;
|
|
}
|
|
}
|
|
return (slot);
|
|
}
|
|
|
|
oc_io_cmp oc_io_wait_single_req(oc_io_req* req)
|
|
{
|
|
return (oc_io_wait_single_req_for_table(req, &oc_globalFileTable));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
// io common primitives
|
|
//-----------------------------------------------------------------------
|
|
|
|
typedef struct oc_io_open_restrict_context
|
|
{
|
|
oc_io_error error;
|
|
u64 rootUID;
|
|
oc_file_desc rootFd;
|
|
oc_file_desc fd;
|
|
|
|
} oc_io_open_restrict_context;
|
|
|
|
oc_io_error oc_io_open_restrict_enter(oc_io_open_restrict_context* context, oc_str8 name, oc_file_access accessRights, oc_file_open_flags openFlags)
|
|
{
|
|
oc_file_desc nextFd = oc_io_raw_open_at(context->fd, name, accessRights, openFlags);
|
|
if(oc_file_desc_is_nil(nextFd))
|
|
{
|
|
context->error = oc_io_raw_last_error();
|
|
}
|
|
else
|
|
{
|
|
if(context->fd != context->rootFd)
|
|
{
|
|
oc_io_raw_close(context->fd);
|
|
}
|
|
context->fd = nextFd;
|
|
}
|
|
return (context->error);
|
|
}
|
|
|
|
typedef struct oc_io_open_restrict_result
|
|
{
|
|
oc_io_error error;
|
|
oc_file_desc fd;
|
|
} oc_io_open_restrict_result;
|
|
|
|
oc_io_open_restrict_result oc_io_open_restrict(oc_file_desc dirFd, oc_str8 path, oc_file_access accessRights, oc_file_open_flags openFlags)
|
|
{
|
|
oc_arena_scope scratch = oc_scratch_begin();
|
|
|
|
oc_str8_list sep = { 0 };
|
|
oc_str8_list_push(scratch.arena, &sep, OC_STR8("/"));
|
|
oc_str8_list_push(scratch.arena, &sep, OC_STR8("\\"));
|
|
oc_str8_list pathElements = oc_str8_split(scratch.arena, path, sep);
|
|
|
|
oc_io_open_restrict_context context = {
|
|
.error = OC_IO_OK,
|
|
.rootFd = dirFd,
|
|
.fd = dirFd,
|
|
};
|
|
|
|
if(oc_file_desc_is_nil(dirFd))
|
|
{
|
|
context.error = OC_IO_ERR_HANDLE;
|
|
}
|
|
else
|
|
{
|
|
oc_file_status status;
|
|
context.error = oc_io_raw_fstat(dirFd, &status);
|
|
context.rootUID = status.uid;
|
|
}
|
|
|
|
if(context.error == OC_IO_OK)
|
|
{
|
|
oc_list_for(pathElements.list, elt, oc_str8_elt, listElt)
|
|
{
|
|
oc_str8 name = elt->string;
|
|
oc_file_access eltAccessRights = OC_FILE_ACCESS_READ;
|
|
oc_file_open_flags eltOpenFlags = 0;
|
|
|
|
bool atLastElement = (&elt->listElt == oc_list_last(pathElements.list));
|
|
if(atLastElement)
|
|
{
|
|
eltAccessRights = accessRights;
|
|
eltOpenFlags = openFlags;
|
|
}
|
|
|
|
if(!oc_str8_cmp(name, OC_STR8("."))
|
|
&& !atLastElement)
|
|
{
|
|
//NOTE: if we're not at the last element we can just skip '.' elements
|
|
continue;
|
|
}
|
|
else if(!oc_str8_cmp(name, OC_STR8("..")))
|
|
{
|
|
//NOTE: check that we don't escape root dir
|
|
oc_file_status status;
|
|
context.error = oc_io_raw_fstat(context.fd, &status);
|
|
if(context.error)
|
|
{
|
|
break;
|
|
}
|
|
else if(status.uid == context.rootUID)
|
|
{
|
|
context.error = OC_IO_ERR_WALKOUT;
|
|
break;
|
|
}
|
|
}
|
|
else if(!oc_io_raw_file_exists_at(context.fd, name, OC_FILE_OPEN_SYMLINK))
|
|
{
|
|
//NOTE: if the file doesn't exists, but we're at the last element and OC_FILE_OPEN_CREATE
|
|
// is set, we create the file. Otherwise it is a OC_IO_ERROR_NO_ENTRY error.
|
|
if(!atLastElement
|
|
|| !(openFlags & OC_FILE_OPEN_CREATE))
|
|
{
|
|
context.error = OC_IO_ERR_NO_ENTRY;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//NOTE: if the file exists, we check the type of file
|
|
oc_file_status status = { 0 };
|
|
context.error = oc_io_raw_fstat_at(context.fd, name, OC_FILE_OPEN_SYMLINK, &status);
|
|
if(context.error)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(status.type == OC_FILE_REGULAR)
|
|
{
|
|
if(!atLastElement)
|
|
{
|
|
context.error = OC_IO_ERR_NOT_DIR;
|
|
break;
|
|
}
|
|
}
|
|
else if(status.type == OC_FILE_SYMLINK)
|
|
{
|
|
//TODO - do we need a OC_FILE_OPEN_NO_FOLLOW that fails if last element is a symlink?
|
|
// - do we need a OC_FILE_OPEN_NO_SYMLINKS that fails if _any_ element is a symlink?
|
|
|
|
if(!atLastElement
|
|
|| !(openFlags & OC_FILE_OPEN_SYMLINK))
|
|
{
|
|
oc_io_raw_read_link_result link = oc_io_raw_read_link_at(scratch.arena, context.fd, name);
|
|
if(link.error)
|
|
{
|
|
context.error = link.error;
|
|
break;
|
|
}
|
|
if(link.target.len == 0)
|
|
{
|
|
//NOTE: treat an empty target as a '.'
|
|
link.target = OC_STR8(".");
|
|
}
|
|
else if(oc_path_is_absolute(link.target))
|
|
{
|
|
context.error = OC_IO_ERR_WALKOUT;
|
|
break;
|
|
}
|
|
|
|
oc_str8_list linkElements = oc_str8_split(scratch.arena, link.target, sep);
|
|
if(!oc_list_empty(linkElements.list))
|
|
{
|
|
//NOTE: insert linkElements into pathElements after elt
|
|
oc_list_elt* tmp = elt->listElt.next;
|
|
elt->listElt.next = linkElements.list.first;
|
|
linkElements.list.last->next = tmp;
|
|
if(!tmp)
|
|
{
|
|
pathElements.list.last = linkElements.list.last;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
else if(status.type != OC_FILE_DIRECTORY)
|
|
{
|
|
context.error = OC_IO_ERR_NOT_DIR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//NOTE: if we arrive here, we have no errors and the correct flags are set,
|
|
// so we can enter the element
|
|
OC_DEBUG_ASSERT(context.error == OC_IO_OK);
|
|
oc_io_open_restrict_enter(&context, name, eltAccessRights, eltOpenFlags);
|
|
}
|
|
}
|
|
|
|
if(context.error && !oc_file_desc_is_nil(context.fd))
|
|
{
|
|
if(context.fd != context.rootFd)
|
|
{
|
|
oc_io_raw_close(context.fd);
|
|
}
|
|
context.fd = oc_file_desc_nil();
|
|
}
|
|
|
|
oc_io_open_restrict_result result = {
|
|
.error = context.error,
|
|
.fd = context.fd
|
|
};
|
|
|
|
oc_scratch_end(scratch);
|
|
return (result);
|
|
}
|
|
|
|
oc_io_cmp oc_io_open_at(oc_file_slot* atSlot, oc_io_req* req, oc_file_table* table)
|
|
{
|
|
oc_io_cmp cmp = { 0 };
|
|
|
|
oc_file_slot* slot = oc_file_slot_alloc(table);
|
|
if(!slot)
|
|
{
|
|
cmp.error = OC_IO_ERR_MAX_FILES;
|
|
cmp.result = 0;
|
|
}
|
|
else
|
|
{
|
|
slot->fd = oc_file_desc_nil();
|
|
cmp.handle = oc_file_from_slot(table, slot);
|
|
|
|
oc_str8 path = oc_str8_from_buffer(req->size, req->buffer);
|
|
|
|
if(!path.len)
|
|
{
|
|
slot->error = OC_IO_ERR_ARG;
|
|
}
|
|
else if(!atSlot && !oc_file_is_nil(req->handle))
|
|
{
|
|
slot->error = OC_IO_ERR_HANDLE;
|
|
}
|
|
else
|
|
{
|
|
slot->rights = req->open.rights;
|
|
if(atSlot)
|
|
{
|
|
slot->rights &= atSlot->rights;
|
|
}
|
|
|
|
if(slot->rights != req->open.rights)
|
|
{
|
|
slot->error = OC_IO_ERR_PERM;
|
|
}
|
|
else
|
|
{
|
|
oc_file_desc dirFd = atSlot ? atSlot->fd : oc_file_desc_nil();
|
|
|
|
if(req->open.flags & OC_FILE_OPEN_RESTRICT)
|
|
{
|
|
oc_io_open_restrict_result res = oc_io_open_restrict(dirFd, path, slot->rights, req->open.flags);
|
|
slot->error = res.error;
|
|
slot->fd = res.fd;
|
|
}
|
|
else
|
|
{
|
|
slot->fd = oc_io_raw_open_at(dirFd, path, slot->rights, req->open.flags);
|
|
if(oc_file_desc_is_nil(slot->fd))
|
|
{
|
|
slot->error = oc_io_raw_last_error();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(slot->error == OC_IO_OK)
|
|
{
|
|
oc_file_status status;
|
|
slot->error = oc_io_raw_fstat(slot->fd, &status);
|
|
if(slot->error == OC_IO_OK)
|
|
{
|
|
slot->type = status.type;
|
|
}
|
|
}
|
|
|
|
if(slot->error)
|
|
{
|
|
slot->fatal = true;
|
|
cmp.error = slot->error;
|
|
}
|
|
}
|
|
return (cmp);
|
|
}
|
|
|
|
oc_file oc_file_open_with_request_for_table(oc_str8 path, oc_file_access rights, oc_file_open_flags flags, oc_file_table* table)
|
|
{
|
|
oc_arena_scope scratch = oc_scratch_begin();
|
|
oc_str8 msg = oc_str8_pushf(scratch.arena, "Application wants to access file '%.*s'.", (int)path.len, path.ptr);
|
|
|
|
oc_str8_list options = { 0 };
|
|
oc_str8_list_push(scratch.arena, &options, OC_STR8("Deny"));
|
|
oc_str8_list_push(scratch.arena, &options, OC_STR8("Accept"));
|
|
|
|
int res = oc_alert_popup(OC_STR8("File Access"), msg, options);
|
|
|
|
oc_file file = oc_file_nil();
|
|
if(res == 1)
|
|
{
|
|
oc_io_cmp cmp = { 0 };
|
|
|
|
oc_io_req req = {
|
|
.op = OC_IO_OPEN_AT,
|
|
.size = path.len,
|
|
.buffer = path.ptr,
|
|
.open.rights = rights,
|
|
.open.flags = flags
|
|
};
|
|
cmp = oc_io_open_at(0, &req, table);
|
|
if(cmp.error == OC_IO_OK)
|
|
{
|
|
file = cmp.handle;
|
|
}
|
|
}
|
|
|
|
oc_scratch_end(scratch);
|
|
|
|
return (file);
|
|
}
|
|
|
|
oc_file oc_file_open_with_request(oc_str8 path, oc_file_access rights, oc_file_open_flags flags)
|
|
{
|
|
return (oc_file_open_with_request_for_table(path, rights, flags, &oc_globalFileTable));
|
|
}
|
|
|
|
oc_file_open_with_dialog_result oc_file_open_with_dialog_for_table(oc_arena* arena,
|
|
oc_file_access rights,
|
|
oc_file_open_flags flags,
|
|
oc_file_dialog_desc* desc,
|
|
oc_file_table* table)
|
|
{
|
|
oc_arena_scope scratch = oc_scratch_begin_next(arena);
|
|
|
|
oc_file_dialog_result dialogResult = oc_file_dialog_for_table(scratch.arena, desc, table);
|
|
|
|
oc_file_open_with_dialog_result result = {
|
|
.button = dialogResult.button
|
|
};
|
|
|
|
if(dialogResult.button == OC_FILE_DIALOG_OK)
|
|
{
|
|
int i = 0;
|
|
oc_list_for(dialogResult.selection.list, elt, oc_str8_elt, listElt)
|
|
{
|
|
oc_file file = oc_file_nil();
|
|
if(elt->string.len)
|
|
{
|
|
oc_io_req req = {
|
|
.op = OC_IO_OPEN_AT,
|
|
.size = elt->string.len,
|
|
.buffer = elt->string.ptr,
|
|
.open.rights = rights,
|
|
.open.flags = flags
|
|
};
|
|
|
|
oc_io_cmp cmp = oc_io_wait_single_req_for_table(&req, table);
|
|
file = cmp.handle;
|
|
}
|
|
|
|
oc_file_open_with_dialog_elt* resElt = oc_arena_push_type(arena, oc_file_open_with_dialog_elt);
|
|
memset(resElt, 0, sizeof(*resElt));
|
|
resElt->file = file;
|
|
oc_list_push_back(&result.selection, &resElt->listElt);
|
|
|
|
if(i == 0)
|
|
{
|
|
result.file = file;
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
oc_scratch_end(scratch);
|
|
|
|
return (result);
|
|
}
|
|
|
|
oc_file_open_with_dialog_result oc_file_open_with_dialog(oc_arena* arena, oc_file_access rights, oc_file_open_flags flags, oc_file_dialog_desc* desc)
|
|
{
|
|
return (oc_file_open_with_dialog_for_table(arena, rights, flags, desc, &oc_globalFileTable));
|
|
}
|