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

added internal buffers to encrypted sockets

Browse Source
This commit is contained in:
Timerix 2025-11-06 22:27:41 +05:00
parent 375dd842d4
commit d36fe9e5b3
10 changed files with 233 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/client/ServerConnection.c
View File

@ -5,7 +5,7 @@ void ServerConnection_close(ServerConnection* conn){
if(conn == NULL)
return;
RSA_destroyPublicKey(&conn->server_pk);
socket_close(conn->sock.sock);
EncryptedSocketTCP_destroy(&conn->sock);
free(conn->session_key.data);
free(conn);
}
@ -63,78 +63,80 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
try(Socket _s, i, socket_open_TCP());
// TODO: set socket timeout to 5 seconds
try_void(socket_connect(_s, conn->server_end));
EncryptedSocketTCP_construct(&conn->sock, _s, conn->session_key);
EncryptedSocketTCP_construct(&conn->sock, _s, NETWORK_BUFFER_SIZE, conn->session_key);
Array(u8) enc_buf = Array_alloc_size(8*1024);
Defer(free(enc_buf.data));
Array(u8) dec_buf = Array_alloc_size(8*1024);
Defer(free(dec_buf.data));
u32 enc_size = 0, dec_size = 0;
Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
Defer(free(buffer.data));
// construct ClientHandshake in dec_buf
try_void(ClientHandshake_tryConstruct((ClientHandshake*)dec_buf.data, conn->session_key));
dec_size = sizeof(ClientHandshake);
// encrypt by server public key
try(enc_size, u,
// construct PacketHeader and ClientHandshake in buffer
PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
PacketType_ClientHandshake, sizeof(ClientHandshake));
ClientHandshake_construct(
Array_sliceAfter(buffer, sizeof(PacketHeader)).data,
conn->session_key);
u32 header_and_message_size = sizeof(PacketHeader) + sizeof(ClientHandshake);
// encrypt message by server public key
Array(u8) bufferPart_encryptedClientHandshake = Array_sliceAfter(buffer, header_and_message_size);
try(u32 rsa_enc_size, u,
RSAEncryptor_encrypt(
&conn->rsa_enc,
Array_sliceBefore(dec_buf, dec_size),
enc_buf
&conn->rsa_enc,
Array_sliceBefore(buffer, header_and_message_size),
bufferPart_encryptedClientHandshake
)
);
try_void(socket_send(conn->sock.sock, Array_sliceBefore(enc_buf, enc_size)));
bufferPart_encryptedClientHandshake.size = rsa_enc_size;
// send encrypted message
try_void(socket_send(conn->sock.sock, bufferPart_encryptedClientHandshake));
// receive server response
enc_size = AESStreamEncryptor_calcDstSize(sizeof(PacketHeader));
try(dec_size, u,
try_void(
EncryptedSocketTCP_recv(&conn->sock,
Array_sliceBefore(enc_buf, enc_size),
dec_buf,
Array_sliceBefore(buffer, sizeof(PacketHeader)),
SocketRecvFlag_WaitAll
)
);
try_assert(dec_size == sizeof(PacketHeader));
PacketHeader* packet_header = dec_buf.data;
PacketHeader* packet_header = buffer.data;
try_void(PacketHeader_validateMagic(packet_header));
// handle server response
switch(packet_header->type){
case PacketType_ErrorMessage: {
Array(u8) err_buf = Array_alloc_size(packet_header->content_size + 1);
u32 err_msg_size = packet_header->content_size;
if(err_msg_size > conn->sock.recv_buf.size)
err_msg_size = conn->sock.recv_buf.size;
Array(u8) err_buf = Array_alloc_size(err_msg_size + 1);
bool err_msg_completed = false;
Defer(
if(!err_msg_completed)
free(err_buf.data);
);
// receive error message of length packet_header->content_size
enc_size = packet_header->content_size;
if(enc_size > enc_buf.size)
enc_size = enc_buf.size;
// receive error message
try_void(
EncryptedSocketTCP_recv(
&conn->sock,
Array_sliceBefore(enc_buf, enc_size),
err_buf,
Array_sliceBefore(err_buf, err_msg_size),
SocketRecvFlag_WaitAll
)
);
((u8*)err_buf.data)[enc_size] = 0;
((u8*)err_buf.data)[err_msg_size] = 0;
err_msg_completed = true;
Return RESULT_ERROR((char*)err_buf.data, true);
}
case PacketType_ServerHandshake: {
enc_size = sizeof(ServerHandshake) - sizeof(PacketHeader);
Array(u8) bufferPart_ServerHandshake = {
.data = (u8*)buffer.data + sizeof(PacketHeader),
.size = sizeof(ServerHandshake)
};
try_void(
EncryptedSocketTCP_recv(
&conn->sock,
Array_sliceBefore(enc_buf, enc_size),
dec_buf,
bufferPart_ServerHandshake,
SocketRecvFlag_WaitAll
)
);
ServerHandshake* server_handshake = dec_buf.data;
ServerHandshake* server_handshake = bufferPart_ServerHandshake.data;
conn->session_id = server_handshake->session_id;
break;
}

5
src/cryptography/AES.c
View File

@ -176,13 +176,14 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const
Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr, Array(u8) src, Array(u8) dst){
Deferral(4);
u32 decrypted_size = __AESStreamDecryptor_calcDstSize(src.size);
try_assert(dst.size >= decrypted_size);
// if it is the beginning of the stream, read IV
if(ptr->block_counter == 0){
__Array_readNext(ptr->iv, &src, __AES_STREAM_IV_SIZE);
}
// size without IV
u32 decrypted_size = src.size;
try_assert(dst.size >= decrypted_size);
// decrypt full buffers
while(src.size > __AES_BUFFER_SIZE){

4
src/cryptography/AES.h
View File

@ -89,7 +89,7 @@ typedef struct AESStreamEncryptor {
void AESStreamEncryptor_construct(AESStreamEncryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class);
/// use this only at the beginning of the stream
#define AESStreamEncryptor_calcDstSize(src_size) (src_size + __AES_BLOCK_IV_SIZE)
#define AESStreamEncryptor_calcDstSize(src_size) (src_size + __AES_STREAM_IV_SIZE)
/// @brief If ptr->block_counter == 0, writes random IV to `dst`. After that writes encrypted data to dst.
/// @param src array of any size
@ -119,5 +119,3 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const
/// @param dst array of size >= src.size
/// @return size of decrypted data
Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr, Array(u8) src, Array(u8) dst);
#define __AESStreamDecryptor_calcDstSize(src_size) (src_size - __AES_BLOCK_IV_SIZE)

135
src/network/encrypted_sockets.c
View File

@ -1,63 +1,134 @@
#include "encrypted_sockets.h"
void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, Socket sock, Array(u8) aes_key)
void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
{
ptr->sock = sock;
AESStreamEncryptor_construct(&ptr->enc, aes_key, AESStream_DEFAULT_CLASS);
AESStreamDecryptor_construct(&ptr->dec, aes_key, AESStream_DEFAULT_CLASS);
ptr->recv_buf = Array_alloc_size(crypto_buffer_size);
ptr->send_buf = Array_alloc_size(crypto_buffer_size);
}
void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr){
socket_close(ptr->sock);
free(ptr->recv_buf.data);
free(ptr->send_buf.data);
}
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) decrypted_buf, Array(u8) encrypted_buf)
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) buffer)
{
Deferral(4);
try(u32 encrypted_size, u, AESStreamEncryptor_encrypt(&ptr->enc, decrypted_buf, encrypted_buf));
encrypted_buf.size = encrypted_size;
try_void(socket_send(ptr->sock, encrypted_buf));
Deferral(1);
try(u32 encrypted_size, u,
AESStreamEncryptor_encrypt(
&ptr->enc,
buffer,
ptr->send_buf
)
);
try_void(
socket_send(
ptr->sock,
Array_sliceBefore(ptr->send_buf, encrypted_size)
)
);
Return RESULT_VOID;
}
Result(i32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) encrypted_buf, Array(u8) decrypted_buf,
SocketRecvFlag flags)
Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) buffer, SocketRecvFlag flags)
{
Deferral(4);
try(i32 received_size, i, socket_recv(ptr->sock, encrypted_buf, flags));
//TODO: return error if WaitAll flag was set and socket closed before filling the buffer
//TODO: return something when received_size == 0 (socket has been closed)
encrypted_buf.size = received_size;
try(i32 decrypted_size, u, AESStreamDecryptor_decrypt(&ptr->dec, encrypted_buf, decrypted_buf));
Return RESULT_VALUE(i, decrypted_size);
Deferral(1);
u32 size_to_receive = buffer.size;
if(ptr->dec.block_counter == 0){
// There is some metadata at the beginning of AES stream
size_to_receive = AESStreamEncryptor_calcDstSize(size_to_receive);
}
try(i32 received_size, i,
socket_recv(
ptr->sock,
Array_sliceBefore(ptr->recv_buf, size_to_receive),
flags
)
);
try(u32 decrypted_size, u,
AESStreamDecryptor_decrypt(
&ptr->dec,
Array_sliceBefore(ptr->recv_buf, received_size),
buffer
)
);
Return RESULT_VALUE(u, decrypted_size);
}
void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, Socket sock, Array(u8) aes_key)
void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
{
ptr->sock = sock;
AESBlockEncryptor_construct(&ptr->enc, aes_key, AESBlockEncryptor_DEFAULT_CLASS);
AESBlockDecryptor_construct(&ptr->dec, aes_key, AESBlockDecryptor_DEFAULT_CLASS);
ptr->recv_buf = Array_alloc_size(crypto_buffer_size);
ptr->send_buf = Array_alloc_size(crypto_buffer_size);
}
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) decrypted_buf, Array(u8) encrypted_buf,
EndpointIPv4 remote_end)
void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr){
socket_close(ptr->sock);
free(ptr->recv_buf.data);
free(ptr->send_buf.data);
}
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) buffer, EndpointIPv4 remote_end)
{
Deferral(4);
try(u32 encrypted_size, u, AESBlockEncryptor_encrypt(&ptr->enc, decrypted_buf, encrypted_buf));
encrypted_buf.size = encrypted_size;
try_void(socket_sendto(ptr->sock, encrypted_buf, remote_end));
Deferral(1);
try(u32 encrypted_size, u,
AESBlockEncryptor_encrypt(
&ptr->enc,
buffer,
ptr->send_buf
)
);
try_void(
socket_sendto(
ptr->sock,
Array_sliceBefore(ptr->send_buf, encrypted_size),
remote_end
)
);
Return RESULT_VOID;
}
Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
Array(u8) encrypted_buf, Array(u8) decrypted_buf,
SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end)
Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end)
{
Deferral(4);
try(i32 received_size, i, socket_recvfrom(ptr->sock, encrypted_buf, flags, remote_end));
encrypted_buf.size = received_size;
try(i32 decrypted_size, u, AESBlockDecryptor_decrypt(&ptr->dec, encrypted_buf, decrypted_buf));
Return RESULT_VALUE(i, decrypted_size);
Deferral(1);
// There is some metadata at the start of each AES block
u32 size_to_receive = AESBlockEncryptor_calcDstSize(buffer.size);
try(i32 received_size, i,
socket_recvfrom(
ptr->sock,
Array_sliceBefore(ptr->recv_buf, size_to_receive),
flags,
remote_end
)
);
try(u32 decrypted_size, u,
AESBlockDecryptor_decrypt(
&ptr->dec,
Array_sliceBefore(ptr->recv_buf, received_size),
buffer
)
);
Return RESULT_VALUE(u, decrypted_size);
}

36
src/network/encrypted_sockets.h
View File

@ -10,16 +10,21 @@ typedef struct EncryptedSocketTCP {
Socket sock;
AESStreamEncryptor enc;
AESStreamDecryptor dec;
Array(u8) send_buf;
Array(u8) recv_buf;
} EncryptedSocketTCP;
void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, Socket sock, Array(u8) aes_key);
void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key);
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) decrypted_buf, Array(u8) encrypted_buf);
/// closes the socket
void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr);
Result(void) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) encrypted_buf, Array(u8) decrypted_buf,
SocketRecvFlag flags);
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) buffer);
Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) buffer, SocketRecvFlag flags);
//////////////////////////////////////////////////////////////////////////////
@ -30,15 +35,18 @@ typedef struct EncryptedSocketUDP {
Socket sock;
AESBlockEncryptor enc;
AESBlockDecryptor dec;
Array(u8) send_buf;
Array(u8) recv_buf;
} EncryptedSocketUDP;
void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, Socket sock, Array(u8) aes_key);
void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key);
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) decrypted_buf, Array(u8) encrypted_buf,
EndpointIPv4 remote_end);
/// closes the socket
void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr);
Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
Array(u8) encrypted_buf, Array(u8) decrypted_buf,
SocketRecvFlag flags,
NULLABLE(EndpointIPv4*) remote_end);
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) buffer, EndpointIPv4 remote_end);
Result(u32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end);

28
src/network/socket.c
View File

@ -61,16 +61,24 @@ Result(void) socket_connect(Socket s, EndpointIPv4 remote_end){
Result(void) socket_send(Socket s, Array(u8) buffer){
i32 r = send(s, buffer.data, buffer.size, 0);
if(r < 0)
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if((u32)r != buffer.size){
return RESULT_ERROR_FMT("Socket was unable to send data");
}
return RESULT_VOID;
}
Result(void) socket_sendto(Socket s, Array(u8) buffer, EndpointIPv4 dst){
struct sockaddr_in sockaddr = EndpointIPv4_toSockaddr(dst);
i32 r = sendto(s, buffer.data, buffer.size, 0, (void*)&sockaddr, sizeof(sockaddr));
if(r < 0)
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if((u32)r != buffer.size){
return RESULT_ERROR_FMT("Socket was unable to send data");
}
return RESULT_VOID;
}
@ -85,8 +93,13 @@ static inline int SocketRecvFlags_toStd(SocketRecvFlag flags){
Result(i32) socket_recv(Socket s, Array(u8) buffer, SocketRecvFlag flags){
i32 r = recv(s, buffer.data, buffer.size, SocketRecvFlags_toStd(flags));
if(r < 0)
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
{
return RESULT_ERROR("Socket closed", false);
}
return RESULT_VALUE(i, r);
}
@ -95,9 +108,14 @@ Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NU
i32 sockaddr_size = sizeof(remote_addr);
i32 r = recvfrom(s, buffer.data, buffer.size, SocketRecvFlags_toStd(flags),
(struct sockaddr*)&remote_addr, (void*)&sockaddr_size);
if(r < 0)
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
{
return RESULT_ERROR("Socket closed", false);
}
//TODO: add IPV6 support (struct sockaddr_in6)
assert(sockaddr_size == sizeof(remote_addr));

9
src/network/tcp-chat-protocol/v1.c
View File

@ -1,14 +1,9 @@
#include "v1.h"
Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, Array(u8) session_key){
Deferral(1);
try_assert(session_key.size == AES_SESSION_KEY_SIZE);
PacketHeader_construct(&ptr->header, PROTOCOL_VERSION, PacketType_ClientHandshake, session_key.size);
memcpy(ptr->session_key, session_key.data, session_key.size);
Return RESULT_VOID;
void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key){
memcpy(ptr->session_key, session_key.data, sizeof(ptr->session_key));
}
void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id){
PacketHeader_construct(&ptr->header, PROTOCOL_VERSION, PacketType_ServerHandshake, sizeof(session_id));
ptr->session_id = session_id;
}

7
src/network/tcp-chat-protocol/v1.h
View File

@ -3,7 +3,7 @@
#include "network/tcp-chat-protocol/constant.h"
#define PROTOCOL_VERSION 1 /* 1.0.0 */
#define NETWORK_BUFFER_SIZE 65536
typedef enum PacketType {
PacketType_Invalid,
@ -14,21 +14,18 @@ typedef enum PacketType {
typedef struct ErrorMessage {
PacketHeader header;
/* content stream of size `header.content_size` */
} ErrorMessage;
typedef struct ClientHandshake {
PacketHeader header;
u8 session_key[AES_SESSION_KEY_SIZE];
} ClientHandshake;
Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, Array(u8) session_key);
void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key);
typedef struct ServerHandshake {
PacketHeader header;
u64 session_id;
} ServerHandshake;

51
src/server/ClientConnection.c
View File

@ -4,7 +4,7 @@
void ClientConnection_close(ClientConnection* conn){
if(conn == NULL)
return;
socket_close(conn->sock.sock);
EncryptedSocketTCP_destroy(&conn->sock);
free(conn->session_key.data);
free(conn);
}
@ -26,19 +26,21 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
conn->session_id = session_id;
conn->session_key = Array_alloc_size(AES_SESSION_KEY_SIZE);
Array(u8) enc_buf = Array_alloc_size(8*1024);
Defer(free(enc_buf.data));
Array(u8) dec_buf = Array_alloc_size(8*1024);
Defer(free(dec_buf.data));
u32 enc_size = 0, dec_size = 0;
Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
Defer(free(buffer.data));
// TODO: set socket timeout to 5 seconds
// receive message encrypted by server public key
try(enc_size, u,
u32 header_and_message_size = sizeof(PacketHeader) + sizeof(ClientHandshake);
Array(u8) bufferPart_encryptedClientHandshake = {
.data = (u8*)buffer.data + header_and_message_size,
.size = server_credentials->rsa_pk.nlen
};
try_void(
socket_recv(
sock_tcp,
Array_sliceBefore(enc_buf, server_credentials->rsa_pk.nlen),
bufferPart_encryptedClientHandshake,
SocketRecvFlag_WaitAll
)
);
@ -46,42 +48,47 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
// decrypt the message using server private key
RSADecryptor rsa_dec;
RSADecryptor_construct(&rsa_dec, &server_credentials->rsa_sk);
try(dec_size, u,
try(u32 rsa_dec_size, u,
RSADecryptor_decrypt(
&rsa_dec,
Array_sliceBefore(enc_buf, enc_size),
dec_buf
bufferPart_encryptedClientHandshake,
buffer
)
);
// validate client handshake
if(dec_size != sizeof(ClientHandshake)){
if(rsa_dec_size != header_and_message_size){
Return RESULT_ERROR_FMT(
"decrypted message (size: %u) is not a ClientHandshake (size: %u)",
dec_size, (u32)sizeof(ClientHandshake)
rsa_dec_size, header_and_message_size
);
}
ClientHandshake* client_handshake = dec_buf.data;
try_void(PacketHeader_validateMagic(&client_handshake->header));
if(client_handshake->header.type != PacketType_ClientHandshake){
PacketHeader* packet_header = buffer.data;
ClientHandshake* client_handshake = Array_sliceAfter(buffer, sizeof(PacketHeader)).data;
try_void(PacketHeader_validateMagic(packet_header));
if(packet_header->type != PacketType_ClientHandshake){
Return RESULT_ERROR_FMT(
"received message of unexpected type: %u",
client_handshake->header.type
packet_header->type
);
}
// use received session key
memcpy(conn->session_key.data, client_handshake->session_key, conn->session_key.size);
EncryptedSocketTCP_construct(&conn->sock, sock_tcp, conn->session_key);
EncryptedSocketTCP_construct(&conn->sock, sock_tcp, NETWORK_BUFFER_SIZE, conn->session_key);
// construct ServerHandshake in dec_buf
ServerHandshake_construct((ServerHandshake*)dec_buf.data, session_id);
// construct PacketHeader and ServerHandshake in buffer
PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
PacketType_ServerHandshake, sizeof(ServerHandshake));
ServerHandshake_construct(
Array_sliceAfter(buffer, sizeof(PacketHeader)).data,
session_id);
// send ServerHandshake over encrypted TCP socket
header_and_message_size = sizeof(PacketHeader) + sizeof(ServerHandshake);
try_void(
EncryptedSocketTCP_send(
&conn->sock,
Array_sliceBefore(dec_buf, sizeof(ServerHandshake)),
enc_buf
Array_sliceBefore(buffer, header_and_message_size)
)
);

14
src/server/server.c
View File

@ -4,6 +4,7 @@
#include "server.h"
#include "config.h"
#include "log.h"
#include "network/tcp-chat-protocol/v1.h"
typedef struct ConnectionHandlerArgs {
Socket accepted_socket;
@ -88,7 +89,10 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
Defer(free(args));
ClientConnection* conn = NULL;
Defer(ClientConnection_close(conn));
Defer(
ClientConnection_close(conn);
logInfo(log_ctx, "session closed");
);
// establish encrypted connection
try(conn, p,
ClientConnection_accept(
@ -98,10 +102,16 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
args->session_id
)
);
logDebug(log_ctx, "session accepted");
logInfo(log_ctx, "session accepted");
// handle requests
// Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
// Defer(free(buffer.data));
// u32 dec_size = 0;
while(true){
sleepMsec(10);
}