moved program modes code to separate files

src/cli/main.c

@@ -1,43 +1,13 @@
 #include "tlibc/tlibc.h"
-#include "tlibc/base64.h"
-#include "tlibc/filesystem.h"
-#include "tlibc/time.h"
 #include "network/network.h"
-#include "cli/ClientCLI/ClientCLI.h"
+#include "cryptography/RSA.h"
-#include "server/server_internal.h"
+#include "modes/modes.h"
 
 #define _DEFAULT_CONFIG_PATH_CLIENT "tcp-chat-client.config"
 #define _DEFAULT_CONFIG_PATH_SERVER "tcp-chat-server.config"
 
 #define arg_is(LITERAL) str_equals(arg_str, STR(LITERAL))
 
-typedef enum ProgramMode {
-    ClientMode,
-    ServerMode,
-    RsaGenStdin,
-    RsaGenRandom,
-    RandomBytes,
-    RandomBytesBase64,
-} ProgramMode;
-
-static void log_func(void* logger, LogSeverity severity, cstr context, cstr msg){
-    (void)logger;
-    
-    cstr severity_cstr;
-    switch(severity){
-        default: severity_cstr = "INVALID_LOG_SEVERITY"; break;
-        case LogSeverity_Debug: severity_cstr = "DBUG"; break;
-        case LogSeverity_Info:  severity_cstr = "INFO"; break;
-        case LogSeverity_Warn:  severity_cstr = "WARN"; break;
-        case LogSeverity_Error: severity_cstr = "ERRR"; break;
-    }
-
-    DateTime dt;
-    DateTime_getLocal(&dt);
-
-    printf("[" FMT_DateTime_text "][%s/%s]: %s\n", DT_expand(dt), context, severity_cstr, msg);
-}
-
 
 int main(const int argc, cstr const* argv){
     Deferral(32);
@@ -158,140 +128,31 @@ int main(const int argc, cstr const* argv){
     }
     
     switch(mode){
-        case ClientMode: {
-            if(!config_path)
-                config_path = _DEFAULT_CONFIG_PATH_CLIENT;
-            
-            ClientCLI client;
-            ClientCLI_construct(&client);
-            Defer(ClientCLI_destroy(&client));
-            try_fatal_void(ClientCLI_run(&client));
-            break;
-        }
-
-        case ServerMode: {
-            if(!config_path)
-                config_path = _DEFAULT_CONFIG_PATH_SERVER;
-            
-            // open file
-            try_fatal(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
-            Defer(file_close(config_file));
-            // read whole file into str
-            Array(u8) config_buf = Array_null;
-            try_fatal_void(file_readWhole(config_file, &config_buf));
-            Defer(Array_free(config_buf));
-            str config_str = Array_castTo_str(config_buf, false);
-            config_buf.data = NULL;
-            // init server
-            try_fatal(Server* server, p, Server_create(config_str, NULL, log_func));
-            Defer(Server_free(server));
-            // manually close file and free config_buf
-            file_close(config_file);
-            config_file = NULL;
-            Array_free(config_buf);
-            // start infinite loop on main thread
-            try_fatal_void(Server_run(server));
-            break;
-        }
-
-        case RsaGenStdin: {
-            printfe("reading stdin...\n");
-            Array(u8) input_buf = Array_alloc_size(64*1024);
-            Defer(Array_free(input_buf));
-            br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
-            br_hmac_drbg_init(&rng, &br_sha256_vtable, NULL, 0);
-            i64 read_n = 0;
-            do {
-                read_n = fread(input_buf.data, 1, input_buf.size, stdin);
-                if(read_n < 0){
-                    printfe("ERROR: no input\n");
-                    Return 1;
-                }
-                // put bytes to rng as seed
-                br_hmac_drbg_update(&rng, input_buf.data, read_n);
-            } while(read_n == input_buf.size);
-            printfe("generating RSA key pair based on stdin...\n");
-            br_rsa_private_key sk;
-            br_rsa_public_key pk;
-            try_fatal_void(RSA_generateKeyPair(size_arg, &sk, &pk, &rng.vtable));
-            Defer(
-                RSA_destroyPrivateKey(&sk);
-                RSA_destroyPublicKey(&pk);
-            );
-            
-            str sk_str = RSA_serializePrivateKey_base64(&sk);
-            printf("rsa_private_key = %s\n", sk_str.data);
-            str_free(sk_str);
-            
-            str pk_str = RSA_serializePublicKey_base64(&pk);
-            printf("\nrsa_public_key = %s\n", pk_str.data);
-            str_free(pk_str);
-            break;
-        }
-        
-        case RsaGenRandom: {
-            printfe("generating random RSA key pair...\n");
-            br_rsa_private_key sk;
-            br_rsa_public_key pk;
-            try_fatal_void(RSA_generateKeyPairFromSystemRandom(size_arg, &sk, &pk));
-            Defer(
-                RSA_destroyPrivateKey(&sk);
-                RSA_destroyPublicKey(&pk);
-            );
-
-            str sk_str = RSA_serializePrivateKey_base64(&sk);
-            printf("rsa_private_key = %s\n", sk_str.data);
-            str_free(sk_str);
-            
-            str pk_str = RSA_serializePublicKey_base64(&pk);
-            printf("\nrsa_public_key = %s\n", pk_str.data);
-            str_free(pk_str);
-            break;
-        }
-        
-        case RandomBytes: {
-            printfe("generating random bytes...\n");
-            br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
-            rng_init_sha256_seedFromSystem(&rng.vtable);
-            Array(u8) random_buf = Array_alloc_size(1024);
-            u32 full_buffers_n = size_arg / random_buf.size;
-            u32 remaining_n = size_arg % random_buf.size;
-            while(full_buffers_n > 0){
-                full_buffers_n--;
-                br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
-                fwrite(random_buf.data, 1, random_buf.size, stdout);
-            }
-            
-            br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
-            fwrite(random_buf.data, 1, remaining_n, stdout);
-            break;
-        }
-
-        case RandomBytesBase64: {
-            printfe("generating random bytes...\n");
-            br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
-            rng_init_sha256_seedFromSystem(&rng.vtable);
-            Array(u8) random_buf = Array_alloc_size(1024);
-            Array(u8) base64_buf = Array_alloc_size(base64_encodedSize(random_buf.size));
-            u32 full_buffers_n = size_arg / random_buf.size;
-            u32 remaining_n = size_arg % random_buf.size;
-            u32 enc_size = 0;
-            while(full_buffers_n > 0){
-                full_buffers_n--;
-                br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
-                enc_size = base64_encode(random_buf.data, random_buf.size, base64_buf.data);
-                fwrite(base64_buf.data, 1, enc_size, stdout);
-            }
-            
-            br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
-            enc_size = base64_encode(random_buf.data, remaining_n, base64_buf.data);
-            fwrite(base64_buf.data, 1, enc_size, stdout);
-            break;
-        }
-        
         default:
             printfe("ERROR: invalid program mode %i\n", mode);
             Return 1;
+        case ClientMode:
+            if(!config_path)
+                config_path = _DEFAULT_CONFIG_PATH_CLIENT;
+            try_fatal_void(run_ClientMode(config_path));
+            break;
+        case ServerMode:
+            if(!config_path)
+                config_path = _DEFAULT_CONFIG_PATH_SERVER;
+            try_fatal_void(run_ServerMode(config_path));
+            break;
+        case RsaGenStdin:
+            try_fatal_void(run_RsaGenStdin(size_arg));
+            break;
+        case RsaGenRandom:
+            try_fatal_void(run_RsaGenRandom(size_arg));
+            break;
+        case RandomBytes:
+            try_fatal_void(run_RandomBytes(size_arg));
+            break;
+        case RandomBytesBase64:
+            try_fatal_void(run_RandomBytesBase64(size_arg));
+            break;
     }
 
     Return 0;

src/cli/modes/ClientMode.c

@@ -0,0 +1,15 @@
+#include "modes.h"
+#include "cli/ClientCLI/ClientCLI.h"
+
+Result(void) run_ClientMode(cstr config_path) {
+    Deferral(4);
+    (void)config_path;
+
+    ClientCLI client;
+    ClientCLI_construct(&client);
+    Defer(ClientCLI_destroy(&client));
+	// start infinite loop on main thread
+    try_fatal_void(ClientCLI_run(&client));
+
+    Return RESULT_VOID;
+}

src/cli/modes/RandomBytes.c

@@ -0,0 +1,49 @@
+#include "modes.h"
+#include "cryptography/cryptography.h"
+#include "tlibc/base64.h"
+
+Result(void) run_RandomBytes(u32 key_size) {
+    Deferral(4);
+    
+	printfe("generating random bytes...\n");
+	br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
+	rng_init_sha256_seedFromSystem(&rng.vtable);
+	Array(u8) random_buf = Array_alloc_size(1024);
+	u32 full_buffers_n = key_size / random_buf.size;
+	u32 remaining_n = key_size % random_buf.size;
+	while(full_buffers_n > 0){
+		full_buffers_n--;
+		br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
+		fwrite(random_buf.data, 1, random_buf.size, stdout);
+	}
+	
+	br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
+	fwrite(random_buf.data, 1, remaining_n, stdout);
+
+    Return RESULT_VOID;
+}
+
+Result(void) run_RandomBytesBase64(u32 key_size) {
+    Deferral(4);
+    
+	printfe("generating random bytes...\n");
+	br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
+	rng_init_sha256_seedFromSystem(&rng.vtable);
+	Array(u8) random_buf = Array_alloc_size(1024);
+	Array(u8) base64_buf = Array_alloc_size(base64_encodedSize(random_buf.size));
+	u32 full_buffers_n = key_size / random_buf.size;
+	u32 remaining_n = key_size % random_buf.size;
+	u32 enc_size = 0;
+	while(full_buffers_n > 0){
+		full_buffers_n--;
+		br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
+		enc_size = base64_encode(random_buf.data, random_buf.size, base64_buf.data);
+		fwrite(base64_buf.data, 1, enc_size, stdout);
+	}
+	
+	br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
+	enc_size = base64_encode(random_buf.data, remaining_n, base64_buf.data);
+	fwrite(base64_buf.data, 1, enc_size, stdout);
+
+    Return RESULT_VOID;
+}

src/cli/modes/RsaGen.c

@@ -0,0 +1,64 @@
+#include "modes.h"
+#include "cryptography/RSA.h"
+
+
+
+Result(void) run_RsaGenStdin(u32 key_size) {
+    Deferral(4);
+
+	printfe("reading stdin...\n");
+	Array(u8) input_buf = Array_alloc_size(64*1024);
+	Defer(Array_free(input_buf));
+	br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
+	br_hmac_drbg_init(&rng, &br_sha256_vtable, NULL, 0);
+	i64 read_n = 0;
+	do {
+		read_n = fread(input_buf.data, 1, input_buf.size, stdin);
+		if(read_n < 0){
+			Return RESULT_ERROR("ERROR: can't read stdin", false);
+		}
+		// put bytes to rng as seed
+		br_hmac_drbg_update(&rng, input_buf.data, read_n);
+	} while(read_n == input_buf.size);
+	printfe("generating RSA key pair based on stdin...\n");
+	br_rsa_private_key sk;
+	br_rsa_public_key pk;
+	try_void(RSA_generateKeyPair(key_size, &sk, &pk, &rng.vtable));
+	Defer(
+		RSA_destroyPrivateKey(&sk);
+		RSA_destroyPublicKey(&pk);
+	);
+	
+	str sk_str = RSA_serializePrivateKey_base64(&sk);
+	printf("rsa_private_key = %s\n", sk_str.data);
+	str_free(sk_str);
+	
+	str pk_str = RSA_serializePublicKey_base64(&pk);
+	printf("\nrsa_public_key = %s\n", pk_str.data);
+	str_free(pk_str);
+
+    Return RESULT_VOID;
+}
+
+Result(void) run_RsaGenRandom(u32 key_size) {
+    Deferral(4);
+
+	printfe("generating random RSA key pair...\n");
+	br_rsa_private_key sk;
+	br_rsa_public_key pk;
+	try_void(RSA_generateKeyPairFromSystemRandom(key_size, &sk, &pk));
+	Defer(
+		RSA_destroyPrivateKey(&sk);
+		RSA_destroyPublicKey(&pk);
+	);
+
+	str sk_str = RSA_serializePrivateKey_base64(&sk);
+	printf("rsa_private_key = %s\n", sk_str.data);
+	str_free(sk_str);
+	
+	str pk_str = RSA_serializePublicKey_base64(&pk);
+	printf("\nrsa_public_key = %s\n", pk_str.data);
+	str_free(pk_str);
+
+    Return RESULT_VOID;
+}

src/cli/modes/ServerMode.c

@@ -0,0 +1,51 @@
+#include "modes.h"
+#include "tcp-chat/server.h"
+#include "tlibc/time.h"
+
+
+static void log_func(void* logger, LogSeverity severity, cstr context, cstr msg){
+    (void)logger;
+    
+    cstr severity_cstr;
+    switch(severity){
+        default: severity_cstr = "INVALID_LOG_SEVERITY"; break;
+        case LogSeverity_Debug: severity_cstr = "DBUG"; break;
+        case LogSeverity_Info:  severity_cstr = "INFO"; break;
+        case LogSeverity_Warn:  severity_cstr = "WARN"; break;
+        case LogSeverity_Error: severity_cstr = "ERRR"; break;
+    }
+
+    DateTime dt;
+    DateTime_getLocal(&dt);
+
+    printf("[" FMT_DateTime_text "][%s/%s]: %s\n", DT_expand(dt), context, severity_cstr, msg);
+}
+
+Result(void) run_ServerMode(cstr config_path) {
+    Deferral(4);
+    
+	// open file
+	try(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
+	Defer(file_close(config_file));
+	
+    // read whole file into str
+	Array(u8) config_buf = Array_null;
+	try_void(file_readWhole(config_file, &config_buf));
+	Defer(Array_free(config_buf));
+	str config_str = Array_castTo_str(config_buf, false);
+	config_buf.data = NULL;
+
+	// init server
+	try(Server* server, p, Server_create(config_str, NULL, log_func));
+	Defer(Server_free(server));
+	
+    // manually close file and free config_buf
+	file_close(config_file);
+	config_file = NULL;
+	Array_free(config_buf);
+
+	// start infinite loop on main thread
+	try_void(Server_run(server));
+
+    Return RESULT_VOID;
+}

src/cli/modes/modes.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "tlibc/errors.h"
+#include "tlibc/filesystem.h"
+
+typedef enum ProgramMode {
+    ClientMode,
+    ServerMode,
+    RsaGenStdin,
+    RsaGenRandom,
+    RandomBytes,
+    RandomBytesBase64,
+} ProgramMode;
+
+Result(void) run_ClientMode(cstr config_path);
+Result(void) run_ServerMode(cstr config_path);
+Result(void) run_RsaGenStdin(u32 key_size);
+Result(void) run_RsaGenRandom(u32 key_size);
+Result(void) run_RandomBytes(u32 key_size);
+Result(void) run_RandomBytesBase64(u32 key_size);

src/cryptography/cryptography.h

@@ -2,6 +2,7 @@
 #include "tlibc/collections/Array.h"
 #include "tlibc/errors.h"
 #include "bearssl_rand.h"
+#include "bearssl_hash.h"
 #include "tcp-chat/common_constants.h"
 
 //////////////////////////////////////////////////////////////////////////////

src/cryptography/hash.c

@@ -1,5 +1,4 @@
 #include "cryptography.h"
-#include "bearssl_hash.h"
 #include "assert.h"
 
 void hash_password(Array(u8) password, u8* out_buffer, i32 iterations){