Merge pull request #12 from dreamer-coding/main

Memory extend patch

Author: dreamer-coding

code/logic/fossil/sys/memory.h

@@ -154,6 +154,79 @@ fossil_sys_memory_t fossil_sys_memory_resize(fossil_sys_memory_t ptr, size_t old
  */
 bool fossil_sys_memory_is_valid(const fossil_sys_memory_t ptr);
 
+/**
+ * @brief Fill memory with a repeating pattern.
+ *
+ * Useful for debugging or initializing buffers to known patterns.
+ *
+ * @param ptr A pointer to the memory to fill.
+ * @param pattern Pointer to the pattern to repeat.
+ * @param pattern_size Size of the pattern in bytes.
+ * @param total_size Total number of bytes to fill.
+ * @return A pointer to the memory.
+ */
+fossil_sys_memory_t fossil_sys_memory_fill(fossil_sys_memory_t ptr,
+                                           const void *pattern,
+                                           size_t pattern_size,
+                                           size_t total_size);
+
+/**
+ * @brief Securely zero memory.
+ *
+ * Unlike fossil_sys_memory_zero, this function prevents
+ * the compiler from optimizing out the zeroing operation.
+ *
+ * @param ptr A pointer to the memory to zero.
+ * @param size The size of the memory to zero.
+ */
+void fossil_sys_memory_secure_zero(fossil_sys_memory_t ptr, size_t size);
+
+/**
+ * @brief Swap contents of two memory regions.
+ *
+ * Swaps memory between two buffers of the same size.
+ *
+ * @param a Pointer to the first buffer.
+ * @param b Pointer to the second buffer.
+ * @param size Number of bytes to swap.
+ * @throws Error message and exits if pointers are NULL or sizes are zero.
+ */
+void fossil_sys_memory_swap(fossil_sys_memory_t a, fossil_sys_memory_t b, size_t size);
+
+/**
+ * @brief Search memory for a byte value.
+ *
+ * Scans memory for the first occurrence of the given byte.
+ *
+ * @param ptr Pointer to the memory to search.
+ * @param value Byte value to search for.
+ * @param size Size of the memory to search.
+ * @return Pointer to the first occurrence of the value, or NULL if not found.
+ */
+void *fossil_sys_memory_find(const fossil_sys_memory_t ptr, uint8_t value, size_t size);
+
+/**
+ * @brief Duplicate a NULL-terminated string using memory API.
+ *
+ * Similar to strdup, but uses fossil_sys_memory_alloc under the hood.
+ *
+ * @param str The string to duplicate.
+ * @return A pointer to the duplicated string.
+ * @throws Error message and exits if allocation fails or str is NULL.
+ */
+char *fossil_sys_memory_strdup(const char *str);
+
+/**
+ * @brief Get memory usage statistics.
+ *
+ * Returns current allocation count and optionally total allocated bytes.
+ * (Useful for leak detection in debug builds.)
+ *
+ * @param out_allocs Pointer to receive allocation count (can be NULL).
+ * @param out_bytes Pointer to receive total allocated bytes (can be NULL).
+ */
+void fossil_sys_memory_stats(size_t *out_allocs, size_t *out_bytes);
+
 #ifdef __cplusplus
 }
 
@@ -313,9 +386,76 @@ namespace fossil {
              * @param ptr A pointer to the memory.
              * @return true if the memory is valid, false otherwise.
              */
-            static bool isValid(const fossil_sys_memory_t ptr) {
+            static bool is_valid(const fossil_sys_memory_t ptr) {
                 return fossil_sys_memory_is_valid(ptr);
             }
+
+            /**
+             * Fill memory with a repeating pattern.
+             *
+             * @param ptr A pointer to the memory to fill.
+             * @param pattern Pointer to the pattern to repeat.
+             * @param pattern_size Size of the pattern in bytes.
+             * @param total_size Total number of bytes to fill.
+             * @return A pointer to the memory.
+             */
+            static fossil_sys_memory_t fill(fossil_sys_memory_t ptr, const void *pattern, size_t pattern_size, size_t total_size) {
+                return fossil_sys_memory_fill(ptr, pattern, pattern_size, total_size);
+            }
+
+            /**
+             * Securely zero memory.
+             *
+             * @param ptr A pointer to the memory to zero.
+             * @param size The size of the memory to zero.
+             */
+            static void secure_zero(fossil_sys_memory_t ptr, size_t size) {
+                fossil_sys_memory_secure_zero(ptr, size);
+            }
+
+            /**
+             * Swap contents of two memory regions.
+             *
+             * @param a Pointer to the first buffer.
+             * @param b Pointer to the second buffer.
+             * @param size Number of bytes to swap.
+             */
+            static void swap(fossil_sys_memory_t a, fossil_sys_memory_t b, size_t size) {
+                fossil_sys_memory_swap(a, b, size);
+            }
+
+            /**
+             * Search memory for a byte value.
+             *
+             * @param ptr Pointer to the memory to search.
+             * @param value Byte value to search for.
+             * @param size Size of the memory to search.
+             * @return Pointer to the first occurrence of the value, or NULL if not found.
+             */
+            static void *find(const fossil_sys_memory_t ptr, uint8_t value, size_t size) {
+                return fossil_sys_memory_find(ptr, value, size);
+            }
+
+            /**
+             * Duplicate a NULL-terminated string using memory API.
+             *
+             * @param str The string to duplicate.
+             * @return A pointer to the duplicated string.
+             */
+            static char *strdup(const char *str) {
+                return fossil_sys_memory_strdup(str);
+            }
+
+            /**
+             * Get memory usage statistics.
+             *
+             * @param out_allocs Pointer to receive allocation count (can be NULL).
+             * @param out_bytes Pointer to receive total allocated bytes (can be NULL).
+             */
+            static void stats(size_t *out_allocs, size_t *out_bytes) {
+                fossil_sys_memory_stats(out_allocs, out_bytes);
+            }
+
         };
 
     }

code/logic/memory.c

@@ -12,14 +12,20 @@
  * -----------------------------------------------------------------------------
  */
 #include "fossil/sys/memory.h"
-#include <stdlib.h>
+#include <stdlib.h> // Needed for posix_memalign
 #include <string.h>
 #include <stdio.h>
 
+// Internal counters for memory stats (optional, for debug)
+static size_t g_alloc_count = 0;
+static size_t g_alloc_bytes = 0;
+
+
+// ----------------------- Aligned Memory -----------------------
 
 fossil_sys_memory_t fossil_sys_memory_alloc(size_t size) {
     if (size == 0) {
-        fprintf(stderr, "Error: fossil_sys_memory_alloc() - Cannot allocate zero bytes.\n");
+         fprintf(stderr, "Error: fossil_sys_memory_alloc() - Cannot allocate zero bytes.\n");
         return NULL;
     }
 
@@ -185,3 +191,91 @@ bool fossil_sys_memory_is_valid(const fossil_sys_memory_t ptr) {
     // Optional: Add more validation logic if needed, but normally you'd rely on the caller to manage validity.
     return true;
 }
+
+// ----------------------- Memory Fill -----------------------
+
+fossil_sys_memory_t fossil_sys_memory_fill(fossil_sys_memory_t ptr,
+                                           const void *pattern,
+                                           size_t pattern_size,
+                                           size_t total_size) {
+    if (!ptr || !pattern || pattern_size == 0 || total_size == 0) {
+        fprintf(stderr, "Error: fossil_sys_memory_fill() - Invalid arguments.\n");
+        return NULL;
+    }
+
+    uint8_t *dst = (uint8_t *)ptr;
+    size_t offset = 0;
+    while (offset + pattern_size <= total_size) {
+        memcpy(dst + offset, pattern, pattern_size);
+        offset += pattern_size;
+    }
+    // Copy remaining bytes if any
+    if (offset < total_size) {
+        memcpy(dst + offset, pattern, total_size - offset);
+    }
+    return ptr;
+}
+
+// ----------------------- Secure Zero -----------------------
+
+void fossil_sys_memory_secure_zero(fossil_sys_memory_t ptr, size_t size) {
+    if (!ptr) return;
+#if defined(_MSC_VER)
+    SecureZeroMemory(ptr, size);
+#elif defined(__GNUC__) || defined(__clang__)
+    volatile uint8_t *p = (volatile uint8_t *)ptr;
+    while (size--) *p++ = 0;
+#else
+    memset(ptr, 0, size); // Fallback (not guaranteed secure)
+#endif
+}
+
+// ----------------------- Swap Memory -----------------------
+
+void fossil_sys_memory_swap(fossil_sys_memory_t a, fossil_sys_memory_t b, size_t size) {
+    if (!a || !b || size == 0) {
+        fprintf(stderr, "Error: fossil_sys_memory_swap() - Invalid arguments.\n");
+        return;
+    }
+
+    uint8_t *pa = (uint8_t *)a;
+    uint8_t *pb = (uint8_t *)b;
+    for (size_t i = 0; i < size; i++) {
+        uint8_t tmp = pa[i];
+        pa[i] = pb[i];
+        pb[i] = tmp;
+    }
+}
+
+// ----------------------- Find Memory -----------------------
+
+void *fossil_sys_memory_find(const fossil_sys_memory_t ptr, uint8_t value, size_t size) {
+    if (!ptr || size == 0) return NULL;
+
+    uint8_t *p = (uint8_t *)ptr;
+    for (size_t i = 0; i < size; i++) {
+        if (p[i] == value) return p + i;
+    }
+    return NULL;
+}
+
+// ----------------------- strdup -----------------------
+
+char *fossil_sys_memory_strdup(const char *str) {
+    if (!str) {
+        fprintf(stderr, "Error: fossil_sys_memory_strdup() - NULL pointer passed.\n");
+        return NULL;
+    }
+
+    size_t len = strlen(str) + 1;
+    char *copy = (char *)fossil_sys_memory_alloc(len);
+    memcpy(copy, str, len);
+    return copy;
+}
+
+// ----------------------- Memory Stats -----------------------
+
+void fossil_sys_memory_stats(size_t *out_allocs, size_t *out_bytes) {
+    if (out_allocs) *out_allocs = g_alloc_count;
+    if (out_bytes) *out_bytes = g_alloc_bytes;
+}

code/tests/cases/test_memory.c

@@ -168,6 +168,57 @@ FOSSIL_TEST(c_test_memory_init) {
     fossil_sys_memory_free(ptr); // Cleanup
 }
 
+FOSSIL_TEST(c_test_memory_fill_pattern) {
+    size_t size = 16;
+    uint8_t pattern[2] = {0xAB, 0xCD};
+    fossil_sys_memory_t ptr = fossil_sys_memory_alloc(size);
+    ASSUME_NOT_CNULL(ptr);
+
+    fossil_sys_memory_fill(ptr, pattern, sizeof(pattern), size);
+    for (size_t i = 0; i < size; i += 2) {
+        ASSUME_ITS_TRUE(((uint8_t*)ptr)[i] == 0xAB);
+        ASSUME_ITS_TRUE(((uint8_t*)ptr)[i+1] == 0xCD);
+    }
+    fossil_sys_memory_free(ptr);
+}
+
+FOSSIL_TEST(c_test_memory_secure_zero) {
+    size_t size = 8;
+    fossil_sys_memory_t ptr = fossil_sys_memory_alloc(size);
+    ASSUME_NOT_CNULL(ptr);
+    fossil_sys_memory_set(ptr, 0xFF, size);
+    fossil_sys_memory_secure_zero(ptr, size);
+    for (size_t i = 0; i < size; ++i) {
+        ASSUME_ITS_TRUE(((uint8_t*)ptr)[i] == 0);
+    }
+    fossil_sys_memory_free(ptr);
+}
+
+FOSSIL_TEST(c_test_memory_swap) {
+    size_t size = 4;
+    uint8_t a[4] = {1, 2, 3, 4};
+    uint8_t b[4] = {5, 6, 7, 8};
+    fossil_sys_memory_swap(a, b, size);
+    ASSUME_ITS_TRUE(a[0] == 5 && a[1] == 6 && a[2] == 7 && a[3] == 8);
+    ASSUME_ITS_TRUE(b[0] == 1 && b[1] == 2 && b[2] == 3 && b[3] == 4);
+}
+
+FOSSIL_TEST(c_test_memory_find) {
+    uint8_t buf[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    void *found = fossil_sys_memory_find(buf, 4, 8);
+    ASSUME_ITS_TRUE(found == &buf[4]);
+    found = fossil_sys_memory_find(buf, 9, 8);
+    ASSUME_ITS_TRUE(found == NULL);
+}
+
+FOSSIL_TEST(c_test_memory_strdup) {
+    const char *src = "fossil";
+    char *dup = fossil_sys_memory_strdup(src);
+    ASSUME_NOT_CNULL(dup);
+    ASSUME_ITS_TRUE(strcmp(src, dup) == 0);
+    fossil_sys_memory_free(dup);
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * *
 // * Fossil Logic Test Pool
 // * * * * * * * * * * * * * * * * * * * * * * * *
@@ -183,6 +234,11 @@ FOSSIL_TEST_GROUP(c_memory_tests) {
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_is_valid);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_calloc);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_init);
+    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_fill_pattern);
+    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_secure_zero);
+    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_swap);
+    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_find);
+    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_strdup);
 
     FOSSIL_TEST_REGISTER(c_memory_suite);
 }