fixed memory issues

dependencies/tlibc

@@ -1 +1 @@
-Subproject commit 5fb2db2380b678381ef455a18c8210a6a3314e60
+Subproject commit 00a1a29d342c6b3bcb8015a661364e10a3134fe4

src/client/ServerConnection.c

@@ -34,7 +34,9 @@ Result(void) ServerLink_parse(cstr server_link_cstr, EndpointIPv4* server_end_ou
         Return RESULT_ERROR_FMT("server link is invalid: %s", server_link_cstr);
     }
     str server_key_str = str_sliceAfter(server_link_str, sep_pos + 1);
-    try_void(RSA_parsePublicKey_base64(server_key_str, server_key_out));
+    char* server_key_cstr = str_copy(server_key_str).data;
+    Defer(free(server_key_cstr));
+    try_void(RSA_parsePublicKey_base64(server_key_cstr, server_key_out));
     
     Return RESULT_VOID;
 }
@@ -66,6 +68,8 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
     EncryptedSocketTCP_construct(&conn->sock, _s, NETWORK_BUFFER_SIZE, conn->session_key);
     
     Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
+    // fix for valgrind false detected errors about uninitialized memory
+    Array_memset(buffer, 0xCC);
     Defer(free(buffer.data));
 
     // construct PacketHeader and ClientHandshake in buffer

src/client/client.c

@@ -27,7 +27,9 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
     str usrername = str_null;
     while(true) {
         printf("username: ");
-        fgets(username_buf, sizeof(username_buf), stdin);
+        if(fgets(username_buf, sizeof(username_buf), stdin) == NULL){
+            Return RESULT_ERROR("STDIN is closed", false);
+        }
         usrername = str_from_cstr(username_buf);
         if(usrername.size < 4){
             printf("ERROR: username length must be at least 4\n");
@@ -40,7 +42,9 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
     while(true) {
         printf("password: ");
         // TODO: hide password
-        fgets(password_buf, sizeof(password_buf), stdin);
+        if(fgets(password_buf, sizeof(password_buf), stdin) == NULL){
+            Return RESULT_ERROR("STDIN is closed", false);
+        }
         password = str_from_cstr(password_buf);
         if(password.size < 8){
             printf("ERROR: password length must be at least 8\n");
@@ -59,15 +63,23 @@ Result(void) client_run() {
     }
 
     fputs(greeting_art.data, stdout);
+
+    Defer(
+        ClientCredentials_free(_client_credentials);
+        ServerConnection_close(_server_connection);
+    );
     try_void(askUserNameAndPassword(&_client_credentials));
 
     Array(char) input_buf = Array_alloc(char, 10000);
+    Defer(free(input_buf.data));
     str command_input = str_null;
     bool stop = false;
     while(!stop){
+        sleepMsec(50);
         fputs("> ", stdout);
-        if(fgets(input_buf.data, input_buf.size, stdin) == NULL)
+        if(fgets(input_buf.data, input_buf.size, stdin) == NULL){
-            continue;
+            Return RESULT_ERROR("STDIN is closed", false);
+        }
         
         command_input = str_from_cstr(input_buf.data);
         str_trim(&command_input, true);
@@ -77,15 +89,12 @@ Result(void) client_run() {
         Result(void) com_result = commandExec(command_input, &stop);
         if(com_result.error){
             str e_str = Error_toStr(com_result.error);
-            printfe("%s\n", e_str.data);
+            printf("%s\n", e_str.data);
             free(e_str.data);
             Error_free(com_result.error);
         }
     }
 
-    free(input_buf.data);
-    ClientCredentials_free(_client_credentials);
-    ServerConnection_close(_server_connection);
     Return RESULT_VOID;
 }
 
@@ -116,7 +125,9 @@ static Result(void) commandExec(str command, bool* stop){
         ServerConnection_close(_server_connection);
 
         puts("Enter server address (ip:port:public_key): ");
-        fgets(answer_buf, answer_buf_size, stdin);
+        if(fgets(answer_buf, answer_buf_size, stdin) == NULL){
+            Return RESULT_ERROR("STDIN is closed", false);
+        }
         str new_server_link = str_from_cstr(answer_buf);
         str_trim(&new_server_link, true);
 

src/cryptography/RSA.c

@@ -111,10 +111,10 @@ str RSA_serializePublicKey_base64(const br_rsa_public_key* pk){
     return str_construct(serialized_buf, offset, true);
 }
 
-Result(void) RSA_parsePublicKey_base64(const str src, br_rsa_public_key* pk){
+Result(void) RSA_parsePublicKey_base64(cstr src, br_rsa_public_key* pk){
     Deferral(8);
     u32 n_bitlen = 0;
-    if(sscanf(src.data, "RSA-Public-%u:", &n_bitlen) != 1){
+    if(sscanf(src, "RSA-Public-%u:", &n_bitlen) != 1){
         Return RESULT_ERROR("can't parse key size", false);
     }
     u32 key_buffer_size = BR_RSA_KBUF_PUB_SIZE(n_bitlen);
@@ -122,11 +122,12 @@ Result(void) RSA_parsePublicKey_base64(const str src, br_rsa_public_key* pk){
     pk->elen = 4;
     pk->nlen = key_buffer_size - 4;
     pk->e = pk->n + pk->nlen;
-    u32 offset = str_seekChar(src, ':', 10) + 1;
+    str src_str = str_from_cstr(src);
+    u32 offset = str_seekChar(src_str, ':', 10) + 1;
     if(offset == 0){
         Return RESULT_ERROR("missing ':' before key data", false);
     }
-    str key_base64_str = src;
+    str key_base64_str = src_str;
     key_base64_str.data += offset;
     key_base64_str.size -= offset;
     u32 decoded_size = base64_decodedSize(key_base64_str.data, key_base64_str.size);
@@ -140,10 +141,10 @@ Result(void) RSA_parsePublicKey_base64(const str src, br_rsa_public_key* pk){
     Return RESULT_VOID;
 }
 
-Result(void) RSA_parsePrivateKey_base64(const str src, br_rsa_private_key* sk){
+Result(void) RSA_parsePrivateKey_base64(cstr src, br_rsa_private_key* sk){
     Deferral(8);
     u32 n_bitlen = 0;
-    if(sscanf(src.data, "RSA-Private-%u:", &n_bitlen) != 1){
+    if(sscanf(src, "RSA-Private-%u:", &n_bitlen) != 1){
         Return RESULT_ERROR("can't parse key size", false);
     }
     sk->n_bitlen = n_bitlen;
@@ -155,11 +156,12 @@ Result(void) RSA_parsePrivateKey_base64(const str src, br_rsa_private_key* sk){
     sk->dp = sk->q + field_len;
     sk->dq = sk->dp + field_len;
     sk->iq = sk->dq + field_len;
-    u32 offset = str_seekChar(src, ':', 10) + 1;
+    str src_str = str_from_cstr(src);
+    u32 offset = str_seekChar(src_str, ':', 10) + 1;
     if(offset == 0){
         Return RESULT_ERROR("missing ':' before key data", false);
     }
-    str key_base64_str = src;
+    str key_base64_str = src_str;
     key_base64_str.data += offset;
     key_base64_str.size -= offset;
     u32 decoded_size = base64_decodedSize(key_base64_str.data, key_base64_str.size);

src/cryptography/RSA.h

@@ -47,7 +47,7 @@ str RSA_serializePrivateKey_base64(const br_rsa_private_key* sk);
 
 /// @param src serialized private key format "RSA-Private-%SIZE%:%DATA_BASE64%"
 /// @param sk out private key. WARNING: .p is allocated on heap
-Result(void) RSA_parsePrivateKey_base64(const str src, br_rsa_private_key* sk);
+Result(void) RSA_parsePrivateKey_base64(cstr src, br_rsa_private_key* sk);
 
 /// @brief Encode key data in human-readable format
 /// @param src some data
@@ -56,7 +56,7 @@ str RSA_serializePublicKey_base64(const br_rsa_public_key* sk);
 
 /// @param src serialized public key format "RSA-Public-%SIZE%:%DATA_BASE64%"
 /// @param sk out public key. WARNING: .p is allocated on heap
-Result(void) RSA_parsePublicKey_base64(const str src, br_rsa_public_key* sk);
+Result(void) RSA_parsePublicKey_base64(cstr src, br_rsa_public_key* sk);
 
 //////////////////////////////////////////////////////////////////////////////
 //                               RSAEncryptor                               //

src/server/ClientConnection.c

@@ -27,6 +27,8 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
     conn->session_key = Array_alloc_size(AES_SESSION_KEY_SIZE);
 
     Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
+    // fix for valgrind false detected errors about uninitialized memory
+    Array_memset(buffer, 0xCC);
     Defer(free(buffer.data));
     
     // TODO: set socket timeout to 5 seconds

src/server/ServerCredentials.c

@@ -1,7 +1,7 @@
 #include "server.h"
 
 
-Result(ServerCredentials*) ServerCredentials_create(const str rsa_sk_base64, const str rsa_pk_base64){
+Result(ServerCredentials*) ServerCredentials_create(cstr rsa_sk_base64, cstr rsa_pk_base64){
     Deferral(4);
     
     ServerCredentials* cred = (ServerCredentials*)malloc(sizeof(ServerCredentials));

src/server/server.c

@@ -24,6 +24,7 @@ static Result(void) parseConfig(cstr config_path){
 
     // open file
     try(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
+    Defer(file_close(config_file));
     // read whole file into Array(char)
     try(i64 config_file_size, i, file_getSize(config_file));
     Array(char) config_buf = Array_alloc(char, config_file_size);
@@ -35,7 +36,13 @@ static Result(void) parseConfig(cstr config_path){
     str pk_base64;
     try_void(config_findValue(config_str, STR("rsa_private_key"), &sk_base64, true));
     try_void(config_findValue(config_str, STR("rsa_public_key"), &pk_base64, true));
-    try(_server_credentials, p, ServerCredentials_create(sk_base64, pk_base64));
+    char* sk_base64_cstr = str_copy(sk_base64).data;
+    char* pk_base64_cstr = str_copy(pk_base64).data;
+    Defer(
+        free(sk_base64_cstr);
+        free(pk_base64_cstr);
+    );
+    try(_server_credentials, p, ServerCredentials_create(sk_base64_cstr, pk_base64_cstr));
     
     Return RESULT_VOID;
 }
@@ -46,6 +53,7 @@ Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
     logInfo(log_ctx, "starting server");
     logDebug(log_ctx, "parsing config");
     try_void(parseConfig(config_path));
+    Defer(ServerCredentials_free(_server_credentials));
 
     logDebug(log_ctx, "initializing main socket");
     EndpointIPv4 server_end;
@@ -64,6 +72,7 @@ Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
         //TODO: use async IO instead of threads to not waste system resources 
         // while waiting for incoming data in 100500 threads
         try_stderrcode(pthread_create(&conn_thread, NULL, handle_connection, args));
+        try_stderrcode(pthread_detach(&conn_thread));
     }
 
     Return RESULT_VOID;
@@ -106,12 +115,13 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
 
     // handle requests
     
-    // Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
+    Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
-    // Defer(free(buffer.data));
+    // fix for valgrind false detected errors about uninitialized memory
-    // u32 dec_size = 0;
+    Array_memset(buffer, 0xCC);
+    Defer(free(buffer.data));
+    u32 dec_size = 0;
 
     while(true){
-        
         sleepMsec(10);
     }
 

src/server/server.h

@@ -11,7 +11,7 @@ typedef struct ServerCredentials {
     br_rsa_public_key rsa_pk;
 } ServerCredentials;
 
-Result(ServerCredentials*) ServerCredentials_create(const str rsa_sk_base64, const str rsa_pk_base64);
+Result(ServerCredentials*) ServerCredentials_create(cstr rsa_sk_base64, cstr rsa_pk_base64);
 
 void ServerCredentials_free(ServerCredentials* cred);