Directory traversal support

include/aws/common/file.h

@@ -4,7 +4,58 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+#include <aws/common/byte_buf.h>
 #include <aws/common/common.h>
+#include <aws/common/linked_list.h>
+#include <aws/common/ref_count.h>
+
+#ifdef _WIN32
+static const char AWS_PATH_DELIM = '\\';
+#else
+static const char AWS_PATH_DELIM = '/';
+#endif
+
+enum aws_file_type {
+    AWS_FILE_TYPE_NONE,
+    AWS_FILE_TYPE_FILE,
+    AWS_FILE_TYPE_SYM_LINK,
+    AWS_FILE_TYPE_DIRECTORY,
+};
+
+struct aws_directory_entry {
+    struct aws_allocator *allocator;
+    struct aws_string *path;
+    struct aws_string *relative_path;
+    enum aws_file_type file_type;
+    int64_t file_size;
+    struct aws_linked_list children;
+    struct aws_linked_list_node node;
+    struct aws_directory_entry *parent;
+    struct aws_ref_count ref_count;
+    void *impl;
+};
+
+/**
+ * Platform implementation of opening a file and loading its immediate children (not recursive).
+ * return AWS_OP_SUCCESS if successful.
+ */
+int aws_directory_entry_open_internal(struct aws_directory_entry *entry);
+
+/**
+ * Destroy any resources allocated in aws_directory_entry_open_internal.
+ */
+void aws_directory_entry_destroy_internal(struct aws_directory_entry *entry);
+
+/**
+ * General function for allocating and setting up a directory entry. Use for allocating and setting up the
+ * platform agnostic portions of aws_directory_entry.
+ *
+ * returns an instance of aws_directory_entry on success and NULL on failure.
+ */
+struct aws_directory_entry *aws_directory_entry_open_base(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor path,
+    struct aws_byte_cursor relative_path);
 
 AWS_EXTERN_C_BEGIN
 
@@ -17,6 +68,54 @@ AWS_EXTERN_C_BEGIN
 AWS_COMMON_API
 FILE *aws_fopen(const char *file_path, const char *mode);
 
+/**
+ * Opens a directory at path. It's ref-count will be initialized to 1 on successful return.
+ * You must call aws_directory_entry_release() when finished or the resource will leak.
+ *
+ * This function allocates resources for children in the directory, but only with a depth of one. To get to the
+ * next level, you call aws_directory_entry_descend() which will repeat this process.
+ */
+AWS_COMMON_API struct aws_directory_entry *aws_directory_entry_open(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor path,
+    struct aws_byte_cursor relative_path);
+
+/**
+ * Holds a reference to the entry. Call this before seating an instance of aws_directory_entry().
+ */
+AWS_COMMON_API void aws_directory_entry_acquire(struct aws_directory_entry *entry);
+
+/**
+ * Releases reference to entry. When the last reference is dropped, the resource will be freed.
+ */
+AWS_COMMON_API void aws_directory_entry_release(struct aws_directory_entry *entry);
+
+/**
+ * Get's the next directory entry at the current directory depth level as entry. Returns NULL when there are no more
+ * sibling entries.
+ */
+AWS_COMMON_API struct aws_directory_entry *aws_directory_entry_get_next_sibling(struct aws_directory_entry *entry);
+
+/**
+ * Get's the previous directory entry at the current directory depth level as entry. Returns NULL when there are no more
+ * sibling entries.
+ */
+AWS_COMMON_API struct aws_directory_entry *aws_directory_entry_get_prev_sibling(struct aws_directory_entry *entry);
+
+/**
+ * Descends into the next depth level for entry. Returns the first child in entry. Returns NULL if entry is not a
+ * directory or it's empty. The return value's reference count is owned by entry. You do not need to acquire unless
+ * you'll be seating the return value beyond the scope of the root entry.
+ */
+AWS_COMMON_API struct aws_directory_entry *aws_directory_entry_descend(struct aws_directory_entry *entry);
+
+/**
+ * Returns the parent for the current entry unless the entry is the initial root directory from
+ * aws_directory_entry_open(). In that case it returns NULL. Also note, you do not need to acquire or release a
+ * reference to the returned value unless you plan on seating it beyond the scope of the root entry.
+ */
+AWS_COMMON_API struct aws_directory_entry *aws_directory_entry_parent(struct aws_directory_entry *entry);
+
 AWS_EXTERN_C_END
 
 #endif /* AWS_COMMON_FILE_H */

source/allocator.c

@@ -119,7 +119,9 @@ void *aws_mem_acquire(struct aws_allocator *allocator, size_t size) {
 
     void *mem = allocator->mem_acquire(allocator, size);
     if (!mem) {
-        aws_raise_error(AWS_ERROR_OOM);
+        AWS_FATAL_ASSERT(
+            mem && "memory allocation failed. If you don't want to exit when this happens, handle OOM in your "
+                   "allocator implementation");
     }
     return mem;
 }
@@ -135,23 +137,26 @@ void *aws_mem_calloc(struct aws_allocator *allocator, size_t num, size_t size) {
      */
     size_t required_bytes;
     if (aws_mul_size_checked(num, size, &required_bytes)) {
-        return NULL;
+        AWS_FATAL_ASSERT("illegal size for calloc()");
     }
 
     /* If there is a defined calloc, use it */
     if (allocator->mem_calloc) {
         void *mem = allocator->mem_calloc(allocator, num, size);
         if (!mem) {
-            aws_raise_error(AWS_ERROR_OOM);
+            AWS_FATAL_ASSERT(
+                mem && "memory allocation failed. If you don't want to exit when this happens, handle OOM in your "
+                       "allocator implementation");
         }
         return mem;
     }
 
     /* Otherwise, emulate calloc */
     void *mem = allocator->mem_acquire(allocator, required_bytes);
     if (!mem) {
-        aws_raise_error(AWS_ERROR_OOM);
-        return NULL;
+        AWS_FATAL_ASSERT(
+            mem && "memory allocation failed. If you don't want to exit when this happens, handle OOM in your "
+                   "allocator implementation");
     }
     memset(mem, 0, required_bytes);
     AWS_POSTCONDITION(mem != NULL);
@@ -186,8 +191,9 @@ void *aws_mem_acquire_many(struct aws_allocator *allocator, size_t count, ...) {
 
         allocation = aws_mem_acquire(allocator, total_size);
         if (!allocation) {
-            aws_raise_error(AWS_ERROR_OOM);
-            goto cleanup;
+            AWS_FATAL_ASSERT(
+                allocation && "memory allocation failed. If you don't want to exit when this happens, handle OOM in "
+                              "your allocator implementation");
         }
 
         uint8_t *current_ptr = allocation;
@@ -204,7 +210,6 @@ void *aws_mem_acquire_many(struct aws_allocator *allocator, size_t count, ...) {
         }
     }
 
-cleanup:
     va_end(args_allocs);
     return allocation;
 }
@@ -235,7 +240,9 @@ int aws_mem_realloc(struct aws_allocator *allocator, void **ptr, size_t oldsize,
     if (allocator->mem_realloc) {
         void *newptr = allocator->mem_realloc(allocator, *ptr, oldsize, newsize);
         if (!newptr) {
-            return aws_raise_error(AWS_ERROR_OOM);
+            AWS_FATAL_ASSERT(
+                newptr && "memory allocation failed. If you don't want to exit when this happens, handle OOM in your "
+                          "allocator implementation");
         }
         *ptr = newptr;
         return AWS_OP_SUCCESS;
@@ -248,7 +255,9 @@ int aws_mem_realloc(struct aws_allocator *allocator, void **ptr, size_t oldsize,
 
     void *newptr = allocator->mem_acquire(allocator, newsize);
     if (!newptr) {
-        return aws_raise_error(AWS_ERROR_OOM);
+        AWS_FATAL_ASSERT(
+            newptr && "memory allocation failed. If you don't want to exit when this happens, handle OOM in your "
+                      "allocator implementation");
     }
 
     memcpy(newptr, *ptr, oldsize);
@@ -274,10 +283,6 @@ static void *s_cf_allocator_allocate(CFIndex alloc_size, CFOptionFlags hint, voi
 
     void *mem = aws_mem_acquire(allocator, (size_t)alloc_size + sizeof(size_t));
 
-    if (!mem) {
-        return NULL;
-    }
-
     size_t allocation_size = (size_t)alloc_size + sizeof(size_t);
     memcpy(mem, &allocation_size, sizeof(size_t));
     return (void *)((uint8_t *)mem + sizeof(size_t));
@@ -301,9 +306,7 @@ static void *s_cf_allocator_reallocate(void *ptr, CFIndex new_size, CFOptionFlag
     size_t original_size = 0;
     memcpy(&original_size, original_allocation, sizeof(size_t));
 
-    if (aws_mem_realloc(allocator, &original_allocation, original_size, (size_t)new_size)) {
-        return NULL;
-    }
+    aws_mem_realloc(allocator, &original_allocation, original_size, (size_t)new_size);
 
     size_t new_allocation_size = (size_t)new_size;
     memcpy(original_allocation, &new_allocation_size, sizeof(size_t));
@@ -347,9 +350,7 @@ CFAllocatorRef aws_wrapped_cf_allocator_new(struct aws_allocator *allocator) {
 
     cf_allocator = CFAllocatorCreate(NULL, &context);
 
-    if (!cf_allocator) {
-        aws_raise_error(AWS_ERROR_OOM);
-    }
+    AWS_FATAL_ASSERT(cf_allocator && "creation of cf allocator failed!");
 
     return cf_allocator;
 }

source/file.c

@@ -0,0 +1,117 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/file.h>
+#include <aws/common/string.h>
+
+static void s_ref_dropped_callback(void *dir_ent) {
+    struct aws_directory_entry *entry = dir_ent;
+    aws_directory_entry_destroy_internal(entry);
+
+    while (!aws_linked_list_empty(&entry->children)) {
+        struct aws_linked_list_node *child = aws_linked_list_pop_front(&entry->children);
+        struct aws_directory_entry *child_entry = AWS_CONTAINER_OF(child, struct aws_directory_entry, node);
+        aws_directory_entry_release(child_entry);
+    }
+
+    aws_string_destroy(entry->path);
+    aws_string_destroy(entry->relative_path);
+    aws_mem_release(entry->allocator, entry);
+}
+
+struct aws_directory_entry *aws_directory_entry_open_base(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor path,
+    struct aws_byte_cursor relative_path) {
+    struct aws_directory_entry *entry = aws_mem_calloc(allocator, 1, sizeof(struct aws_directory_entry));
+
+    struct aws_byte_cursor trimmed_path = aws_byte_cursor_trim_pred(&path, aws_isspace);
+    struct aws_byte_cursor trimmed_relative_path = aws_byte_cursor_trim_pred(&relative_path, aws_isspace);
+
+    if (trimmed_path.len && trimmed_path.ptr[trimmed_path.len - 1] == AWS_PATH_DELIM) {
+        trimmed_path.len -= 1;
+    }
+
+    entry->path = aws_string_new_from_cursor(allocator, &trimmed_path);
+
+    if (trimmed_relative_path.len && trimmed_relative_path.ptr[trimmed_relative_path.len - 1] == AWS_PATH_DELIM) {
+        trimmed_relative_path.len -= 1;
+    }
+
+    entry->relative_path = aws_string_new_from_cursor(allocator, &trimmed_relative_path);
+
+    entry->allocator = allocator;
+    aws_ref_count_init(&entry->ref_count, entry, s_ref_dropped_callback);
+    aws_linked_list_init(&entry->children);
+
+    return entry;
+}
+
+struct aws_directory_entry *aws_directory_entry_open(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor path,
+    struct aws_byte_cursor relative_path) {
+    struct aws_directory_entry *entry = aws_directory_entry_open_base(allocator, path, relative_path);
+
+    if (aws_directory_entry_open_internal(entry)) {
+        aws_string_destroy(entry->path);
+        aws_string_destroy(entry->relative_path);
+        aws_mem_release(entry->allocator, entry);
+        return NULL;
+    }
+
+    return entry;
+}
+
+void aws_directory_entry_acquire(struct aws_directory_entry *entry) {
+    aws_ref_count_acquire(&entry->ref_count);
+}
+
+void aws_directory_entry_release(struct aws_directory_entry *entry) {
+    aws_ref_count_release(&entry->ref_count);
+}
+
+struct aws_directory_entry *aws_directory_entry_get_next_sibling(struct aws_directory_entry *entry) {
+    if (aws_linked_list_node_next_is_valid(&entry->node)) {
+        struct aws_linked_list_node *sibling = aws_linked_list_next(&entry->node);
+        return AWS_CONTAINER_OF(sibling, struct aws_directory_entry, node);
+    }
+
+    return NULL;
+}
+
+struct aws_directory_entry *aws_directory_entry_get_prev_sibling(struct aws_directory_entry *entry) {
+    if (aws_linked_list_node_prev_is_valid(&entry->node)) {
+        struct aws_linked_list_node *sibling = aws_linked_list_prev(&entry->node);
+        return AWS_CONTAINER_OF(sibling, struct aws_directory_entry, node);
+    }
+
+    return NULL;
+}
+
+struct aws_directory_entry *aws_directory_entry_parent(struct aws_directory_entry *entry) {
+    return entry->parent;
+}
+
+struct aws_directory_entry *aws_directory_entry_descend(struct aws_directory_entry *entry) {
+    if (entry->file_type != AWS_FILE_TYPE_DIRECTORY && entry->file_type != AWS_FILE_TYPE_SYM_LINK) {
+        aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+        return NULL;
+    }
+
+    if (aws_linked_list_empty(&entry->children)) {
+        if (aws_directory_entry_open_internal(entry)) {
+            return NULL;
+        }
+    }
+
+    if (!aws_linked_list_empty(&entry->children)) {
+        struct aws_linked_list_node *first_child = aws_linked_list_front(&entry->children);
+        return AWS_CONTAINER_OF(first_child, struct aws_directory_entry, node);
+    }
+
+    aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    return NULL;
+}