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

created structs Client and Server

Browse Source
This commit is contained in:
Timerix 2025-11-09 03:36:50 +05:00
parent 96a117bc50
commit e03c651cef
15 changed files with 234 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dependencies/tlibc vendored

@ -1 +1 @@
Subproject commit d6436d08338a0a762e727f0c816dd5a09782b180
Subproject commit 2c8e6fc601a868851d8ce50f77b391e6a9b7e656

49
src/client/ClientCredential.c
View File

@ -1,49 +0,0 @@
#include "client.h"
#include "tlibc/string/StringBuilder.h"
void ClientCredentials_free(ClientCredentials* cred){
if(cred == NULL)
return;
free(cred->username.data);
free(cred->aes_key.data);
free(cred);
}
Result(ClientCredentials*) ClientCredentials_create(str username, str password){
Deferral(8);
ClientCredentials* cred = (ClientCredentials*)malloc(sizeof(ClientCredentials));
memset(cred, 0, sizeof(ClientCredentials));
bool success = false;
Defer(
if(!success)
free(cred);
);
cred->username = str_copy(username);
Defer(
if(!success)
free(cred->username.data);
);
// concat password and username
StringBuilder sb = StringBuilder_alloc(username.size + password.size + 1);
Defer(StringBuilder_destroy(&sb));
StringBuilder_append_str(&sb, password);
StringBuilder_append_str(&sb, username);
Array(u8) password_and_username = str_castTo_Array(StringBuilder_getStr(&sb));
cred->aes_key = Array_alloc(u8, PASSWORD_HASH_SIZE);
Defer(
if(!success){
free(cred->aes_key.data);
}
);
// lvl 1 hash - is used as AES key for user data
hash_password(password_and_username, cred->aes_key.data, __PASSWORD_HASH_LVL_ITERATIONS);
AESBlockEncryptor_construct(&cred->user_data_aes_enc, cred->aes_key, AESBlockEncryptor_DEFAULT_CLASS);
AESBlockDecryptor_construct(&cred->user_data_aes_dec, cred->aes_key, AESBlockDecryptor_DEFAULT_CLASS);
success = true;
Return RESULT_VALUE(p, cred);
}

43
src/client/ClientCredentials.c Normal file
View File

@ -0,0 +1,43 @@
#include "client.h"
#include "tlibc/string/StringBuilder.h"
void ClientCredentials_destroy(ClientCredentials* cred){
if(!cred)
return;
free(cred->username.data);
free(cred->user_data_key.data);
free(cred->token.data);
}
Result(void) ClientCredentials_tryConstruct(ClientCredentials* cred,
str username, str password)
{
Deferral(8);
memset(cred, 0, sizeof(ClientCredentials));
bool success = false;
Defer(if(!success) ClientCredentials_destroy(cred));
cred->username = str_copy(username);
// concat password and username
StringBuilder sb = StringBuilder_alloc(username.size + password.size + 1);
Defer(StringBuilder_destroy(&sb));
StringBuilder_append_str(&sb, password);
StringBuilder_append_str(&sb, username);
Array(u8) password_and_username = str_castTo_Array(StringBuilder_getStr(&sb));
// lvl 1 hash - is used as AES key for user data
cred->user_data_key = Array_alloc(u8, PASSWORD_HASH_SIZE);
hash_password(password_and_username, cred->user_data_key.data, __PASSWORD_HASH_LVL_ITERATIONS);
// lvl 2 hash - is used for authentification
cred->token = Array_alloc(u8, PASSWORD_HASH_SIZE);
hash_password(cred->user_data_key, cred->token.data, __PASSWORD_HASH_LVL_ITERATIONS);
AESBlockEncryptor_construct(&cred->user_data_aes_enc, cred->user_data_key, AESBlockEncryptor_DEFAULT_CLASS);
AESBlockDecryptor_construct(&cred->user_data_aes_dec, cred->user_data_key, AESBlockDecryptor_DEFAULT_CLASS);
success = true;
Return RESULT_VOID;
}

9
src/client/ServerConnection.c
View File

@ -2,7 +2,7 @@
#include "network/tcp-chat-protocol/v1.h"
void ServerConnection_close(ServerConnection* conn){
if(conn == NULL)
if(!conn)
return;
RSA_destroyPublicKey(&conn->server_pk);
EncryptedSocketTCP_destroy(&conn->sock);
@ -42,15 +42,12 @@ Result(void) ServerLink_parse(cstr server_link_cstr, EndpointIPv4* server_end_ou
}
Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_credentials, cstr server_link_cstr){
Deferral(64);
Deferral(16);
ServerConnection* conn = (ServerConnection*)malloc(sizeof(ServerConnection));
memset(conn, 0, sizeof(*conn));
bool success = false;
Defer(
if(!success)
ServerConnection_close(conn);
);
Defer(if(!success) ServerConnection_close(conn));
try_void(ServerLink_parse(server_link_cstr, &conn->server_end, &conn->server_pk));
RSAEncryptor_construct(&conn->rsa_enc, &conn->server_pk);

57
src/client/client.c
View File

@ -17,12 +17,30 @@ static const str farewell_art = STR(
"\\(_,J J L l`,)/\n"
);
static ClientCredentials* _client_credentials = NULL;
static ServerConnection* _server_connection = NULL;
Result(void) Client_createFromConfig(cstr config_path){
Deferral(16);
static Result(void) commandExec(str command, bool* stop);
Client* client = (Client*)malloc(sizeof(Client));
memset(client, 0, sizeof(Client));
bool success = false;
Defer(if(!success) Client_free(client));
static Result(void) askUserNameAndPassword(ClientCredentials** cred){
success = true;
Return RESULT_VALUE(p, client);
}
void Client_free(Client* client){
if(!client)
return;
ClientCredentials_destroy(&client->cred);
ServerConnection_close(client->server_connection);
free(client);
}
static Result(void) commandExec(Client* client, str command, bool* stop);
static Result(void) askUserNameAndPassword(ClientCredentials* cred){
Deferral(8);
char username_buf[128];
@ -33,6 +51,7 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
Return RESULT_ERROR("STDIN is closed", false);
}
username = str_from_cstr(username_buf);
str_trim(&username, true);
if(username.size < USERNAME_SIZE_MIN || username.size > USERNAME_SIZE_MAX){
printf("ERROR: username length (in bytes) must be >= %i and <= %i\n",
USERNAME_SIZE_MIN, USERNAME_SIZE_MAX);
@ -49,6 +68,7 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
Return RESULT_ERROR("STDIN is closed", false);
}
password = str_from_cstr(password_buf);
str_trim(&password, true);
if(password.size < PASSWORD_SIZE_MIN || password.size > PASSWORD_SIZE_MAX){
printf("ERROR: password length (in bytes) must be >= %i and <= %i\n",
PASSWORD_SIZE_MIN, PASSWORD_SIZE_MAX);
@ -56,23 +76,18 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
else break;
}
try(*cred, p, ClientCredentials_create(username, password));
try_void(ClientCredentials_tryConstruct(cred, username, password));
Return RESULT_VOID;
}
Result(void) client_run() {
Deferral(32);
Result(void) Client_run(Client* client) {
Deferral(16);
if(!term_init()){
Return RESULT_ERROR("can't init terminal", false);
}
fputs(greeting_art.data, stdout);
Defer(
ClientCredentials_free(_client_credentials);
ServerConnection_close(_server_connection);
);
try_void(askUserNameAndPassword(&_client_credentials));
try_void(askUserNameAndPassword(&client->cred));
Array(char) input_buf = Array_alloc(char, 10000);
Defer(free(input_buf.data));
@ -90,7 +105,7 @@ Result(void) client_run() {
if(command_input.size == 0)
continue;
ResultVar(void) com_result = commandExec(command_input, &stop);
ResultVar(void) com_result = commandExec(client, command_input, &stop);
if(com_result.error){
str e_str = Error_toStr(com_result.error);
printf("%s\n", e_str.data);
@ -104,7 +119,7 @@ Result(void) client_run() {
#define is_alias(LITERAL) str_equals(command, STR(LITERAL))
static Result(void) commandExec(str command, bool* stop){
static Result(void) commandExec(Client* client, str command, bool* stop){
Deferral(64);
char answer_buf[10000];
const u32 answer_buf_size = sizeof(answer_buf);
@ -126,7 +141,7 @@ static Result(void) commandExec(str command, bool* stop){
);
}
else if (is_alias("j") || is_alias("join")){
ServerConnection_close(_server_connection);
ServerConnection_close(client->server_connection);
puts("Enter server address (ip:port:public_key): ");
if(fgets(answer_buf, answer_buf_size, stdin) == NULL){
@ -136,7 +151,8 @@ static Result(void) commandExec(str command, bool* stop){
str_trim(&new_server_link, true);
printf("connecting to server...\n");
try(_server_connection, p, ServerConnection_open(_client_credentials, new_server_link.data));
try(client->server_connection, p,
ServerConnection_open(&client->cred, new_server_link.data));
printf("connection established\n");
// TODO: request server info
@ -145,7 +161,7 @@ static Result(void) commandExec(str command, bool* stop){
// try log in
// if not registered, request registration and then log in
// call serverConnection_run():
// call Client_runIO():
// function with infinite loop which sends and receives messages
// with navigation across server channels
//
@ -159,9 +175,8 @@ static Result(void) commandExec(str command, bool* stop){
// regiser and then log in
}
else {
Return RESULT_ERROR_FMT("unknown kommand: '%s'\n"
"Use 'h' to see list of avaliable commands",
command.data);
printf("ERROR: unknown command.\n"
"Use 'h' to see list of avaliable commands\n");
}
Return RESULT_VOID;

26
src/client/client.h
View File

@ -3,17 +3,21 @@
#include "cryptography/RSA.h"
#include "network/encrypted_sockets.h"
Result(void) client_run();
typedef struct Client Client;
typedef struct ClientCredentials {
str username;
Array(u8) aes_key;
Array(u8) user_data_key;
Array(u8) token;
AESBlockEncryptor user_data_aes_enc;
AESBlockDecryptor user_data_aes_dec;
} ClientCredentials;
Result(ClientCredentials*) ClientCredentials_create(str username, str password);
void ClientCredentials_free(ClientCredentials* cred);
Result(void) ClientCredentials_tryConstruct(ClientCredentials* cred,
str username, str password);
void ClientCredentials_destroy(ClientCredentials* cred);
typedef struct ServerConnection {
u64 session_id;
@ -24,5 +28,17 @@ typedef struct ServerConnection {
EncryptedSocketTCP sock;
} ServerConnection;
Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_credentials, cstr server_link_cstr);
Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_credentials,
cstr server_link_cstr);
void ServerConnection_close(ServerConnection* conn);
typedef struct Client {
ClientCredentials cred;
ServerConnection* server_connection;
} Client;
Result(void) Client_createFromConfig(cstr config_path);
void Client_free(Client* client);
Result(void) Client_run(Client* client);

12
src/cryptography/RSA.c
View File

@ -11,7 +11,7 @@ Result(void) RSA_generateKeyPair(u32 key_size,
br_rsa_private_key* sk, br_rsa_public_key* pk,
const br_prng_class** rng_vtable_ptr)
{
Deferral(8);
Deferral(4);
bool success = false;
void* sk_buf = malloc(BR_RSA_KBUF_PRIV_SIZE(key_size));
@ -34,7 +34,7 @@ Result(void) RSA_generateKeyPair(u32 key_size,
Result(void) RSA_generateKeyPairFromSystemRandom(u32 key_size,
br_rsa_private_key* sk, br_rsa_public_key* pk)
{
Deferral(8);
Deferral(4);
br_hmac_drbg_context time_based_rng = { .vtable = &br_hmac_drbg_vtable };
rng_init_sha256_seedFromSystem(&time_based_rng.vtable);
try_void(RSA_generateKeyPair(key_size, sk, pk, &time_based_rng.vtable));
@ -44,7 +44,7 @@ Result(void) RSA_generateKeyPairFromSystemRandom(u32 key_size,
Result(void) RSA_generateKeyPairFromPassword(u32 key_size,
br_rsa_private_key* sk, br_rsa_public_key* pk, str password)
{
Deferral(8);
Deferral(4);
br_hmac_drbg_context password_based_rng = { .vtable = &br_hmac_drbg_vtable };
br_hmac_drbg_init(&password_based_rng, &br_sha256_vtable, password.data, password.size);
try_void(RSA_generateKeyPair(key_size, sk, pk, &password_based_rng.vtable));
@ -52,7 +52,7 @@ Result(void) RSA_generateKeyPairFromPassword(u32 key_size,
}
Result(void) RSA_computePublicKey(const br_rsa_private_key* sk, br_rsa_public_key* pk){
Deferral(8);
Deferral(4);
br_rsa_compute_modulus compute_modulus = br_rsa_i31_compute_modulus;
br_rsa_compute_pubexp compute_pubexp = br_rsa_i31_compute_pubexp;
@ -112,7 +112,7 @@ str RSA_serializePublicKey_base64(const br_rsa_public_key* pk){
}
Result(void) RSA_parsePublicKey_base64(cstr src, br_rsa_public_key* pk){
Deferral(8);
Deferral(4);
u32 n_bitlen = 0;
if(sscanf(src, "RSA-Public-%u:", &n_bitlen) != 1){
Return RESULT_ERROR("can't parse key size", false);
@ -142,7 +142,7 @@ Result(void) RSA_parsePublicKey_base64(cstr src, br_rsa_public_key* pk){
}
Result(void) RSA_parsePrivateKey_base64(cstr src, br_rsa_private_key* sk){
Deferral(8);
Deferral(4);
u32 n_bitlen = 0;
if(sscanf(src, "RSA-Private-%u:", &n_bitlen) != 1){
Return RESULT_ERROR("can't parse key size", false);

32
src/db/idb.c
View File

@ -63,7 +63,7 @@ Result(void) validateTableName(str name){
}
Result(void) Table_readHeader(Table* t){
Deferral(8);
Deferral(4);
// seek for start of the file
try_void(file_seek(t->table_file, 0, SeekOrigin_Start));
// read header
@ -72,7 +72,7 @@ Result(void) Table_readHeader(Table* t){
}
Result(void) Table_writeHeader(Table* t){
Deferral(8);
Deferral(4);
// seek for start of the file
try_void(file_seek(t->table_file, 0, SeekOrigin_Start));
// write header
@ -81,20 +81,20 @@ Result(void) Table_writeHeader(Table* t){
}
Result(void) Table_setDirtyBit(Table* t, bool val){
Deferral(8);
Deferral(4);
t->header._dirty_bit = val;
try_void(Table_writeHeader(t));
Return RESULT_VOID;
}
Result(bool) Table_getDirtyBit(Table* t){
Deferral(8);
Deferral(4);
try_void(Table_readHeader(t));
Return RESULT_VALUE(i, t->header._dirty_bit);
}
Result(void) Table_calculateRowCount(Table* t){
Deferral(8);
Deferral(4);
try(i64 file_size, i, file_getSize(t->table_file));
i64 data_size = file_size - sizeof(t->header);
if(data_size % t->header.row_size != 0){
@ -109,7 +109,7 @@ Result(void) Table_calculateRowCount(Table* t){
}
Result(void) Table_validateHeader(Table* t){
Deferral(8);
Deferral(4);
if(t->header.magic.n != TABLE_FILE_MAGIC.n
|| t->header.row_size == 0)
{
@ -147,10 +147,7 @@ Result(IncrementalDB*) idb_open(str db_dir){
IncrementalDB* db = (IncrementalDB*)malloc(sizeof(IncrementalDB));
// if object construction fails, destroy incomplete object
bool success = false;
Defer({
if(!success)
idb_close(db);
});
Defer(if(!success) idb_close(db));
// value of *db must be set to zero or behavior of idb_close will be undefined
memset(db, 0, sizeof(IncrementalDB));
@ -171,7 +168,7 @@ void idb_close(IncrementalDB* db){
}
Result(Table*) idb_getOrCreateTable(IncrementalDB* db, str _table_name, u32 row_size){
Deferral(64);
Deferral(16);
// db lock
try_stderrcode(pthread_mutex_lock(&db->mutex));
Defer(pthread_mutex_unlock(&db->mutex));
@ -188,10 +185,7 @@ Result(Table*) idb_getOrCreateTable(IncrementalDB* db, str _table_name, u32 row_
Table* t = (Table*)malloc(sizeof(Table));
// if object construction fails, destroy incomplete object
bool success = false;
Defer({
if(!success)
Table_close(t);
});
Defer(if(!success) Table_close(t));
// value of *t must be set to zero or behavior of Table_close will be undefined
memset(t, 0, sizeof(Table));
@ -237,7 +231,7 @@ Result(Table*) idb_getOrCreateTable(IncrementalDB* db, str _table_name, u32 row_
}
Result(void) idb_getRows(Table* t, u64 id, void* dst, u64 count){
Deferral(16);
Deferral(8);
// table lock
try_stderrcode(pthread_mutex_lock(&t->mutex));
Defer(pthread_mutex_unlock(&t->mutex));
@ -260,7 +254,7 @@ Result(void) idb_getRows(Table* t, u64 id, void* dst, u64 count){
}
Result(void) idb_updateRows(Table* t, u64 id, const void* src, u64 count){
Deferral(16);
Deferral(8);
// table lock
try_stderrcode(pthread_mutex_lock(&t->mutex));
Defer(pthread_mutex_unlock(&t->mutex));
@ -289,7 +283,7 @@ Result(void) idb_updateRows(Table* t, u64 id, const void* src, u64 count){
}
Result(u64) idb_pushRows(Table* t, const void* src, u64 count){
Deferral(16);
Deferral(8);
// table lock
try_stderrcode(pthread_mutex_lock(&t->mutex));
Defer(pthread_mutex_unlock(&t->mutex));
@ -309,7 +303,7 @@ Result(u64) idb_pushRows(Table* t, const void* src, u64 count){
}
Result(u64) idb_getRowCount(Table* t){
Deferral(8);
Deferral(4);
// table lock
try_stderrcode(pthread_mutex_lock(&t->mutex));
Defer(pthread_mutex_unlock(&t->mutex));

32
src/main.c
View File

@ -6,8 +6,8 @@
#define _DEFAULT_CONFIG_PATH_SERVER "tcp-chat-server.config"
typedef enum ProgramMode {
Client,
Server,
ClientMode,
ServerMode,
RsaGenStdin,
RsaGenRandom,
} ProgramMode;
@ -22,7 +22,7 @@ int main(const int argc, cstr const* argv){
return 1;
}
ProgramMode mode = Client;
ProgramMode mode = ClientMode;
cstr server_endpoint_cstr = NULL;
cstr config_path = NULL;
u32 key_size = 0;
@ -46,12 +46,12 @@ int main(const int argc, cstr const* argv){
Return 0;
}
if(arg_is("-l") || arg_is("--listen")){
if(mode != Client){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = Server;
mode = ServerMode;
if(++argi >= argc){
printfe("ERROR: no endpoint specified\n");
Return 1;
@ -66,7 +66,7 @@ int main(const int argc, cstr const* argv){
config_path = argv[argi];
}
else if(arg_is("--rsa-gen-stdin")){
if(mode != Client){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
@ -81,7 +81,7 @@ int main(const int argc, cstr const* argv){
}
else if(arg_is("--rsa-gen-random")){
if(mode != Client){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
@ -106,17 +106,23 @@ int main(const int argc, cstr const* argv){
Defer(network_deinit());
switch(mode){
case Client: {
if(config_path == NULL)
case ClientMode: {
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_CLIENT;
try_fatal_void(client_run());
try_fatal(Client* client, p, Client_createFromConfig(config_path));
Defer(Client_free(client));
try_fatal_void(Client_run(client));
break;
}
case Server: {
if(config_path == NULL)
case ServerMode: {
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_SERVER;
try_fatal_void(server_run(server_endpoint_cstr, config_path));
try_fatal(Server* server, p, Server_createFromConfig(config_path));
Defer(Server_free(server));
try_fatal_void(Server_run(server, server_endpoint_cstr));
break;
}

5
src/network/encrypted_sockets.c
View File

@ -15,6 +15,8 @@ void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
}
void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr){
if(!ptr)
return;
socket_close(ptr->sock);
free(ptr->recv_buf.data);
free(ptr->send_buf.data);
@ -161,6 +163,9 @@ void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
}
void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr){
if(!ptr)
return;
socket_close(ptr->sock);
free(ptr->recv_buf.data);
free(ptr->send_buf.data);

1
src/network/internal.h
View File

@ -21,6 +21,7 @@
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>

14
src/server/ClientConnection.c
View File

@ -2,25 +2,21 @@
#include "network/tcp-chat-protocol/v1.h"
void ClientConnection_close(ClientConnection* conn){
if(conn == NULL)
if(!conn)
return;
EncryptedSocketTCP_destroy(&conn->sock);
free(conn->session_key.data);
free(conn);
}
Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_credentials,
ConnectionHandlerArgs* args)
Result(ClientConnection*) ClientConnection_accept(ConnectionHandlerArgs* args)
{
Deferral(32);
Deferral(8);
ClientConnection* conn = (ClientConnection*)malloc(sizeof(ClientConnection));
memset(conn, 0, sizeof(*conn));
bool success = false;
Defer(
if(!success)
ClientConnection_close(conn);
);
Defer(if(!success) ClientConnection_close(conn));
conn->client_end = args->client_end;
conn->session_id = args->session_id;
@ -33,7 +29,7 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
// decrypt the rsa messages using server private key
RSADecryptor rsa_dec;
RSADecryptor_construct(&rsa_dec, &server_credentials->rsa_sk);
RSADecryptor_construct(&rsa_dec, &args->server->cred.rsa_sk);
// receive PacketHeader
PacketHeader packet_header = {0};

18
src/server/ServerCredentials.c
View File

@ -1,26 +1,26 @@
#include "server.h"
Result(ServerCredentials*) ServerCredentials_create(cstr rsa_sk_base64, cstr rsa_pk_base64){
Result(void) ServerCredentials_tryConstruct(ServerCredentials* cred,
cstr rsa_sk_base64, cstr rsa_pk_base64)
{
Deferral(4);
ServerCredentials* cred = (ServerCredentials*)malloc(sizeof(ServerCredentials));
memset(cred, 0, sizeof(*cred));
bool success = false;
Defer(
if(!success)
ServerCredentials_free(cred);
);
Defer(if(!success) ServerCredentials_destroy(cred));
try_void(RSA_parsePrivateKey_base64(rsa_sk_base64, &cred->rsa_sk));
try_void(RSA_parsePublicKey_base64(rsa_pk_base64, &cred->rsa_pk));
success = true;
Return RESULT_VALUE(p, cred);
Return RESULT_VOID;
}
void ServerCredentials_free(ServerCredentials* cred){
void ServerCredentials_destroy(ServerCredentials* cred){
if(!cred)
return;
RSA_destroyPrivateKey(&cred->rsa_sk);
RSA_destroyPublicKey(&cred->rsa_pk);
free(cred);
}

87
src/server/server.c
View File

@ -8,15 +8,26 @@
#include "network/tcp-chat-protocol/v1.h"
#include "server/request_handlers/request_handlers.h"
static void* handle_connection(void* _args);
static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_ctx);
static void* handleConnection(void* _args);
static Result(void) try_handleConnection(ConnectionHandlerArgs* args, cstr log_ctx);
void Server_free(Server* server){
if(!server)
return;
free(server->name.data);
free(server->description.data);
ServerCredentials_destroy(&server->cred);
}
static ServerCredentials* _server_credentials = NULL;
static Result(void) parseConfig(cstr config_path){
Deferral(8);
Result(Server*) Server_createFromConfig(cstr config_path){
Deferral(16);
cstr log_ctx = "ServerInit";
logInfo(log_ctx, "parsing config");
Server* server = (Server*)malloc(sizeof(Server));
memset(server, 0, sizeof(Server));
bool success = false;
Defer(if(!success) Server_free(server));
// open file
try(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
@ -28,32 +39,40 @@ static Result(void) parseConfig(cstr config_path){
try_void(file_readBytesArray(config_file, config_buf));
str config_str = Array_castTo_str(config_buf, false);
str sk_base64;
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));
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));
// parse name
str tmp_str = str_null;
try_void(config_findValue(config_str, STR("name"), &tmp_str, true));
server->name = str_copy(tmp_str);
// parse description
try_void(config_findValue(config_str, STR("description"), &tmp_str, true));
server->description = str_copy(tmp_str);
Return RESULT_VOID;
// parse rsa_private_key
try_void(config_findValue(config_str, STR("rsa_private_key"), &tmp_str, true));
char* sk_base64_cstr = str_copy(tmp_str).data;
Defer(free(sk_base64_cstr));
// parse rsa_public_key
try_void(config_findValue(config_str, STR("rsa_public_key"), &tmp_str, true));
char* pk_base64_cstr = str_copy(tmp_str).data;
Defer(free(pk_base64_cstr));
try_void(ServerCredentials_tryConstruct(&server->cred, sk_base64_cstr, pk_base64_cstr));
success = true;
Return RESULT_VALUE(p, server);
}
Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
Deferral(32);
cstr log_ctx = "MainThread";
Result(void) Server_run(Server* server, cstr server_endpoint_cstr){
Deferral(16);
cstr log_ctx = "ListenerThread";
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;
try_void(EndpointIPv4_parse(server_endpoint_cstr, &server_end));
logDebug(log_ctx, "initializing main socket");
try(Socket main_socket, i, socket_open_TCP());
try_void(socket_bind(main_socket, server_end));
try_void(socket_listen(main_socket, 512));
@ -62,24 +81,26 @@ Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
u64 session_id = 1;
while(true){
ConnectionHandlerArgs* args = (ConnectionHandlerArgs*)malloc(sizeof(ConnectionHandlerArgs));
try(args->accepted_socket, i, socket_accept(main_socket, &args->client_end));
args->server = server;
try(args->accepted_socket, i,
socket_accept(main_socket, &args->client_end));
args->session_id = session_id++;
pthread_t conn_thread = {0};
//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_create(&conn_thread, NULL, handleConnection, args));
try_stderrcode(pthread_detach(conn_thread));
}
Return RESULT_VOID;
}
static void* handle_connection(void* _args){
static void* handleConnection(void* _args){
ConnectionHandlerArgs* args = (ConnectionHandlerArgs*)_args;
char log_ctx[64];
sprintf(log_ctx, "Session-" IFWIN("%llx", "%lx"), args->session_id);
ResultVar(void) r = try_handle_connection(args, log_ctx);
ResultVar(void) r = try_handleConnection(args, log_ctx);
if(r.error){
str error_s = Error_toStr(r.error);
logError(log_ctx, "%s", error_s.data);
@ -89,8 +110,8 @@ static void* handle_connection(void* _args){
return NULL;
}
static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_ctx){
Deferral(64);
static Result(void) try_handleConnection(ConnectionHandlerArgs* args, cstr log_ctx){
Deferral(16);
Defer(free(args));
ClientConnection* conn = NULL;
@ -99,7 +120,7 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
logInfo(log_ctx, "session closed");
);
// establish encrypted connection
try(conn, p, ClientConnection_accept(_server_credentials, args));
try(conn, p, ClientConnection_accept(args));
logInfo(log_ctx, "session accepted");
// handle requests

31
src/server/server.h
View File

@ -3,23 +3,17 @@
#include "cryptography/RSA.h"
#include "network/encrypted_sockets.h"
Result(void) server_run(cstr server_endpoint_cstr, cstr config_path);
typedef struct Server Server;
typedef struct ServerCredentials {
br_rsa_private_key rsa_sk;
br_rsa_public_key rsa_pk;
} ServerCredentials;
Result(ServerCredentials*) ServerCredentials_create(cstr rsa_sk_base64, cstr rsa_pk_base64);
Result(void) ServerCredentials_tryConstruct(ServerCredentials* cred,
cstr rsa_sk_base64, cstr rsa_pk_base64);
void ServerCredentials_free(ServerCredentials* cred);
typedef struct ServerInfo {
str name;
str description;
} ServerInfo;
void ServerCredentials_destroy(ServerCredentials* cred);
typedef struct ClientConnection {
@ -32,12 +26,23 @@ typedef struct ClientConnection {
typedef struct ConnectionHandlerArgs {
Server* server;
Socket accepted_socket;
EndpointIPv4 client_end;
u64 session_id;
} ConnectionHandlerArgs;
Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_credentials,
ConnectionHandlerArgs* args);
Result(ClientConnection*) ClientConnection_accept(ConnectionHandlerArgs* args);
void ClientConnection_close(ClientConnection* conn);
void ClientConnection_close(ClientConnection* conn);
typedef struct Server {
str name;
str description;
ServerCredentials cred;
} Server;
Result(Server*) Server_createFromConfig(cstr config_path);
void Server_free(Server* server);
Result(void) Server_run(Server* server, cstr server_endpoint_cstr);