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

implemented ServerPublicInfoResponse and ProgramMode::RandomBytes

Browse Source
This commit is contained in:
Timerix
2025-11-13 02:34:03 +05:00
parent 4add849b9e
commit d53557dbb6
13 changed files with 207 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/server/ClientConnection.c
View File

@@ -24,8 +24,8 @@ Result(ClientConnection*) ClientConnection_accept(ConnectionHandlerArgs* args)
conn->session_key = Array_alloc_size(AES_SESSION_KEY_SIZE);
// correct session key will be received from client later
Array_memset(conn->session_key, 0);
EncryptedSocketTCP_construct(&conn->sock, args->accepted_socket, NETWORK_BUFFER_SIZE, conn->session_key);
try_void(socket_TCP_enableAliveChecks_default(args->accepted_socket));
EncryptedSocketTCP_construct(&conn->sock, args->accepted_socket_tcp, NETWORK_BUFFER_SIZE, conn->session_key);
try_void(socket_TCP_enableAliveChecks_default(args->accepted_socket_tcp));
// decrypt the rsa messages using server private key
RSADecryptor rsa_dec;

14
src/server/request_handlers/ServerPublicInfo.c
View File

@@ -11,6 +11,20 @@ declare_RequestHandler(ServerPublicInfo)
//TODO: try find requested info
Array(u8) content;
switch(req.property){
default:
try(char* err_msg, p, sendErrorMessage(conn, res_head,
"unknown ServerPublicInfo property %u", req.property));
logWarn(log_ctx, "%s", err_msg);
Return RESULT_VOID;
break;
case ServerPublicInfo_Name:
content = str_castTo_Array(server->name);
break;
case ServerPublicInfo_Description:
content = str_castTo_Array(server->name);
break;
}
PacketHeader_construct(res_head,
PROTOCOL_VERSION, PacketType_ServerPublicInfoResponse, content.size);

12
src/server/request_handlers/request_handlers.h
View File

@@ -4,20 +4,20 @@
#include "log.h"
Result(char*) __sendErrorMessage(ClientConnection* conn, PacketHeader* req_head, PacketHeader* res_head,
u32 msg_buf_size, cstr format, va_list argv);
Result(char*) sendErrorMessage(ClientConnection* conn, PacketHeader* req_head, PacketHeader* res_head,
u32 msg_buf_size, cstr format, ...) ATTRIBUTE_CHECK_FORMAT_PRINTF(5, 6);
Result(char*) __sendErrorMessage_va(ClientConnection* conn, PacketHeader* res_head,
cstr format, va_list argv);
Result(char*) sendErrorMessage(ClientConnection* conn, PacketHeader* res_head,
cstr format, ...) ATTRIBUTE_CHECK_FORMAT_PRINTF(3, 4);
#define declare_RequestHandler(TYPE) \
Result(void) handleRequest_##TYPE( \
cstr log_ctx, cstr req_type_name, \
Server* server, cstr log_ctx, cstr req_type_name, \
ClientConnection* conn, PacketHeader* req_head, PacketHeader* res_head)
#define case_handleRequest(TYPE) \
case PacketType_##TYPE##Request:\
try_void(handleRequest_##TYPE(log_ctx, #TYPE, conn, &req_head, &res_head));\
try_void(handleRequest_##TYPE(args->server, log_ctx, #TYPE, conn, &req_head, &res_head));\
break;
declare_RequestHandler(ServerPublicInfo);

21
src/server/request_handlers/send_error.c
View File

@@ -1,17 +1,18 @@
#include "request_handlers.h"
Result(char*) __sendErrorMessage(ClientConnection* conn, PacketHeader* req_head, PacketHeader* res_head,
u32 msg_buf_size, cstr format, va_list argv)
Result(char*) __sendErrorMessage_va(ClientConnection* conn, PacketHeader* res_head,
cstr format, va_list argv)
{
Deferral(4);
(void)req_head;
//TODO: limit ErrorMessage size to fit into EncryptedSocketTCP.internal_buffer_size
Array(u8) err_buf = Array_alloc(u8, msg_buf_size);
Array(u8) err_buf;
err_buf.data = vsprintf_malloc(format, argv);
err_buf.size = strlen(err_buf.data);
//limit ErrorMessage size to fit into EncryptedSocketTCP.internal_buffer_size
if(err_buf.size > NETWORK_BUFFER_SIZE)
err_buf.size = NETWORK_BUFFER_SIZE;
bool err_complete = false;
Defer(if(!err_complete) free(err_buf.data));
vsprintf(err_buf.data, format, argv);
err_buf.size = strlen(err_buf.data);
PacketHeader_construct(res_head,
PROTOCOL_VERSION, PacketType_ErrorMessage, err_buf.size);
@@ -22,12 +23,12 @@ Result(char*) __sendErrorMessage(ClientConnection* conn, PacketHeader* req_head,
Return RESULT_VALUE(p, err_buf.data);
}
Result(char*) sendErrorMessage(ClientConnection* conn, PacketHeader* req_head, PacketHeader* res_head,
u32 msg_buf_size, cstr format, ...)
Result(char*) sendErrorMessage(ClientConnection* conn, PacketHeader* res_head,
cstr format, ...)
{
va_list argv;
va_start(argv, format);
ResultVar(char*) err_msg = __sendErrorMessage(conn, req_head, res_head, msg_buf_size, format, argv);
ResultVar(char*) err_msg = __sendErrorMessage_va(conn, res_head, format, argv);
va_end(argv);
return err_msg;
}

36
src/server/server.c
View File

@@ -1,7 +1,7 @@
#include <pthread.h>
#include "tlibc/filesystem.h"
#include "tlibc/time.h"
#include "db/idb.h"
#include "tlibc/base64.h"
#include "server.h"
#include "config.h"
#include "log.h"
@@ -17,6 +17,7 @@ void Server_free(Server* server){
free(server->name.data);
free(server->description.data);
ServerCredentials_destroy(&server->cred);
idb_close(server->db);
}
Result(Server*) Server_createFromConfig(cstr config_path){
@@ -48,6 +49,12 @@ Result(Server*) Server_createFromConfig(cstr config_path){
try_void(config_findValue(config_str, STR("description"), &tmp_str, true));
server->description = str_copy(tmp_str);
// parse local_address
try_void(config_findValue(config_str, STR("local_address"), &tmp_str, true));
char* local_end_cstr = str_copy(tmp_str).data;
Defer(free(local_end_cstr));
try_void(EndpointIPv4_parse(local_end_cstr, &server->local_end));
// 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;
@@ -60,29 +67,37 @@ Result(Server*) Server_createFromConfig(cstr config_path){
try_void(ServerCredentials_tryConstruct(&server->cred, sk_base64_cstr, pk_base64_cstr));
// parse db_key
try_void(config_findValue(config_str, STR("db_aes_key"), &tmp_str, true));
Array(u8) db_aes_key = Array_alloc_size(base64_decodedSize(tmp_str.data, tmp_str.size));
base64_decode(tmp_str.data, tmp_str.size, db_aes_key.data);
// parse db_dir and open db
try_void(config_findValue(config_str, STR("db_dir"), &tmp_str, true));
try(server->db, p, idb_open(tmp_str, db_aes_key));
success = true;
Return RESULT_VALUE(p, server);
}
Result(void) Server_run(Server* server, cstr server_endpoint_cstr){
Result(void) Server_run(Server* server){
Deferral(16);
cstr log_ctx = "ListenerThread";
logInfo(log_ctx, "starting server");
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_bind(main_socket, server->local_end));
try_void(socket_listen(main_socket, 512));
logInfo(log_ctx, "server is listening at %s", server_endpoint_cstr);
str local_end_str = EndpointIPv4_toStr(server->local_end);
Defer(free(local_end_str.data));
logInfo(log_ctx, "server is listening at %s", local_end_str.data);
u64 session_id = 1;
while(true){
ConnectionHandlerArgs* args = (ConnectionHandlerArgs*)malloc(sizeof(ConnectionHandlerArgs));
args->server = server;
try(args->accepted_socket, i,
try(args->accepted_socket_tcp, i,
socket_accept(main_socket, &args->client_end));
args->session_id = session_id++;
pthread_t conn_thread = {0};
@@ -137,9 +152,8 @@ static Result(void) try_handleConnection(ConnectionHandlerArgs* args, cstr log_c
// send error message and close connection
default:
try(char* err_msg, p,
sendErrorMessage(
conn, &req_head, &res_head,
128, "Received unexpected packet of type %u",
sendErrorMessage(conn, &res_head,
"Received unexpected packet of type %u",
req_head.type
)
);

7
src/server/server.h
View File

@@ -2,6 +2,7 @@
#include "cryptography/AES.h"
#include "cryptography/RSA.h"
#include "network/encrypted_sockets.h"
#include "db/idb.h"
typedef struct Server Server;
@@ -27,7 +28,7 @@ typedef struct ClientConnection {
typedef struct ConnectionHandlerArgs {
Server* server;
Socket accepted_socket;
Socket accepted_socket_tcp;
EndpointIPv4 client_end;
u64 session_id;
} ConnectionHandlerArgs;
@@ -40,9 +41,11 @@ void ClientConnection_close(ClientConnection* conn);
typedef struct Server {
str name;
str description;
EndpointIPv4 local_end;
ServerCredentials cred;
IncrementalDB* db;
} Server;
Result(Server*) Server_createFromConfig(cstr config_path);
void Server_free(Server* server);
Result(void) Server_run(Server* server, cstr server_endpoint_cstr);
Result(void) Server_run(Server* server);