aboutsummaryrefslogtreecommitdiff
path: root/c_implementation/src
diff options
context:
space:
mode:
Diffstat (limited to 'c_implementation/src')
-rw-r--r--c_implementation/src/akfs.c349
-rw-r--r--c_implementation/src/aklog.c287
-rw-r--r--c_implementation/src/aklogcatter.c35
-rw-r--r--c_implementation/src/aksettings.c113
-rw-r--r--c_implementation/src/akutils.c8
5 files changed, 792 insertions, 0 deletions
diff --git a/c_implementation/src/akfs.c b/c_implementation/src/akfs.c
new file mode 100644
index 0000000..a71a003
--- /dev/null
+++ b/c_implementation/src/akfs.c
@@ -0,0 +1,349 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libakfs.h>
+#include <sys/stat.h>
+
+char* ak_fs_return_hash_path(char* string)
+{
+ if ( ak_fs_verify_input_is_hash(string) )
+ {
+ unsigned int i = 0;
+ char *result = malloc((128*2)+1);
+ while ( string[i] != '\0' )
+ {
+ result[i*2] = string[i];
+ if ( (i*2) + 1 <= 254 )
+ {
+ result[(i*2)+1] = '/';
+ }
+ else
+ {
+ result[(i*2)+1] = '\0';
+ }
+ ++i;
+ }
+ return result;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+char* ak_fs_return_hash_dir(char* string)
+{
+ if ( ak_fs_verify_input_is_hash(string) )
+ {
+ unsigned int i = 0;
+ char *result = malloc((128*2)+1);
+ while ( string[i] != '\0' )
+ {
+ result[i*2] = string[i];
+ if ( (i*2) + 1 <= 254-2 )
+ {
+ result[(i*2)+1] = '/';
+ }
+ else
+ {
+ result[(i*2)+1] = '\0';
+ }
+ ++i;
+ }
+ return result;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+bool ak_fs_verify_input_is_hash(char* string)
+{
+ unsigned int i = 0;
+ while ( string[i] != '\0' )
+ {
+ if (
+ i < 128 &&
+ !(
+ ( string[i] >= 0x30 ) &&
+ (( string[i] <= 0x39) || ( string[i] >= 0x61 )) &&
+ ( string[i] <= 0x66 )
+ )
+ )
+ {
+ return false;
+ }
+ else {
+ i++;
+ }
+ }
+ if ( i > 128 )
+ {
+ return false;
+ }
+ return true;
+}
+
+int ak_fs_create_dir_for_hash(char* string)
+{
+ /* TODO
+ * Some aspects of this function
+ * 1. We need a "root" place to put our dirs into, this is not specified
+ * anywhere in this code but it is spartially specified in other files
+ * like lib/_ak_fs bash script and the rc/config file we currently source
+ * in $HOME/.bashrc
+ * 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(string) )
+ {
+ char* dir_path = ak_fs_return_hash_dir(string);
+ // We will need to separate the string so we can create the path one
+ // directory at the time
+ int len = strlen(dir_path);
+ for ( int i = 0; i < len+1; ++i)
+ {
+ if ( dir_path[i] == '/' )
+ {
+ //printf("%c\n", dir_path[i]);
+ //char* test = strndup(dir_path, i);
+ //printf("A: [i:%d] [c:%c] - %s\n", i, dir_path[i], test);
+ continue;
+ }
+ else
+ {
+ char* incremental_dir_path = strndup(dir_path, i+1);
+ // printf("B: [i:%d] [c:%c] - %s\n", i, dir_path[i], test);
+ struct stat sb;
+ if (stat(incremental_dir_path, &sb) == 0 && S_ISDIR(sb.st_mode))
+ {
+ continue;
+ }
+ else
+ {
+ int return_code = mkdir(incremental_dir_path, 0777);
+ if ( return_code == 0 )
+ {
+ continue;
+ }
+ else
+ {
+ // should be unreachable I guess since previous checks
+ // though it could be caused by some other kind of error
+ // like, no permission, or exists but is not a directory
+ // but a file, dev, char, pipe whatever this thing
+ // supports anyway
+ free(incremental_dir_path);
+ free(dir_path);
+ return -3;
+ }
+ }
+ free(incremental_dir_path);
+ }
+ }
+ //printf("%d\n", len);
+ //printf("%s\n", dir_path);
+ //const char *pathname = dir_path;
+ //int ec = mkdir(pathname, 0777);
+ //return ec;
+ free(dir_path);
+ return 0;
+ }
+ else
+ {
+ return -2;
+ }
+}
+
+sha512sum ak_fs_sha512sum_string_to_struct(char* string)
+{
+ sha512sum hash = {0};
+ if ( ak_fs_verify_input_is_hash(string) )
+ {
+ for (size_t l = 0; l < 8; ++l)
+ {
+ hash.sum[l]=0;
+ }
+ unsigned int i = 0;
+ unsigned int j = 0;
+ unsigned int k = 4;
+ while ( string[i] != '\0' )
+ {
+ assert( i < 128 && "Length exceeded limit");
+ if ( i % 16 == 0 ) j = i / 16;
+ switch (string[i])
+ {
+ case 0x30:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x0;
+ break;
+ case 0x31:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x1;
+ break;
+ case 0x32:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x2;
+ break;
+ case 0x33:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x3;
+ break;
+ case 0x34:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x4;
+ break;
+ case 0x35:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x5;
+ break;
+ case 0x36:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x6;
+ break;
+ case 0x37:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x7;
+ break;
+ case 0x38:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x8;
+ break;
+ case 0x39:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0x9;
+ break;
+ case 0x61:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xa;
+ break;
+ case 0x62:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xb;
+ break;
+ case 0x63:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xc;
+ break;
+ case 0x64:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xd;
+ break;
+ case 0x65:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xe;
+ break;
+ case 0x66:
+ hash.sum[j] = hash.sum[j] << k;
+ hash.sum[j] += 0xf;
+ break;
+ default:
+ assert(0 && "Character out of range");
+ }
+ i++;
+ }
+ if ( i != 128 )
+ {
+ sha512sum hash0 = {0};
+ return hash0;
+ }
+ return hash;
+ }
+ else
+ {
+ return hash;
+ }
+}
+
+void ak_fs_sha512sum_struct_to_string(sha512sum hash, char* string)
+{
+ int counter = 0;
+ for (size_t i = 0; i < 8; ++i)
+ {
+ for (size_t j = 0; j < 16; ++j)
+ {
+ long unsigned first = hash.sum[i]/0xfffffffffffffff;
+ switch(first){
+ case 0:
+ string[counter] = '0';
+ break;
+ case 1:
+ string[counter] = '1';
+ break;
+ case 2:
+ string[counter] = '2';
+ break;
+ case 3:
+ string[counter] = '3';
+ break;
+ case 4:
+ string[counter] = '4';
+ break;
+ case 5:
+ string[counter] = '5';
+ break;
+ case 6:
+ string[counter] = '6';
+ break;
+ case 7:
+ string[counter] = '7';
+ break;
+ case 8:
+ string[counter] = '8';
+ break;
+ case 9:
+ string[counter] = '9';
+ break;
+ case 0xa:
+ string[counter] = 'a';
+ break;
+ case 0xb:
+ string[counter] = 'b';
+ break;
+ case 0xc:
+ string[counter] = 'c';
+ break;
+ case 0xd:
+ string[counter] = 'd';
+ break;
+ case 0xe:
+ string[counter] = 'e';
+ break;
+ case 0xf:
+ string[counter] = 'f';
+ break;
+ default:
+ assert(0 && "Should be unreachable");
+ }
+ counter++;
+ hash.sum[i] = hash.sum[i] << 4;
+ }
+ }
+ string[128] = '\0';
+}
+
+int ak_fs_open_map_v3(char* maphash)
+{
+ if ( ak_fs_verify_input_is_hash(maphash) )
+ {
+ //FILE *fd;
+ //char *mapsdir = "/home/kaotisk/.arching-kaos/akfs/maps/";
+ //strncat(mapsdir, maphash);
+ // printf("%s\n", mapsdir);
+ exit(1);
+ return 0;
+ }
+ else
+ {
+ return 1;
+ }
+}
+
+int ak_fs_from_map_v3_to_file(akfs_map_v3 maphash)
+{
+ (void)maphash;
+ return 0;
+}
diff --git a/c_implementation/src/aklog.c b/c_implementation/src/aklog.c
new file mode 100644
index 0000000..f6b04e8
--- /dev/null
+++ b/c_implementation/src/aklog.c
@@ -0,0 +1,287 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "libaklog.h"
+
+#define AK_DEBUG true
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+int ak_log_write_to_file(char* message)
+{
+ FILE *fp;
+ fp = fopen("/home/kaotisk/.arching-kaos/logs/log", "ab");
+ if (!fp)
+ {
+ perror("fopen");
+ return EXIT_FAILURE;
+ }
+ fwrite(message, strlen(message),1,fp);
+ fwrite("\n", strlen("\n"),1,fp);
+ fclose(fp);
+ return 0;
+}
+
+void ak_log_print_log_line(char* line)
+{
+ if ( line )
+ {
+ int i = 0;
+ int spaces_found = 0;
+ int last_space = -1;
+ long int l = 1000000000;
+ long int ts = 0;
+ struct tm *timeInfo;
+ char ts_string[16]; // %Y%Y%Y%Y%m%m%d%d_%H%H%M%M%S%S
+ while ( line[i] != '\0' )
+ {
+ if ( line[i] == ' ' ) // && spaces_found < 4)
+ {
+ spaces_found++;
+ if (true) //( spaces_found < 4 )
+ {
+ for ( int k = last_space+1; k < i; k++ )
+ {
+ switch(spaces_found){
+ case 1:
+ // TS
+ while (true)
+ {
+ if ( line[k] == ' ' )
+ {
+ timeInfo = localtime(&ts);
+ strftime(ts_string, sizeof(ts_string), "%Y%m%d_%H%M%S", timeInfo);
+ printf("%s ", ts_string);
+ break;
+ }
+ else
+ {
+ switch(line[k])
+ {
+ case '0':
+ ts = 0*l + ts;
+ break;
+ case '1':
+ ts = 1*l + ts;
+ break;
+ case '2':
+ ts = 2*l + ts;
+ break;
+ case '3':
+ ts = 3*l + ts;
+ break;
+ case '4':
+ ts = 4*l + ts;
+ break;
+ case '5':
+ ts = 5*l + ts;
+ break;
+ case '6':
+ ts = 6*l + ts;
+ break;
+ case '7':
+ ts = 7*l + ts;
+ break;
+ case '8':
+ ts = 8*l + ts;
+ break;
+ case '9':
+ ts = 9*l + ts;
+ break;
+ }
+ l = l/10;
+ }
+ k++;
+ }
+ break;
+ case 2:
+ // PROGRAM
+ printf("\033[1;32m");
+ while (true)
+ {
+ if ( line[k] == ' ' )
+ {
+ break;
+ }
+ else
+ {
+ printf("%c", line[k]);
+ }
+ k++;
+ }
+ break;
+ case 3:
+ // TYPE
+ printf("\033[0;00m \033[1;31m");
+ while (true)
+ {
+ if ( line[k] == ' ' )
+ {
+ break;
+ }
+ else
+ {
+ printf("%c", line[k]);
+ }
+ k++;
+ }
+ break;
+ case 4:
+ // MESSAGE
+ printf("\033[0;00m ");
+ while (true)
+ {
+ if ( line[k] == '\0' )
+ {
+ printf("\n");
+ break;
+ }
+ else
+ {
+ printf("%c", line[k]);
+ }
+ k++;
+ }
+ break;
+ }
+ }
+ last_space = i;
+ }
+ }
+ i++;
+ }
+ }
+}
+
+void ak_log_follow()
+{
+ // tail -f $AK_LOGSFILE | while read -r p || [ -n "$p" ]
+ // do
+ // ak_log_print_log_line "$p"
+ // done
+}
+
+void ak_log_grep(char* message)
+{
+ printf("ak_log_grep: not implemented\n");
+ return;
+ exit(2);
+ if ( message )
+ {
+ if ( strcmp(message, "-h") || strcmp(message, "--help") )
+ {
+ // description();
+ printf("Launch with no arguments and select from the menu that will appear\n");
+ exit(1);
+ }
+ }
+ printf("The following scripts have entries in the log file.\n");
+ printf("Select one of those by entering the number of it below and hit enter:\n");
+ // select x in $(cat $AK_LOGSFILE | cut -d ' ' -f 2 | sort | uniq)
+ // do
+ // grep $x $AK_LOGSFILE | while read line
+ // do
+ // ak_log_print_log_line "$line"
+ // done
+ // break
+ // done
+}
+
+void ak_log_rotate()
+{
+ // if [ -f $AK_LOGSFILE ]
+ // then
+ // tar cvfz $AK_ARCHIVESDIR/logs_$(date -u +%s).tar.gz $AK_WORKDIR/logs
+ // cat /dev/null > $AK_WORKDIR/logs
+ // fi
+ // if [ -f $AK_WORKDIR/akd.log ]
+ // then
+ // tar cvfz $AK_ARCHIVESDIR/akd-logs_$(date -u +%s).tar.gz $AK_WORKDIR/akd.log
+ // cat /dev/null > $AK_WORKDIR/akd.log
+ // fi
+ printf("ak_log_rotate: not implemented\n");
+ return;
+ exit(2);
+}
+
+void ak_log_message(const char* program, LogMessageType lmtype, char* message)
+{
+ time_t ts = time(NULL);
+ time(&ts);
+ char* some_string = {0};
+ char* type = {0};
+ if ( program != NULL )
+ {
+ switch(lmtype)
+ {
+ case ERROR:
+ type = "ERROR";
+ break;
+ case INFO:
+ type = "INFO";
+ break;
+ case WARNING:
+ type = "WARNING";
+ break;
+ case EXIT:
+ type = "EXIT";
+ break;
+ case DEBUG:
+ type = "DEBUG";
+ break;
+ default:
+ 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);
+ exit(1);
+ }
+ if ( message != NULL )
+ {
+ asprintf(&some_string, "%ld <%s> [%s] %s", ts, program, type, message);
+ ak_log_write_to_file(some_string);
+ if ( AK_DEBUG ) ak_log_print_log_line(some_string);
+ }
+ else
+ {
+ 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);
+ exit(1);
+ }
+ }
+ else
+ {
+ // echo "$TS" "<$(basename $0)>" "[ERROR]" "No arguments given" >> $AK_LOGSFILE
+ asprintf(&some_string, "%ld <%s> [ERROR] No arguments given\n", ts, program);
+ ak_log_write_to_file(some_string);
+ if ( AK_DEBUG ) ak_log_print_log_line(some_string);
+ exit(1);
+ }
+}
+
+void ak_log_exit(const char* program, char* message)
+{
+ ak_log_message(program, EXIT, message);
+}
+
+void ak_log_warning(const char* program, char* message)
+{
+ ak_log_message(program, WARNING, message);
+}
+
+void ak_log_debug(const char* program, char* message)
+{
+ ak_log_message(program, DEBUG, message);
+}
+
+void ak_log_error(const char* program, char* message)
+{
+ ak_log_message(program, ERROR, message);
+}
+
+void ak_log_info(const char* program, char* message)
+{
+ ak_log_message(program, INFO, message);
+}
+
diff --git a/c_implementation/src/aklogcatter.c b/c_implementation/src/aklogcatter.c
new file mode 100644
index 0000000..54b1f8c
--- /dev/null
+++ b/c_implementation/src/aklogcatter.c
@@ -0,0 +1,35 @@
+#include <libaklogcatter.h>
+#include <stdio.h>
+#include <libaklog.h>
+#include <stdlib.h>
+
+int ak_logcatter()
+{
+ printf("Testing: %s\n", __func__);
+ FILE *fp;
+ fp = fopen("/home/kaotisk/.arching-kaos/logs", "r");
+ if (!fp)
+ {
+ perror("fopen");
+ return EXIT_FAILURE;
+ }
+ char buffer[1] = {0};
+ char line[1024] = {0};
+ unsigned int i = 0;
+ while ( fread(buffer, sizeof(char), sizeof(char), fp) )
+ {
+ if ( buffer[0] == '\n' )
+ {
+ line[i] = '\0';
+ ak_log_print_log_line(line);
+ i = 0;
+ }
+ else
+ {
+ line[i] = buffer[0];
+ i++;
+ }
+ }
+ fclose(fp);
+ return 0;
+}
diff --git a/c_implementation/src/aksettings.c b/c_implementation/src/aksettings.c
new file mode 100644
index 0000000..470330f
--- /dev/null
+++ b/c_implementation/src/aksettings.c
@@ -0,0 +1,113 @@
+#include <libaksettings.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define MAX_SETTINGS 100
+
+AKSetting settings[MAX_SETTINGS];
+int settings_count = 0;
+
+bool ak_settings_write_string(FILE *file, const char *str) {
+ size_t len = strlen(str) + 1; // Include null terminator
+ if (fwrite(&len, sizeof(size_t), 1, file) != 1) return false;
+ if (fwrite(str, sizeof(char), len, file) != len) return false;
+ return true;
+}
+
+char *ak_settings_read_string(FILE *file) {
+ size_t len;
+ if (fread(&len, sizeof(size_t), 1, file) != 1) return NULL;
+ char *str = malloc(len);
+ if (!str) return NULL;
+ if (fread(str, sizeof(char), len, file) != len) {
+ free(str);
+ return NULL;
+ }
+ return str;
+}
+
+void ak_settings_free_settings() {
+ for (int i = 0; i < settings_count; i++) {
+ free(settings[i].key);
+ free(settings[i].value);
+ }
+ settings_count = 0;
+}
+
+int ak_settings_find_setting(const char *key) {
+ for (int i = 0; i < settings_count; i++) {
+ if (strcmp(settings[i].key, key) == 0) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+bool ak_settings_load_settings_binary() {
+ FILE *file = fopen("settings.bin", "rb");
+ if (!file) return false;
+ if (fread(&settings_count, sizeof(int), 1, file) != 1) {
+ fclose(file);
+ return false;
+ }
+ for (int i = 0; i < settings_count; i++) {
+ settings[i].key = ak_settings_read_string(file);
+ settings[i].value = ak_settings_read_string(file);
+ if (!settings[i].key || !settings[i].value) {
+ ak_settings_free_settings();
+ fclose(file);
+ return false;
+ }
+ }
+ fclose(file);
+ return true;
+}
+
+bool ak_settings_save_settings_binary() {
+ FILE *file = fopen("settings.bin", "wb");
+ if (!file) return false;
+ if (fwrite(&settings_count, sizeof(int), 1, file) != 1) {
+ fclose(file);
+ return false;
+ }
+ for (int i = 0; i < settings_count; i++) {
+ if (!ak_settings_write_string(file, settings[i].key)) {
+ fclose(file);
+ return false;
+ }
+ if (!ak_settings_write_string(file, settings[i].value)) {
+ fclose(file);
+ return false;
+ }
+ }
+ fclose(file);
+ return true;
+}
+
+bool ak_settings_set_setting(const char *key, const char *value) {
+ int index = ak_settings_find_setting(key);
+ if (index == -1) {
+ if (settings_count >= MAX_SETTINGS) return false;
+ settings[settings_count].key = strdup(key);
+ settings[settings_count].value = strdup(value);
+ if (!settings[settings_count].key || !settings[settings_count].value) {
+ free(settings[settings_count].key);
+ free(settings[settings_count].value);
+ return false;
+ }
+ settings_count++;
+ } else {
+ char *new_value = strdup(value);
+ if (!new_value) return false;
+ free(settings[index].value);
+ settings[index].value = new_value;
+ }
+ return true;
+}
+
+const char *ak_settings_get_setting(const char *key) {
+ int index = ak_settings_find_setting(key);
+ return (index == -1) ? NULL : settings[index].value;
+}
diff --git a/c_implementation/src/akutils.c b/c_implementation/src/akutils.c
new file mode 100644
index 0000000..d58e0a3
--- /dev/null
+++ b/c_implementation/src/akutils.c
@@ -0,0 +1,8 @@
+#include <libakutils.h>
+#include <stdio.h>
+
+int ak_utils()
+{
+ printf("Testing: %s\n", __func__);
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-04 15:50:45 +0000