diff options
Diffstat (limited to 'c_implementation')
21 files changed, 698 insertions, 380 deletions
diff --git a/c_implementation/Makefile.am b/c_implementation/Makefile.am index 57fd80a..9b6cd65 100644 --- a/c_implementation/Makefile.am +++ b/c_implementation/Makefile.am @@ -3,45 +3,57 @@ AM_CPPFLAGS = -Wall -Werror -Wextra -Wpedantic -ggdb -I$(top_srcdir)/include #AM_CFLAGS = -Wall -Werror -Wextra -Wpedantic -ggdb -I$(top_srcdir)/include lib_LTLIBRARIES = libaklog.la libaksettings.la libakfs.la libakdatetime.la libakutils.la -libaklog_la_SOURCES = $(top_srcdir)/src/aklog.c -libaksettings_la_SOURCES = $(top_srcdir)/src/aksettings.c +libaklog_la_SOURCES = $(top_srcdir)/src/ak_log.c $(top_srcdir)/src/ak_log_main.c -libakfs_LDADD = libaksettings.la -libakfs_la_SOURCES = $(top_srcdir)/src/akfs.c $(top_srcdir)/src/aksettings.c $(top_srcdir)/src/akfs_sha512sum.c $(top_srcdir)/src/akfs_map_v3.c $(top_srcdir)/src/akfs_map_v4.c $(top_srcdir)/src/akfs_main.c +libaksettings_la_SOURCES = $(top_srcdir)/src/ak_settings.c -libakutils_la_SOURCES = $(top_srcdir)/src/akutils.c +libakfs_LDADD = libaksettings.la libaklog.la +libakfs_la_SOURCES = $(top_srcdir)/src/ak_fs.c \ + $(top_srcdir)/src/ak_fs_main.c \ + $(top_srcdir)/src/ak_fs_maps_v3.c \ + $(top_srcdir)/src/ak_fs_map_v3.c \ + $(top_srcdir)/src/ak_fs_map_v4.c \ + $(top_srcdir)/src/ak_fs_sha512sum.c -libakdatetime_la_SOURCES = $(top_srcdir)/src/akdatetime.c +libakutils_la_SOURCES = $(top_srcdir)/src/ak_utils.c -include_HEADERS = include/libaklog.h include/libaksettings.h include/libakfs.h +libakdatetime_la_SOURCES = $(top_srcdir)/src/ak_datetime.c -bin_PROGRAMS = akt akdefuse aklog akfs +#include_HEADERS = "$(wildcard include/*.h)" +include_HEADERS = $(top_srcdir)/include/libaklog.h \ + $(top_srcdir)/include/libaksettings.h \ + $(top_srcdir)/include/libakfs.h \ + $(top_srcdir)/include/libak.h + +bin_PROGRAMS = akfs akdefuse #akt akdefuse aklog akfs_LDADD = libaklog.la libakfs.la libaksettings.la -akfs_SOURCES = src/akfs_main.c -akt_SOURCES = src/ak.c +akfs_SOURCES = src/ak_fs_main.c + akt_LDADD = libaklog.la libakfs.la libaksettings.la akt_SOURCES = src/ak.c + akdefuse_CFLAGS = -I/usr/include/fuse3 -lfuse3 -lpthread akdefuse_LDADD = libaklog.la libakfs.la -akdefuse_SOURCES = src/akfs_defuse.c +akdefuse_SOURCES = src/ak_fs_defuse.c + aklog_LDADD = libaklog.la -aklog_SOURCES = src/aklog_main.c +aklog_SOURCES = src/ak_log_main.c check_PROGRAMS = test_aklog test_aksettings test_akfs test_akutils test_akdatetime -test_akdatetime_SOURCES = ./tests/test_akdatetime.c ./src/akdatetime.c +test_akdatetime_SOURCES = ./tests/test_akdatetime.c ./src/ak_datetime.c test_akdatetime_LDADD = libakdatetime.la -test_akutils_SOURCES = ./tests/test_akutils.c ./src/akutils.c +test_akutils_SOURCES = ./tests/test_akutils.c ./src/ak_utils.c test_akutils_LDADD = libakutils.la -test_aklog_SOURCES = ./tests/test_aklog.c ./src/aklog.c +test_aklog_SOURCES = ./tests/test_aklog.c ./src/ak_log.c test_aklog_LDADD = libaklog.la -test_akfs_SOURCES = ./tests/test_akfs.c ./src/akfs.c +test_akfs_SOURCES = ./tests/test_akfs.c ./src/ak_fs.c test_akfs_LDADD = libakfs.la libaklog.la -test_aksettings_SOURCES = ./tests/test_aksettings.c ./src/aksettings.c ./src/aklog.c +test_aksettings_SOURCES = ./tests/test_aksettings.c ./src/ak_settings.c ./src/ak_log.c test_aksettings_LDADD = libaksettings.la tests_test_main_CPPFLAGS = -I$(top_srcdir)/include diff --git a/c_implementation/include/libakdatetime.h b/c_implementation/include/libakdatetime.h new file mode 100644 index 0000000..435c3d8 --- /dev/null +++ b/c_implementation/include/libakdatetime.h @@ -0,0 +1,14 @@ +#include <stdbool.h> +#include <stddef.h> +#ifndef AK_DATETIME_H +#define AK_DATETIME_H + +long ak_datetime_unix(); +void ak_datetime_unix_nanosecs(char *buffer, size_t size); +void ak_datetime_human(char *buffer, size_t size); +void ak_datetime_human_date_only(char *buffer, size_t size); +void ak_datetime_human_date_only_yesterday(char *buffer, size_t size); +//static bool is_digits_only(const char *str); +bool ak_datetime_unix_to_human(const char *timestamp_str, char *buffer, size_t size); + +#endif // AK_DATETIME_H diff --git a/c_implementation/include/libakfs.h b/c_implementation/include/libakfs.h index d8d8c85..80fea58 100644 --- a/c_implementation/include/libakfs.h +++ b/c_implementation/include/libakfs.h @@ -131,7 +131,7 @@ char* ak_fs_return_hash_dir(const char*); * param char* string to be checked * returns boolean */ -bool ak_fs_verify_input_is_hash(const char*); +bool ak_fs_verify_input_is_hash(const char*, size_t); /** * Unused @@ -161,7 +161,12 @@ void ak_fs_sha512sum_struct_to_string(const sha512sum*, char*); /** * Opens a map file to an akfs_map_v3 struct */ -int ak_fs_open_map_v3_file(char*, akfs_map_v3*); +int ak_fs_map_v3_open_from_file(akfs_map_v3*); + +/** + * Prints filenames from a map_store + */ +void ak_fs_print_filenames_from_map_store(akfs_map_v3**, size_t); /** * Unused @@ -196,12 +201,19 @@ void ak_fs_map_v3_print_filename(akfs_map_v3*); /** * Unused */ +void ak_fs_maps_v3_print_filenames(akfs_map_v3**, size_t); + +void ak_fs_map_v3_print_as_json(akfs_map_v3*); + +/** + * Unused + */ void ak_fs_map_v3_print(akfs_map_v3*); /** * Takes an array of sha512sums (maps) and puts it in an array of maps (v3) */ -int ak_fs_load_available_maps(sha512sum**, size_t, akfs_map_v3**, size_t); +int ak_fs_map_v3_resolve_maps(akfs_map_v3**, size_t); /** * Unused @@ -211,7 +223,7 @@ void ak_fs_print_available_maps(sha512sum**, size_t); /** * Unused */ -void ak_fs_print_loaded_maps(akfs_map_v3**, size_t); +void ak_fs_maps_v3_print(akfs_map_v3**, size_t); /** * Reads maps_dir and outputs it in an array of sha512sum @@ -263,7 +275,7 @@ void ak_fs_map_v3_init(akfs_map_v3*); /** * Initializes an array of akfs_map_v3 */ -void ak_fs_map_v3_init_store(akfs_map_v3**, size_t); +void ak_fs_maps_v3_init(akfs_map_v3**, size_t); /** * returns: boolean @@ -283,7 +295,9 @@ sha512sum* ak_fs_map_v3_get_map_hash(akfs_map_v3*); */ sha512sum* ak_fs_map_v3_get_root_hash(akfs_map_v3*); /** - * Unused + * Gets original hash out of the akfs_map_v3 + * param: akfs_map_v3 + * return: pointer to sha512sum */ sha512sum* ak_fs_map_v3_get_orig_hash(akfs_map_v3*); /** @@ -334,6 +348,11 @@ sha512sum* ak_fs_map_v4_get_root_hash(akfs_map_v4*); sha512sum* ak_fs_map_v4_get_orig_hash(akfs_map_v4*); /** + * Returns number of files found in maps fs location + */ +size_t ak_fs_maps_v3_found_in_fs(); + +/** * Unused */ int ak_fs_ls(); diff --git a/c_implementation/include/libaksettings.h b/c_implementation/include/libaksettings.h index 0f53218..505e502 100644 --- a/c_implementation/include/libaksettings.h +++ b/c_implementation/include/libaksettings.h @@ -8,15 +8,14 @@ typedef struct { char *value; } AKSetting; -int ak_settings(); void ak_settings_print_setting(AKSetting); int ak_settings_from_file(); int ak_setting_to_file(AKSetting); AKSetting* ak_settings_get_all(); -char *ak_settings_get_setting(const char *key); -bool ak_settings_set_setting(const char *key, const char *value); +char *ak_settings_get_setting(const char*); +bool ak_settings_set_setting(const char*, const char*); bool ak_settings_save_settings(); bool ak_settings_load_settings_binary(); int ak_settings_find_setting(const char *key); 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(×tamp); + 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..c037fd8 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,20 +69,27 @@ 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; + printf("%s: this %lu is %lu: %s\n", __func__, i, len, str); + if (len != 128) + { + ak_log_debug(__func__, "Hash string length not right"); + 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 ) - ) - ) + ) + ) { + ak_log_debug(__func__, "Char out of range"); return false; } else { @@ -96,8 +98,10 @@ bool ak_fs_verify_input_is_hash(const char* str) } if ( i > 128 ) { + ak_log_debug(__func__, "String exceeds limit"); return false; } + ak_log_debug(__func__, "String okay"); return true; } @@ -112,7 +116,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 +189,13 @@ 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; + // spaces_found++; + sa[++spaces_found] = i; } if ( str[i] == '\n' ) { - newlines_found++; - na[newlines_found] = i; + // newlines_found++; + na[++newlines_found] = i; } } int si = 0; @@ -201,7 +205,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 +222,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,85 +246,70 @@ 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; + ak_log_debug(__func__, "gonna if"); if (d) { - for ( ptr = *ma; ptr < *ma+length; ++ptr) + ak_log_debug(__func__, "in if"); + 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); + ak_log_debug(__func__, "in while"); + // if ( ptr >= *ma+length ) break; + printf("iMH: %s\n", dir->d_name); + if (!ak_fs_verify_input_is_hash(dir->d_name, 128)) continue; + ak_fs_sha512sum_string_to_struct(dir->d_name, &(ptr->mh)); + ++ptr; } + ak_log_debug(__func__, "out while"); } + ak_log_debug(__func__, "out if"); closedir(d); } -int ak_fs_load_available_maps(sha512sum **ma, size_t ma_len, akfs_map_v3 **ms, size_t ms_len) +int ak_fs_map_v3_resolve_maps(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) + akfs_map_v3 *ptr = NULL; + // char s[129] = {0}; + printf("%s: %lu\n", __func__, ms_len); + for ( ptr = *ms; ptr < *ms+ms_len; ++ptr) { - if ( ak_fs_sha512sum_is_null(ptr)) + printf("MH: %s\n", ak_fs_sha512sum_struct_read_as_string(&(ptr->mh))); + if ( ak_fs_sha512sum_is_null(&(ptr->mh)) ) { + ak_log_debug(__func__, "map hash is null"); continue; } - if( ak_fs_open_map_v3_file(ak_fs_sha512sum_struct_read_as_string(ptr), mptr) != 2) + if( ak_fs_map_v3_open_from_file(ptr) != 2) { - ++(mptr); + ak_log_debug(__func__, "not 2"); + ++(ptr); continue; } else { - ++(mptr); + ak_log_debug(__func__, "2"); + ++(ptr); // return 1; } } return 0; } -void ak_fs_print_loaded_maps(akfs_map_v3 **map_store, size_t length) -{ - akfs_map_v3 *ptr = NULL; - for ( ptr = *map_store; ptr < *map_store + length; ++ptr) - { - if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print(ptr); - } -} - -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); - return ak_fs_map_v3_compare(m, &n); -} - -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_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) { @@ -330,97 +319,38 @@ 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); - } -} - -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 ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_print_filename(ptr); - } -} - -// char* ak_fs_fuse_list_filenames_from_map_store(akfs_map_v3** m, size_t s) +// void ak_fs_print_map_avail(const sha512sum* m) // { -// akfs_map_v3 *ptr = NULL; +// 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) // { -// if ( !ak_fs_map_v3_is_null(ptr) ) ak_fs_map_v3_get_filename(ptr); +// ak_fs_print_map_avail(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) - { - if (!ak_fs_map_v3_is_null(ptr)) ak_fs_map_v3_print(ptr); - } -} - 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]; + 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; - 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); - return 0; -} + ak_fs_maps_v3_init(&maps_ptr, len); + // ak_fs_maps_v3_print(&maps_ptr, len); + ak_fs_maps_v3_get_from_fs(&maps_ptr, len); + ak_fs_maps_v3_print(&maps_ptr, len); + ak_fs_map_v3_resolve_maps(&maps_ptr, len); -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) -{ - (void)c; - (void)v; - int option; - while ( (option = getopt(c, v, ":h|:help")) != -1 ) - { - printf("%d\n", option); - switch(option) - { - case 'h': - return ak_fs_usage(); - case ':': - printf("kek\n"); - return 1; - case '?': - printf("lol\n"); - return 2; - } - } + // 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); return 0; } - diff --git a/c_implementation/src/akfs_defuse.c b/c_implementation/src/ak_fs_defuse.c index da0c3d0..10617cc 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_map_v3_resolve_maps(&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..f1660cf --- /dev/null +++ b/c_implementation/src/ak_fs_main.c @@ -0,0 +1,43 @@ +#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__, "ak fs --list"); + return 1; +} + +int ak_fs_main(int argc, char** argv) +{ + int option; + int logind = 0; + static struct option long_options[] = { + {"help", no_argument, 0, 'h'}, + {"list", no_argument, 0, 'l'}, + {0,0,0,0} + }; + while(1) + { + option = getopt_long(argc, argv, "hl", long_options, &logind); + if ( option == -1 ) return ak_fs_usage(); + switch(option) + { + case 'h': + return ak_fs_usage(); + case 'l': + return ak_fs_ls(); + 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..92bef5d --- /dev/null +++ b/c_implementation/src/ak_fs_map_v3.c @@ -0,0 +1,244 @@ +#include <stdio.h> +#include <string.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 {\n"); + 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"); +} + +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"); + 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"); + 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) s |