Timerix/tcp-chat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed memory issues

Browse Source
This commit is contained in:
Timerix 2025-11-06 22:36:02 +05:00
parent d36fe9e5b3
commit ee522ac401
9 changed files with 57 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dependencies/tlibc vendored

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

6
src/client/ServerConnection.c
View File

@ -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

29
src/client/client.c
View File

@ -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)
continue;
if(fgets(input_buf.data, input_buf.size, stdin) == NULL){
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);

18
src/cryptography/RSA.c
View File

@ -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);

4
src/cryptography/RSA.h
View File

@ -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 //

2
src/server/ClientConnection.c
View File

@ -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

2
src/server/ServerCredentials.c
View File

@ -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));

20
src/server/server.c
View File

@ -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);
// Defer(free(buffer.data));
// u32 dec_size = 0;
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));
u32 dec_size = 0;
while(true){
sleepMsec(10);
}

2
src/server/server.h
View File

@ -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);