16 files changed, 674 insertions, 365 deletions

diff --git a/c_implementation/src/ak_datetime.c b/c_implementation/src/ak_datetime.c
new file mode 100644
index 0000000..71dcb18
--- /dev/null
+++ b/c_implementation/src/ak_datetime.c
@@ -0,0 +1,70 @@
+#include <libakdatetime.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+// Returns Unix timestamp (seconds since epoch)
+long ak_datetime_unix() {
+	return time(NULL);
+}
+
+// Returns Unix timestamp with nanoseconds
+void ak_datetime_unix_nanosecs(char *buffer, size_t size) {
+	struct timespec ts;
+	clock_gettime(CLOCK_REALTIME, &ts);
+	snprintf(buffer, size, "%ld.%09ld", ts.tv_sec, ts.tv_nsec);
+}
+
+// Returns human-readable datetime in format YYYYMMDD_HHMMSS
+void ak_datetime_human(char *buffer, size_t size) {
+	time_t now = time(NULL);
+	const struct tm *tm = gmtime(&now);
+	strftime(buffer, size, "%Y%m%d_%H%M%S", tm);
+}
+
+// Returns human-readable date in format YYYYMMDD
+void ak_datetime_human_date_only(char *buffer, size_t size) {
+	time_t now = time(NULL);
+	const struct tm *tm = gmtime(&now);
+	strftime(buffer, size, "%Y%m%d", tm);
+}
+
+// Returns yesterday's date in format YYYYMMDD
+void ak_datetime_human_date_only_yesterday(char *buffer, size_t size) {
+	time_t now = time(NULL);
+	now -= 24 * 60 * 60; // Subtract one day
+	const struct tm *tm = gmtime(&now);
+	strftime(buffer, size, "%Y%m%d", tm);
+}
+
+// Checks if string contains only digits
+static bool is_digits_only(const char *str) {
+	while (*str) {
+		if (!isdigit(*str)) {
+			return false;
+		}
+		str++;
+	}
+	return true;
+}
+
+// Converts Unix timestamp to human-readable format YYYYMMDD_HHMMSS
+bool ak_datetime_unix_to_human(const char *timestamp_str, char *buffer, size_t size) {
+	// Check if input is valid (10-digit number)
+	if (timestamp_str == NULL || strlen(timestamp_str) != 10 || !is_digits_only(timestamp_str)) {
+		return false;
+	}
+
+	time_t timestamp = (time_t)atol(timestamp_str);
+	const struct tm *tm = gmtime(&timestamp);
+	if (tm == NULL) {
+		return false;
+	}
+
+	strftime(buffer, size, "%Y%m%d_%H%M%S", tm);
+	return true;
+}
+
diff --git a/c_implementation/src/akfs.c b/c_implementation/src/ak_fs.c
index f9abc34..8ede3f6 100644
--- a/c_implementation/src/akfs.c
+++ b/c_implementation/src/ak_fs.c
@@ -10,14 +10,9 @@
 #include <sys/stat.h>
 #include <dirent.h>
 
-const char* ak_fs_maps_v3_get_dir()
-{
-    return getenv("AK_MAPSDIR");
-}
-
 char* ak_fs_return_hash_path(const char* str)
 {
-    if ( ak_fs_verify_input_is_hash(str) )
+    if ( ak_fs_verify_input_is_hash(str, strlen(str)) )
     {
         unsigned int i = 0;
         char *result = malloc((128*2)+1);
@@ -48,7 +43,7 @@ char* ak_fs_return_hash_path(const char* str)
 
 char* ak_fs_return_hash_dir(const char* str)
 {
-    if ( ak_fs_verify_input_is_hash(str) )
+    if ( ak_fs_verify_input_is_hash(str, strlen(str)) )
     {
         unsigned int i = 0;
         char *result = malloc((128*2)+1);
@@ -74,19 +69,23 @@ char* ak_fs_return_hash_dir(const char* str)
     }
 }
 
-bool ak_fs_verify_input_is_hash(const char* str)
+bool ak_fs_verify_input_is_hash(const char* str, size_t len)
 {
     size_t i = 0;
+    if (len != 128)
+    {
+        return false;
+    }
     while ( str[i] != '\0' )
     {
         if (
                 i < 128 &&
                 !(
                     ( str[i] >= 0x30 ) &&
-                    (( str[i] <= 0x39) || ( str[i] >= 0x61 )) &&
+                    ( str[i] <= 0x39 || str[i] >= 0x61 ) &&
                     ( str[i] <= 0x66 )
-                )
-            )
+                 )
+           )
         {
             return false;
         }
@@ -112,7 +111,7 @@ int ak_fs_create_dir_for_hash(const char* str)
      * 2. We might need to "lock" onto some version of glibc and be aware of
      *    other systems that do not use that one.
      */
-    if ( ak_fs_verify_input_is_hash(str) )
+    if ( ak_fs_verify_input_is_hash(str, strlen(str)) )
     {
         char* dir_path = ak_fs_return_hash_dir(str);
         // We will need to separate the string so we can create the path one
@@ -185,13 +184,11 @@ int ak_fs_convert_map_v3_string_to_struct(const char *str, size_t ssize, akfs_ma
     {
         if ( str[i] == ' ' )
         {
-            spaces_found++;
-            sa[spaces_found] = i;
+            sa[++spaces_found] = i;
         }
         if ( str[i] == '\n' )
         {
-            newlines_found++;
-            na[newlines_found] = i;
+            na[++newlines_found] = i;
         }
     }
     int si = 0;
@@ -201,7 +198,7 @@ int ak_fs_convert_map_v3_string_to_struct(const char *str, size_t ssize, akfs_ma
         si++;
     }
     original_hash_str[si] = '\0';
-    if( !ak_fs_verify_input_is_hash(original_hash_str) )
+    if( !ak_fs_verify_input_is_hash(original_hash_str, strlen(original_hash_str)) )
     {
         ak_log_error(__func__, "original_hash_str not a hash");
         return 1;
@@ -218,7 +215,7 @@ int ak_fs_convert_map_v3_string_to_struct(const char *str, size_t ssize, akfs_ma
         si++;
     }
     root_hash_str[si] = '\0';
-    if( !ak_fs_verify_input_is_hash(root_hash_str) )
+    if( !ak_fs_verify_input_is_hash(root_hash_str, strlen(root_hash_str)) )
     {
         ak_log_error(__func__, "root_hash_str not a hash");
         return 1;
@@ -242,185 +239,145 @@ int ak_fs_convert_map_v3_string_to_struct(const char *str, size_t ssize, akfs_ma
     return 0;
 }
 
-void ak_fs_get_available_maps_from_fs(sha512sum **ma, size_t length)
+void ak_fs_maps_v3_get_from_fs(akfs_map_v3 **ma, size_t length)
 {
+    (void)length;
     DIR *d;
     d = opendir(ak_fs_maps_v3_get_dir());
-    sha512sum *ptr = NULL;
+    akfs_map_v3 *ptr = NULL;
+    ptr = *ma;
     if (d)
     {
-        for ( ptr = *ma; ptr < *ma+length; ++ptr)
+        const struct dirent *dir;
+        while((dir = readdir(d)) != NULL )
         {
-            const struct dirent *dir;
-            if ((dir = readdir(d)) == NULL ) break;
-            if (!ak_fs_verify_input_is_hash(dir->d_name)) continue;
-            ak_fs_sha512sum_string_to_struct(dir->d_name, ptr);
+            if (!ak_fs_verify_input_is_hash(dir->d_name, 128)) continue;
+            ak_fs_sha512sum_string_to_struct(dir->d_name, &(ptr->mh));
+            ++ptr;
         }
     }
     closedir(d);
 }
 
-int ak_fs_load_available_maps(sha512sum **ma, size_t ma_len, akfs_map_v3 **ms, size_t ms_len)
-{
-    sha512sum *ptr = NULL;
-    akfs_map_v3 *mptr = NULL;
-    mptr = *ms;
-    (void)ms_len;
-    for ( ptr = *ma; ptr < *ma+ma_len; ++ptr)
-    {
-        if ( ak_fs_sha512sum_is_null(ptr))
-        {
-            continue;
-        }
-        if( ak_fs_open_map_v3_file(ak_fs_sha512sum_struct_read_as_string(ptr), mptr) != 2)
-        {
-            ++(mptr);
-            continue;
-        }
-        else
-        {
-            ++(mptr);
-            // return 1;
-        }
-    }
-    return 0;
-}
-
-void ak_fs_print_loaded_maps(akfs_map_v3 **map_store, size_t length)
+void ak_fs_init_string(char *str, size_t len)
 {
-    akfs_map_v3 *ptr = NULL;
-    for ( ptr = *map_store; ptr < *map_store + length; ++ptr)
+    for (size_t i = 0; i < len; ++i)
     {
-        if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print(ptr);
+        str[i] = '\0';
     }
 }
 
-bool ak_fs_map_v3_compare(akfs_map_v3* a, akfs_map_v3* b)
-{
-    return (
-            (ak_fs_sha512sum_compare(&a->oh, &b->oh) == true) &&
-            (ak_fs_sha512sum_compare(&a->rh, &b->rh) == true) &&
-            (ak_fs_sha512sum_compare(&a->mh, &b->mh) == true) &&
-            (strcmp(a->filename, b->filename) == 0)
-           );
-}
-
-bool ak_fs_map_v3_is_null(akfs_map_v3* m)
+int ak_fs_ls()
 {
-    akfs_map_v3 n;
-    ak_fs_map_v3_init(&n);
-    return ak_fs_map_v3_compare(m, &n);
+    size_t len = ak_fs_maps_v3_found_in_fs();
+    akfs_map_v3 map_store[len];
+    akfs_map_v3* maps_ptr = &map_store[0];
+    ak_fs_maps_v3_init(&maps_ptr, len);
+    ak_fs_maps_v3_get_from_fs(&maps_ptr, len);
+    ak_fs_maps_v3_resolve(&maps_ptr, len);
+    ak_fs_maps_v3_print_bif(&maps_ptr, len);
+    return 0;
 }
 
-void ak_fs_print_available_maps(sha512sum **ma, size_t ma_len)
+int ak_fs_cat_file_from_root_hash(const sha512sum* rh)
 {
-    sha512sum *ptr = NULL;
-    for ( ptr = *ma; ptr < *ma+ma_len; ++ptr)
+    const char* chunks_dir = getenv("AK_CHUNKSDIR");
+    if ( chunks_dir == NULL )
     {
-        ak_log_debug(__func__, ak_fs_sha512sum_struct_read_as_string(ptr));
+        ak_log_error(__func__, "No directory for chunks found");
+        return -2;
     }
-
-}
-
-void ak_fs_init_string(char *str, size_t len)
-{
-    for (size_t i = 0; i < len; ++i)
+    const char* leafs_dir = getenv("AK_LEAFSDIR");
+    if ( leafs_dir == NULL )
     {
-        str[i] = '\0';
+        ak_log_error(__func__, "No directory for leafs found");
+        return -3;
     }
-}
-
-
-void ak_fs_print_map_avail(const sha512sum* m)
-{
-    printf(" .MA: %s\n", ak_fs_sha512sum_struct_read_as_string(m));
-}
-
-void ak_fs_print_map_all_avail(sha512sum** m, size_t s)
-{
-    sha512sum *ptr = NULL;
-    for (ptr = *m; ptr < *m+s; ++ptr)
+    FILE *fd;
+    char *fullpath;
+    bool is_chunk = false;
+    char root_hash_str[129] = {0};
+    ak_fs_sha512sum_struct_to_string(rh, root_hash_str);
+    if ( asprintf(&fullpath, "%s/%s", leafs_dir, root_hash_str) == -1 ) return -1;
+    fd = fopen(fullpath, "r");
+    if ( fd == NULL )
     {
-        ak_fs_print_map_avail(ptr);
+        free(fullpath);
+        if ( asprintf(&fullpath, "%s/%s", chunks_dir, ak_fs_sha512sum_struct_read_as_string(rh)) == -1 ) return -1;
+        fd = fopen(fullpath, "r");
+        if ( fd == NULL )
+        {
+            ak_log_error(__func__, "Could not be found");
+            free(fullpath);
+            return 1;
+        }
+        is_chunk = true;
     }
-}
-
-void ak_fs_print_filenames_from_map_store(akfs_map_v3** m, size_t s)
-{
-    akfs_map_v3 *ptr = NULL;
-    for (ptr = *m; ptr < *m+s; ++ptr)
+    if ( !is_chunk )
     {
-        if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print_filename(ptr);
+        char buffer[258] = {0};
+        size_t bytes_read = fread(&buffer, 1, sizeof(buffer), fd);
+        if ( bytes_read < sizeof(buffer) )
+        {
+            ak_log_error(__func__, "File is smaller than expected. Wrong format?");
+            fclose(fd);
+            free(fullpath);
+            return 2;
+        }
+        if ( buffer[128] != '\n' || buffer[257] != '\n' )
+        {
+            ak_log_error(__func__, "Unknown format");
+            fclose(fd);
+            free(fullpath);
+            return 2;
+        }
+        char h_str[129] = {0};
+        char t_str[129] = {0};
+        mt_branch h0;
+        ak_fs_sha512sum_init(&h0.root);
+        ak_fs_sha512sum_init(&h0.head);
+        ak_fs_sha512sum_init(&h0.tail);
+        h0.root = *rh;
+        memcpy(h_str, buffer, 128);
+        h_str[128] = '\0';
+        memcpy(t_str, buffer + 129, 128);
+        t_str[128] = '\0';
+        fclose(fd);
+        // free(fullpath);
+        ak_fs_sha512sum_string_to_struct(h_str, &h0.head);
+        ak_fs_sha512sum_string_to_struct(t_str, &h0.tail);
+        ak_fs_cat_file_from_root_hash(&h0.head);
+        if ( !ak_fs_sha512sum_compare(&h0.head, &h0.tail) ) ak_fs_cat_file_from_root_hash(&h0.tail);
     }
-}
-
-// char* ak_fs_fuse_list_filenames_from_map_store(akfs_map_v3** m, size_t s)
-// {
-//     akfs_map_v3 *ptr = NULL;
-//     for (ptr = *m; ptr < *m+s; ++ptr)
-//     {
-//         if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_get_filename(ptr);
-//     }
-// }
-
-void ak_fs_print_all_maps_from_map_store(akfs_map_v3** m, size_t s)
-{
-    akfs_map_v3 *ptr = NULL;
-    for (ptr = *m; ptr < *m+s; ++ptr)
+    else
     {
-        if (!ak_fs_map_v3_is_null(ptr)) ak_fs_map_v3_print(ptr);
+        struct stat sb;
+        if (stat(fullpath, &sb) == -1) {
+            perror("stat");
+            fclose(fd);
+            free(fullpath);
+            return 2;
+        }
+        char buffer[(long long) sb.st_size+1];
+        fread(&buffer, sizeof(buffer), 1, fd);
+        fclose(fd);
+        buffer[sizeof(buffer)-1] = '\0';
+        printf("%s", buffer);
     }
-}
-
-int ak_fs_ls()
-{
-    size_t ms_len = 100;
-    size_t ma_len = 100;
-    akfs_map_v3 map_store[ms_len];
-    akfs_map_v3* mps_ptr = &map_store[0];
-    void* mps_start = &map_store[0];
-    (void)mps_start;
-    sha512sum maps_avail[ma_len];
-    sha512sum *mav_ptr = &maps_avail[0];
-    void* mav_start = &map_store[0];
-    (void)mav_start;
-    ak_fs_map_v3_init_store(&mps_ptr, ms_len);
-    ak_fs_sha512sum_init_avail(&mav_ptr, ma_len);
-    ak_fs_print_all_maps_from_map_store(&mps_ptr, ms_len);
-    ak_fs_get_available_maps_from_fs(&mav_ptr, ma_len);
-    ak_fs_load_available_maps(&mav_ptr, ma_len, &mps_ptr, ms_len);
-    ak_fs_print_loaded_maps(&mps_ptr, ms_len);
-    ak_fs_print_filenames_from_map_store(&mps_ptr, ms_len);
+    free(fullpath);
     return 0;
 }
 
-int ak_fs_usage()
-{
-    ak_log_debug(__func__, "Available commands:");
-    ak_log_debug(__func__, "ak fs --list");
-    return 1;
-}
-
-int ak_fs_main(int c, char** v)
+int ak_fs_cfm(akfs_map_v3* map)
 {
-    (void)c;
-    (void)v;
-    int option;
-    while ( (option = getopt(c, v, ":h|:help")) != -1 )
+    sha512sum x;
+    ak_fs_sha512sum_init(&x);
+    const sha512sum *rh_ptr = ak_fs_map_v3_get_root_hash(map);
+    if ( rh_ptr == NULL )
     {
-        printf("%d\n", option);
-        switch(option)
-        {
-            case 'h':
-                return ak_fs_usage();
-            case ':':
-                printf("kek\n");
-                return 1;
-            case '?':
-                printf("lol\n");
-                return 2;
-        }
+        ak_log_debug(__func__, "No root hash found on the map");
+        return -1;
     }
-    return 0;
+    x = *rh_ptr;
+    return ak_fs_cat_file_from_root_hash(&x);
 }
-
diff --git a/c_implementation/src/akfs_defuse.c b/c_implementation/src/ak_fs_defuse.c
index da0c3d0..76514f6 100644
--- a/c_implementation/src/akfs_defuse.c
+++ b/c_implementation/src/ak_fs_defuse.c
@@ -37,36 +37,37 @@ static int akfs_fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler
 	if (strcmp(path, "/") != 0)  // Only support root dir
 		return -ENOENT;
 
-	filler(buf, ".", NULL, 0, 0);   // Current dir
-	filler(buf, "..", NULL, 0, 0);  // Parent dir
-	filler(buf, "hello", NULL, 0, 0);  // Our file
-    size_t ms_len = 100;
-    size_t ma_len = 100;
+	filler(buf, ".", NULL, 0, 0);
+	filler(buf, "..", NULL, 0, 0);
+
+    // example file
+	filler(buf, "hello", NULL, 0, 0);
+
+    // ak fs integration
+    size_t ms_len = ak_fs_maps_v3_found_in_fs();
     akfs_map_v3 map_store[ms_len];
     akfs_map_v3* mps_ptr = &map_store[0];
     void* mps_start = &map_store[0];
     (void)mps_start;
-    sha512sum maps_avail[ma_len];
-    sha512sum *mav_ptr = &maps_avail[0];
-    void* mav_start = &map_store[0];
-    (void)mav_start;
-    ak_fs_map_v3_init_store(&mps_ptr, ms_len);
-    ak_fs_sha512sum_init_avail(&mav_ptr, ma_len);
-    ak_fs_get_available_maps_from_fs(&mav_ptr, ma_len);
-    ak_fs_load_available_maps(&mav_ptr, ma_len, &mps_ptr, ms_len);
+    ak_fs_maps_v3_init(&mps_ptr, ms_len);
+    ak_fs_maps_v3_resolve(&mps_ptr, ms_len);
     akfs_map_v3 *ptr = NULL;
     for (ptr = mps_ptr; ptr < mps_ptr + ms_len; ++ptr)
     {
-        if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print_filename(ptr);
-        filler(buf, ak_fs_map_v3_get_filename(ptr), NULL, 0, 0);
+        if ( ak_fs_map_v3_is_null(ptr) )
+        {
+            ak_fs_map_v3_print_filename(ptr);
+            filler(buf, ak_fs_map_v3_get_filename(ptr), NULL, 0, 0);
+        }
     }
-	return 0;
+
+    return 0;
 }
 
 // Called to get file attributes (metadata)
 static int akfs_fuse_getattr(const char *path, struct stat *st, struct fuse_file_info *fi)
 {
-	(void) fi;  // Unused
+	(void) fi;
 	st->st_uid = getuid();
 	st->st_gid = getgid();
 	st->st_atime = st->st_mtime = time(NULL);
diff --git a/c_implementation/src/ak_fs_main.c b/c_implementation/src/ak_fs_main.c
new file mode 100644
index 0000000..e399544
--- /dev/null
+++ b/c_implementation/src/ak_fs_main.c
@@ -0,0 +1,51 @@
+#include <getopt.h>
+#include <stdio.h>
+#include <libaklog.h>
+#include <libakfs.h>
+
+static int ak_fs_usage()
+{
+    ak_log_debug(__func__, "Available commands:");
+    ak_log_debug(__func__, "akfs --list");
+    ak_log_debug(__func__, "akfs --cfm <map hash>");
+    return 1;
+}
+
+int ak_fs_main(int argc, char** argv)
+{
+    int option;
+    int logind = 0;
+    akfs_map_v3 map;
+    static struct option long_options[] = {
+        {"help", no_argument, 0, 'h'},
+        {"list", no_argument, 0, 'l'},
+        {"cfm", required_argument, 0, 'C'},
+        {0,0,0,0}
+    };
+    while(1)
+    {
+        option = getopt_long(argc, argv, "hlC:", long_options, &logind);
+        if ( option == -1 ) return ak_fs_usage();
+        switch(option)
+        {
+            case 'h':
+                return ak_fs_usage();
+            case 'l':
+                return ak_fs_ls();
+            case 'C':
+                ak_fs_map_v3_init(&map);
+                if ( ak_fs_sha512sum_string_to_struct(optarg, &map.mh) != 0 ) return -1;
+                if ( ak_fs_map_v3_open_from_file(&map) != 0 ) return -2;
+                return ak_fs_cfm(&map);
+            default:
+                printf("double lol\n");
+                return 4;
+        }
+    }
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    return ak_fs_main(argc, argv);
+}
diff --git a/c_implementation/src/ak_fs_map_v3.c b/c_implementation/src/ak_fs_map_v3.c
new file mode 100644
index 0000000..1d3e37e
--- /dev/null
+++ b/c_implementation/src/ak_fs_map_v3.c
@@ -0,0 +1,213 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <libakfs.h>
+#include <libaklog.h>
+#include <sys/stat.h>
+
+// const char maps_dir[] = "/home/kaotisk/.arching-kaos/akfs/maps/";
+
+void ak_fs_map_v3_init(akfs_map_v3 *map)
+{
+    ak_fs_sha512sum_init(&map->oh);
+    ak_fs_sha512sum_init(&map->rh);
+    ak_fs_sha512sum_init(&map->mh);
+    ak_fs_init_string(map->filename, 256);
+}
+
+bool ak_fs_map_v3_compare(akfs_map_v3* a, akfs_map_v3* b)
+{
+    return (
+            (ak_fs_sha512sum_compare(&a->oh, &b->oh) == true) &&
+            (ak_fs_sha512sum_compare(&a->rh, &b->rh) == true) &&
+            (ak_fs_sha512sum_compare(&a->mh, &b->mh) == true) &&
+            (strcmp(a->filename, b->filename) == 0)
+           );
+}
+
+
+bool ak_fs_map_v3_is_null(akfs_map_v3* m)
+{
+    akfs_map_v3 n;
+    ak_fs_map_v3_init(&n);
+    if ( ak_fs_map_v3_compare(m, &n) )
+    {
+        ak_log_debug(__func__, "true");
+    }
+    else
+    {
+        ak_log_debug(__func__, "false");
+    }
+    return ak_fs_map_v3_compare(m, &n);
+}
+
+void ak_fs_map_v3_print_map_hash(akfs_map_v3 *map)
+{
+    if( !ak_fs_sha512sum_is_null(&(map->mh)) )
+    {
+        char str[129] = {0};
+        char* s = &str[0];
+        ak_fs_sha512sum_struct_to_string(&(map->mh), s);
+        printf("%s", s);
+    }
+    else
+    {
+        ak_log_debug(__func__,"hash is null");
+    }
+}
+
+void ak_fs_map_v3_print_original_hash(akfs_map_v3 *map)
+{
+    if (!ak_fs_sha512sum_is_null(&(map->oh)))
+    {
+        printf("%s", ak_fs_sha512sum_struct_read_as_string(&(map->oh)));
+    }
+    else
+    {
+        ak_log_debug(__func__,"hash is null");
+    }
+}
+
+void ak_fs_map_v3_print_root_hash(akfs_map_v3 *map)
+{
+    if (!ak_fs_sha512sum_is_null(&(map->rh)))
+    {
+        printf("%s", ak_fs_sha512sum_struct_read_as_string(&(map->rh)));
+    }
+    else
+    {
+        ak_log_debug(__func__,"hash is null");
+    }
+}
+
+sha512sum* ak_fs_map_v3_get_map_hash(akfs_map_v3 *map)
+{
+    return &(map->mh);
+}
+
+sha512sum* ak_fs_map_v3_get_root_hash(akfs_map_v3 *map)
+{
+    if (!ak_fs_sha512sum_is_null(&(map->rh)))
+    {
+        return &(map->rh);
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+sha512sum* ak_fs_map_v3_get_orig_hash(akfs_map_v3 *map)
+{
+    if (!ak_fs_sha512sum_is_null(&(map->oh)))
+    {
+        return &(map->oh);
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+char* ak_fs_map_v3_get_filename(akfs_map_v3 *map)
+{
+    return map->filename;
+}
+
+void ak_fs_map_v3_print_filename(akfs_map_v3 *map)
+{
+    printf("%s", ak_fs_map_v3_get_filename(map));
+}
+
+void ak_fs_map_v3_print(akfs_map_v3 *map)
+{
+    printf("map_v3 {");
+    printf("\n .mh: ");
+    ak_fs_map_v3_print_map_hash(map);
+    printf("\n .oh: ");
+    ak_fs_map_v3_print_original_hash(map);
+    printf("\n .rh: ");
+    ak_fs_map_v3_print_root_hash(map);
+    printf("\n .fn: ");
+    ak_fs_map_v3_print_filename(map);
+    printf("\n}\n");
+}
+
+void ak_fs_map_v3_print_as_json(akfs_map_v3 *map)
+{
+    printf("{\"type\":\"map_v3\",");
+    printf("\"map\":\"");
+    ak_fs_map_v3_print_map_hash(map);
+    printf("\",");
+    printf("\"original\":\"");
+    ak_fs_map_v3_print_original_hash(map);
+    printf("\",");
+    printf("\"root\":\"");
+    ak_fs_map_v3_print_root_hash(map);
+    printf("\",");
+    printf("\"filename\":\"");
+    ak_fs_map_v3_print_filename(map);
+    printf("\"");
+    printf("}\n");
+}
+
+void ak_fs_map_v3_print_bif(akfs_map_v3 *map)
+{
+    ak_fs_map_v3_print_map_hash(map);
+    printf(" ");
+    ak_fs_map_v3_print_root_hash(map);
+    printf(" ");
+    ak_fs_map_v3_print_filename(map);
+}
+
+int ak_fs_map_v3_open_from_file(akfs_map_v3 * map)
+{
+    if (map==0x0)
+    {
+        ak_log_debug(__func__, "Zeropointer");
+        return 1;
+    }
+    FILE *fd;
+    char *full_path = {0};
+    asprintf(&full_path,
+            "%s/%s",
+            ak_fs_maps_v3_get_dir(),
+            ak_fs_sha512sum_struct_read_as_string(ak_fs_map_v3_get_map_hash(map))
+            );
+    // printf("Trying path: %s\n", full_path);
+    fd = fopen(full_path, "rb");
+    if (!fd)
+    {
+        // perror("fopen");
+        ak_log_debug(__func__, "File not found or other error");
+        free(full_path);
+        return 1;
+    }
+    struct stat sb;
+    if (stat(full_path, &sb) == -1) {
+        perror("stat");
+        fclose(fd);
+        free(full_path);
+        return 2;
+    }
+    // File size: %lld in bytes: (long long) sb.st_size);
+    char buffer[(long long) sb.st_size+1];
+    fread(&buffer, sizeof(buffer), (long long) sb.st_size, fd);
+    // ak_fs_sha512sum_string_to_struct(maphash, &(map->mh));
+    if ( ak_fs_convert_map_v3_string_to_struct(buffer, strlen(buffer), map) != 0 )
+    {
+        ak_log_debug(__func__,"conversion failed");
+        fclose(fd);
+        free(full_path);
+        return 1;
+    }
+    fclose(fd);
+    free(full_path);
+    return 0;
+}
+
+int ak_fs_map_v3_to_file(akfs_map_v3 maphash)
+{
+    (void)maphash;
+    return 0;
+}
diff --git a/c_implementation/src/akfs_map_v4.c b/c_implementation/src/ak_fs_map_v4.c
index 3fea244..3fea244 100644
--- a/c_implementation/src/akfs_map_v4.c
+++ b/c_implementation/src/ak_fs_map_v4.c
diff --git a/c_implementation/src/ak_fs_maps_v3.c b/c_implementation/src/ak_fs_maps_v3.c
new file mode 100644
index 0000000..a5060b2
--- /dev/null
+++ b/c_implementation/src/ak_fs_maps_v3.c
@@ -0,0 +1,98 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <dirent.h>
+#include "libakfs.h"
+
+const char* ak_fs_maps_v3_get_dir()
+{
+    return getenv("AK_MAPSDIR");
+}
+
+void ak_fs_maps_v3_init(akfs_map_v3** ms, size_t l)
+{
+    akfs_map_v3 *m = NULL;
+    for (m = *ms; m < *ms+l; ++m)
+    {
+        ak_fs_map_v3_init(m);
+    }
+}
+
+void ak_fs_maps_v3_print_map_hashes(akfs_map_v3** m, size_t s)
+{
+    akfs_map_v3 *ptr = NULL;
+    for (ptr = *m; ptr < *m+s; ++ptr)
+    {
+        if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print_map_hash(ptr);
+    }
+}
+
+void ak_fs_maps_v3_print_filenames(akfs_map_v3** m, size_t s)
+{
+    akfs_map_v3 *ptr = NULL;
+    for (ptr = *m; ptr < *m+s; ++ptr)
+    {
+        if ( ptr != NULL )
+        {
+            ak_fs_map_v3_print_filename(ptr);
+            printf("\n");
+        }
+    }
+}
+
+void ak_fs_maps_v3_print(akfs_map_v3 **map_store, size_t length)
+{
+    akfs_map_v3 *ptr = NULL;
+    for ( ptr = *map_store; ptr < *map_store + length; ++ptr)
+    {
+        ak_fs_map_v3_print(ptr);
+        printf("\n");
+    }
+}
+
+void ak_fs_maps_v3_print_as_json(akfs_map_v3 **map_store, size_t length)
+{
+    akfs_map_v3 *ptr = NULL;
+    for ( ptr = *map_store; ptr < *map_store + length; ++ptr)
+    {
+        ak_fs_map_v3_print_as_json(ptr);
+    }
+}
+
+void ak_fs_maps_v3_print_bif(akfs_map_v3 **map_store, size_t length)
+{
+    akfs_map_v3 *ptr = NULL;
+    for ( ptr = *map_store; ptr < *map_store + length; ++ptr)
+    {
+        ak_fs_map_v3_print_bif(ptr);
+        printf("\n");
+    }
+}
+
+size_t ak_fs_maps_v3_found_in_fs()
+{
+    DIR *d;
+    size_t counter = 0;
+    d = opendir(ak_fs_maps_v3_get_dir());
+    if (d)
+    {
+        const struct dirent *dir;
+        while ((dir = readdir(d)) != NULL )
+        {
+            if (ak_fs_verify_input_is_hash(dir->d_name, strlen(dir->d_name))) counter++;
+        }
+    }
+    closedir(d);
+    return counter;
+}
+
+int ak_fs_maps_v3_resolve(akfs_map_v3 **ms, size_t ms_len)
+{
+    akfs_map_v3 *ptr = NULL;
+    for ( ptr = *ms; ptr < *ms+ms_len; ++ptr)
+    {
+        if ( ak_fs_sha512sum_is_null(&(ptr->mh)) ) continue;
+        ak_fs_map_v3_open_from_file(ptr);
+    }
+    return 0;
+}
diff --git a/c_implementation/src/ak_fs_mt.c b/c_implementation/src/ak_fs_mt.c
new file mode 100644
index 0000000..2c3414b
--- /dev/null
+++ b/c_implementation/src/ak_fs_mt.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <libakfs.h>
+#include <libaklog.h>
+#include <stdbool.h>
+
+bool ak_fs_mt_branch_is_null(mt_branch* n)
+{
+    if ( n == NULL )
+    {
+        ak_log_warning(__func__, "A NULL mt_branch* node was given");
+        return false;
+    }
+    if (
+            ak_fs_sha512sum_is_null(&n->root) &&
+            ak_fs_sha512sum_is_null(&n->head) &&
+            ak_fs_sha512sum_is_null(&n->tail)
+       )
+    {
+        return true;
+    }
+    return false;
+}
+
+bool ak_fs_mt_branch_compare(mt_branch *a, mt_branch *b)
+{
+    if ( a == NULL || b == NULL )
+    {
+        ak_log_warning(__func__, "One or two NULL mt_branch* node was given");
+        return false;
+    }
+    if (
+            ak_fs_sha512sum_compare(&a->root, &b->root) &&
+            ak_fs_sha512sum_compare(&a->head, &b->head) &&
+            ak_fs_sha512sum_compare(&a->tail, &b->tail)
+       )
+    {
+        return true;
+    }
+    return false;
+}
+
+void ak_fs_mt_branch_print(mt_branch *n)
+{
+    if ( n == NULL )
+    {
+        ak_log_warning(__func__, "NULL mt_branch* was given");
+        return;
+    }
+    printf("r: %s\n", ak_fs_sha512sum_struct_read_as_string(&n->root));
+    printf("h: %s\n", ak_fs_sha512sum_struct_read_as_string(&n->head));
+    printf("t: %s\n", ak_fs_sha512sum_struct_read_as_string(&n->tail));
+}
diff --git a/c_implementation/src/akfs_sha512sum.c b/c_implementation/src/ak_fs_sha512sum.c
index 6db6397..619269f 100644
--- a/c_implementation/src/akfs_sha512sum.c
+++ b/c_implementation/src/ak_fs_sha512sum.c
@@ -1,6 +1,8 @@
 #include <libakfs.h>
+#include <libaklog.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <string.h>
 
 void ak_fs_sha512sum_init(sha512sum *hash)
 {
@@ -38,8 +40,9 @@ void ak_fs_sha512sum_init_avail(sha512sum** m, size_t s)
 
 char* ak_fs_sha512sum_struct_read_as_string(const sha512sum *ptr)
 {
-    char *str = malloc(129*sizeof(char));
+    static char str[129] = {0}; // = malloc(129*sizeof(char));
     ak_fs_sha512sum_struct_to_string(ptr, str);
+    // ak_log_debug(__func__, str);
     return str;
 }
 
@@ -52,7 +55,7 @@ bool ak_fs_sha512sum_is_null(const sha512sum *h)
 
 int ak_fs_sha512sum_string_to_struct(const char* str, sha512sum* hash)
 {
-    if ( ak_fs_verify_input_is_hash(str) )
+    if ( ak_fs_verify_input_is_hash(str, strlen(str)) )
     {
         for (size_t l = 0; l < 8; ++l)
         {
diff --git a/c_implementation/src/aklog.c b/c_implementation/src/ak_log.c
index 260621c..65e81d3 100644
--- a/c_implementation/src/aklog.c
+++ b/c_implementation/src/ak_log.c
@@ -22,11 +22,13 @@ int ak_log_write_to_file(const char* message)
     if (!fp)
     {
         perror("fopen");
+        free(fullpath_to_l