5 files changed, 96 insertions, 136 deletions

diff --git a/c_implementation/src/ak_fs.c b/c_implementation/src/ak_fs.c
index 1d30744..6594f2d 100644
--- a/c_implementation/src/ak_fs.c
+++ b/c_implementation/src/ak_fs.c
@@ -12,7 +12,7 @@
 
 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);
@@ -43,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);
@@ -69,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;
         }
@@ -107,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
@@ -180,12 +184,10 @@ 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;
         }
         if ( str[i] == '\n' )
         {
-            // newlines_found++;
             na[++newlines_found] = i;
         }
     }
@@ -196,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;
@@ -213,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;
@@ -237,56 +239,26 @@ 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_map_v3_resolve_maps(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;
-        }
-        if( ak_fs_map_v3_open_from_file(ptr) != 2)
-        {
-            ++(ptr);
-            continue;
-        }
-        else
-        {
-            ++(ptr);
-            // return 1;
-        }
-    }
-    return 0;
-}
-
-// void ak_fs_print_available_maps(sha512sum **ma, size_t ma_len)
-// {
-//     sha512sum *ptr = NULL;
-//     for ( ptr = *ma; ptr < *ma+ma_len; ++ptr)
-//     {
-//         ak_log_debug(__func__, ak_fs_sha512sum_struct_read_as_string(ptr));
-//     }
-// }
-
 void ak_fs_init_string(char *str, size_t len)
 {
     for (size_t i = 0; i < len; ++i)
@@ -295,38 +267,14 @@ void ak_fs_init_string(char *str, size_t len)
     }
 }
 
-// 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)
-//     {
-//         ak_fs_print_map_avail(ptr);
-//     }
-// }
-
 int ak_fs_ls()
 {
     size_t len = ak_fs_maps_v3_found_in_fs();
-    printf("Found: %lu\n", len);
     akfs_map_v3 map_store[len];
     akfs_map_v3* maps_ptr = &map_store[0];
-    void* mps_start = &map_store[0];
-    (void)mps_start;
     ak_fs_maps_v3_init(&maps_ptr, len);
-    ak_fs_maps_v3_print(&maps_ptr, len);
-
-    // TODO Rename the following to "ak_fs_resolve_map_v3_array" or close to it
-    ak_fs_map_v3_resolve_maps(&maps_ptr, len);
-
-    // TODO Decide what we should be printing
-    // Possibly, something like "maphex(6)_filename" so we can put multiple
-    // files with the same name into the list
-    ak_fs_maps_v3_print(&maps_ptr, len);
-    ak_fs_maps_v3_print_filenames(&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;
 }
diff --git a/c_implementation/src/ak_fs_defuse.c b/c_implementation/src/ak_fs_defuse.c
index 10617cc..76514f6 100644
--- a/c_implementation/src/ak_fs_defuse.c
+++ b/c_implementation/src/ak_fs_defuse.c
@@ -50,7 +50,7 @@ static int akfs_fuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler
     void* mps_start = &map_store[0];
     (void)mps_start;
     ak_fs_maps_v3_init(&mps_ptr, ms_len);
-    ak_fs_map_v3_resolve_maps(&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)
     {
diff --git a/c_implementation/src/ak_fs_map_v3.c b/c_implementation/src/ak_fs_map_v3.c
index 1b26d89..6774f65 100644
--- a/c_implementation/src/ak_fs_map_v3.c
+++ b/c_implementation/src/ak_fs_map_v3.c
@@ -84,15 +84,27 @@ sha512sum* ak_fs_map_v3_get_map_hash(akfs_map_v3 *map)
     return &(map->mh);
 }
 
-char* ak_fs_map_v3_get_root_hash(akfs_map_v3 *map)
+sha512sum* ak_fs_map_v3_get_root_hash(akfs_map_v3 *map)
 {
     if (!ak_fs_sha512sum_is_null(&(map->rh)))
     {
-        return ak_fs_sha512sum_struct_read_as_string(&(map->rh));
+        return &(map->rh);
     }
     else
     {
-        return "";
+        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;
     }
 }
 
@@ -103,12 +115,12 @@ char* ak_fs_map_v3_get_filename(akfs_map_v3 *map)
 
 void ak_fs_map_v3_print_filename(akfs_map_v3 *map)
 {
-    printf(" .fn: %s\n", ak_fs_map_v3_get_filename(map));
+    printf("%s", ak_fs_map_v3_get_filename(map));
 }
 
 void ak_fs_map_v3_print(akfs_map_v3 *map)
 {
-    printf("map_v3 {\n");
+    printf("map_v3 {");
     printf("\n .mh: ");
     ak_fs_map_v3_print_map_hash(map);
     printf("\n .oh: ");
@@ -126,21 +138,29 @@ void ak_fs_map_v3_print_as_json(akfs_map_v3 *map)
     printf("\"map\":\"");
     ak_fs_map_v3_print_map_hash(map);
     printf("\",");
-    printf("{\"original\":\"");
+    printf("\"original\":\"");
     ak_fs_map_v3_print_original_hash(map);
     printf("\",");
-    printf("{\"root\":\"");
+    printf("\"root\":\"");
     ak_fs_map_v3_print_root_hash(map);
     printf("\",");
-    printf("{\"filename\":\"");
+    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)
 {
-    ak_log_debug(__func__, "Started");
     if (map==0x0)
     {
         ak_log_debug(__func__, "Zeropointer");
@@ -181,50 +201,6 @@ int ak_fs_map_v3_open_from_file(akfs_map_v3 * map)
     return 0;
 }
 
-int ak_fs_open_map_v3_file(char* maphash, akfs_map_v3 * map)
-{
-    ak_log_debug(__func__, "Started");
-    if (map==0x0)
-    {
-        ak_log_debug(__func__, "Zeropointer");
-        return 1;
-    }
-    if ( !ak_fs_verify_input_is_hash(maphash) )
-    {
-        ak_log_debug(__func__,"not a hash");
-        return 1;
-    }
-    FILE *fd;
-    char *full_path = {0};
-    asprintf(&full_path, "%s/%s", ak_fs_maps_v3_get_dir(), maphash);
-    printf("Trying path: %s\n", full_path);
-    fd = fopen(full_path, "rb");
-    if (!fd)
-    {
-        // perror("fopen");
-        ak_log_debug(__func__, "file not found");
-        return 1;
-    }
-    struct stat sb;
-    if (stat(full_path, &sb) == -1) {
-        perror("stat");
-        fclose(fd);
-        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);
-        return 1;
-    }
-    fclose(fd);
-    return 0;
-}
-
 int ak_fs_map_v3_to_file(akfs_map_v3 maphash)
 {
     (void)maphash;
diff --git a/c_implementation/src/ak_fs_maps_v3.c b/c_implementation/src/ak_fs_maps_v3.c
index 9b047b0..a5060b2 100644
--- a/c_implementation/src/ak_fs_maps_v3.c
+++ b/c_implementation/src/ak_fs_maps_v3.c
@@ -1,6 +1,8 @@
-#include <libakfs.h>
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
 #include <dirent.h>
+#include "libakfs.h"
 
 const char* ak_fs_maps_v3_get_dir()
 {
@@ -30,7 +32,11 @@ 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);
+        if ( ptr != NULL )
+        {
+            ak_fs_map_v3_print_filename(ptr);
+            printf("\n");
+        }
     }
 }
 
@@ -40,10 +46,28 @@ void ak_fs_maps_v3_print(akfs_map_v3 **map_store, size_t length)
     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()
 {
@@ -55,9 +79,20 @@ size_t ak_fs_maps_v3_found_in_fs()
         const struct dirent *dir;
         while ((dir = readdir(d)) != NULL )
         {
-            if (ak_fs_verify_input_is_hash(dir->d_name)) counter++;
+            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_sha512sum.c b/c_implementation/src/ak_fs_sha512sum.c
index 2e10544..6a2ebaa 100644
--- a/c_implementation/src/ak_fs_sha512sum.c
+++ b/c_implementation/src/ak_fs_sha512sum.c
@@ -2,6 +2,7 @@
 #include <libaklog.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <string.h>
 
 void ak_fs_sha512sum_init(sha512sum *hash)
 {
@@ -41,7 +42,7 @@ char* ak_fs_sha512sum_struct_read_as_string(const sha512sum *ptr)
 {
     char *str = malloc(129*sizeof(char));
     ak_fs_sha512sum_struct_to_string(ptr, str);
-    ak_log_debug(__func__, str);
+    // ak_log_debug(__func__, str);
     return str;
 }
 
@@ -54,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)
         {