6 files changed, 177 insertions, 3 deletions

diff --git a/c_implementation/src/ak_fs.c b/c_implementation/src/ak_fs.c
index 6594f2d..8ede3f6 100644
--- a/c_implementation/src/ak_fs.c
+++ b/c_implementation/src/ak_fs.c
@@ -278,3 +278,106 @@ int ak_fs_ls()
     ak_fs_maps_v3_print_bif(&maps_ptr, len);
     return 0;
 }
+
+int ak_fs_cat_file_from_root_hash(const sha512sum* rh)
+{
+    const char* chunks_dir = getenv("AK_CHUNKSDIR");
+    if ( chunks_dir == NULL )
+    {
+        ak_log_error(__func__, "No directory for chunks found");
+        return -2;
+    }
+    const char* leafs_dir = getenv("AK_LEAFSDIR");
+    if ( leafs_dir == NULL )
+    {
+        ak_log_error(__func__, "No directory for leafs found");
+        return -3;
+    }
+    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 )
+    {
+        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;
+    }
+    if ( !is_chunk )
+    {
+        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);
+    }
+    else
+    {
+        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);
+    }
+    free(fullpath);
+    return 0;
+}
+
+int ak_fs_cfm(akfs_map_v3* map)
+{
+    sha512sum x;
+    ak_fs_sha512sum_init(&x);
+    const sha512sum *rh_ptr = ak_fs_map_v3_get_root_hash(map);
+    if ( rh_ptr == NULL )
+    {
+        ak_log_debug(__func__, "No root hash found on the map");
+        return -1;
+    }
+    x = *rh_ptr;
+    return ak_fs_cat_file_from_root_hash(&x);
+}
diff --git a/c_implementation/src/ak_fs_main.c b/c_implementation/src/ak_fs_main.c
index f1660cf..e399544 100644
--- a/c_implementation/src/ak_fs_main.c
+++ b/c_implementation/src/ak_fs_main.c
@@ -6,7 +6,8 @@
 static int ak_fs_usage()
 {
     ak_log_debug(__func__, "Available commands:");
-    ak_log_debug(__func__, "ak fs --list");
+    ak_log_debug(__func__, "akfs --list");
+    ak_log_debug(__func__, "akfs --cfm <map hash>");
     return 1;
 }
 
@@ -14,14 +15,16 @@ 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, "hl", long_options, &logind);
+        option = getopt_long(argc, argv, "hlC:", long_options, &logind);
         if ( option == -1 ) return ak_fs_usage();
         switch(option)
         {
@@ -29,6 +32,11 @@ int ak_fs_main(int argc, char** argv)
                 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;
diff --git a/c_implementation/src/ak_fs_map_v3.c b/c_implementation/src/ak_fs_map_v3.c
index 6774f65..1d3e37e 100644
--- a/c_implementation/src/ak_fs_map_v3.c
+++ b/c_implementation/src/ak_fs_map_v3.c
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include <libakfs.h>
 #include <libaklog.h>
 #include <sys/stat.h>
@@ -179,12 +180,14 @@ int ak_fs_map_v3_open_from_file(akfs_map_v3 * map)
     {
         // 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);
@@ -195,9 +198,11 @@ int ak_fs_map_v3_open_from_file(akfs_map_v3 * map)
     {
         ak_log_debug(__func__,"conversion failed");
         fclose(fd);
+        free(full_path);
         return 1;
     }
     fclose(fd);
+    free(full_path);
     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/ak_fs_sha512sum.c b/c_implementation/src/ak_fs_sha512sum.c
index 6a2ebaa..619269f 100644
--- a/c_implementation/src/ak_fs_sha512sum.c
+++ b/c_implementation/src/ak_fs_sha512sum.c
@@ -40,7 +40,7 @@ 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;
diff --git a/c_implementation/src/ak_log.c b/c_implementation/src/ak_log.c
index e3af865..65e81d3 100644
--- a/c_implementation/src/ak_log.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_log_file);
         return EXIT_FAILURE;
     }
     fwrite(message, strlen(message),1,fp);
     fwrite("\n", strlen("\n"),1,fp);
     fclose(fp);
+    free(fullpath_to_log_file);
     return 0;
 }
 
@@ -169,6 +171,7 @@ void ak_log_message(const char* program, LogMessageType lmtype, char* message)
         asprintf(&some_string, "%ld <NULL> [ERROR] No arguments given\n", ts);
         ak_log_write_to_file(some_string);
         if ( AK_DEBUG ) ak_log_print_log_line(some_string);
+        free(some_string);
         return;
     }
     if ( message == NULL )
@@ -176,6 +179,7 @@ void ak_log_message(const char* program, LogMessageType lmtype, char* message)
         asprintf(&some_string, "%ld <%s> [ERROR] No message\n", ts, program);
         ak_log_write_to_file(some_string);
         if ( AK_DEBUG ) ak_log_print_log_line(some_string);
+        free(some_string);
         return;
     }
     switch(lmtype)
@@ -202,11 +206,13 @@ void ak_log_message(const char* program, LogMessageType lmtype, char* message)
             asprintf(&some_string, "%ld <%s> [ERROR] No message type\n", ts, program);
             ak_log_write_to_file(some_string);
             if ( AK_DEBUG ) ak_log_print_log_line(some_string);
+            free(some_string);
             return;
     }
     asprintf(&some_string, "%ld <%s> [%s] %s", ts, program, type, message);
     ak_log_write_to_file(some_string);
     if ( lmtype <= AK_DEBUG_LEVEL ) ak_log_print_log_line(some_string);
+    free(some_string);
 }
 
 void ak_log_exit(const char* program, char* message)