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
Download Patch File Download Diff File Expand all files Collapse all files

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