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

refactored tlibc collections

Browse Source
This commit is contained in:
Timerix
2025-11-25 16:31:58 +05:00
parent 7a3808ba59
commit 8bc98a321d
32 changed files with 294 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/network/encrypted_sockets.c
View File

@@ -10,16 +10,16 @@ void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
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);
ptr->recv_buf = Array_u8_alloc(crypto_buffer_size);
ptr->send_buf = Array_u8_alloc(crypto_buffer_size);
}
void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr){
if(!ptr)
return;
socket_close(ptr->sock);
Array_free(ptr->recv_buf);
Array_free(ptr->send_buf);
Array_u8_destroy(&ptr->recv_buf);
Array_u8_destroy(&ptr->send_buf);
}
void EncryptedSocketTCP_changeKey(EncryptedSocketTCP* ptr, Array(u8) aes_key){
@@ -42,11 +42,11 @@ Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
try_void(
socket_send(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size)
Array_u8_sliceTo(ptr->send_buf, encrypted_size)
)
);
// printf("SEND data_size: %u, enc_size: %u\n", buffer.size, encrypted_size);
// printf("SEND data_size: %u, enc_size: %u\n", buffer.len, encrypted_size);
Return RESULT_VOID;
}
@@ -55,7 +55,7 @@ Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
{
Deferral(1);
u32 size_to_receive = buffer.size;
u32 size_to_receive = buffer.len;
if(ptr->dec.block_counter == 0){
// There is some metadata at the beginning of AES stream
size_to_receive = AESStreamEncryptor_calcDstSize(size_to_receive);
@@ -63,14 +63,14 @@ Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
try(i32 received_size, i,
socket_recv(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
Array_u8_sliceTo(ptr->recv_buf, size_to_receive),
flags
)
);
try(u32 decrypted_size, u,
AESStreamDecryptor_decrypt(
&ptr->dec,
Array_sliceTo(ptr->recv_buf, received_size),
Array_u8_sliceTo(ptr->recv_buf, received_size),
buffer
)
);
@@ -94,11 +94,11 @@ Result(void) EncryptedSocketTCP_sendRSA(EncryptedSocketTCP* ptr,
try_void(
socket_send(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size)
Array_u8_sliceTo(ptr->send_buf, encrypted_size)
)
);
// printf("SEND-RSA data_size: %u, enc_size: %u\n", buffer.size, encrypted_size);
// printf("SEND-RSA data_size: %u, enc_size: %u\n", buffer.len, encrypted_size);
Return RESULT_VOID;
}
@@ -119,30 +119,30 @@ Result(u32) EncryptedSocketTCP_recvRSA(EncryptedSocketTCP* ptr,
try(i32 received_size, i,
socket_recv(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
Array_u8_sliceTo(ptr->recv_buf, size_to_receive),
flags
)
);
try(u32 decrypted_size, u,
RSADecryptor_decrypt(
rsa_dec,
Array_sliceTo(ptr->recv_buf, received_size)
Array_u8_sliceTo(ptr->recv_buf, received_size)
)
);
if(fill_whole_buffer){
if(decrypted_size != buffer.size){
if(decrypted_size != buffer.len){
Return RESULT_ERROR_FMT(
"SocketRecvFlag_WholeBuffer is set, "
"but decrypted_size (%u) != buffer.size (%u)",
decrypted_size, buffer.size
"but decrypted_size (%u) != buffer.len (%u)",
decrypted_size, buffer.len
);
}
}
else if(decrypted_size > buffer.size){
else if(decrypted_size > buffer.len){
Return RESULT_ERROR_FMT(
"decrypted_size (%u) > buffer.size (%u)",
decrypted_size, buffer.size
"decrypted_size (%u) > buffer.len (%u)",
decrypted_size, buffer.len
);
}
@@ -163,16 +163,16 @@ void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
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);
ptr->recv_buf = Array_u8_alloc(crypto_buffer_size);
ptr->send_buf = Array_u8_alloc(crypto_buffer_size);
}
void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr){
if(!ptr)
return;
socket_close(ptr->sock);
Array_free(ptr->recv_buf);
Array_free(ptr->send_buf);
Array_u8_destroy(&ptr->recv_buf);
Array_u8_destroy(&ptr->send_buf);
}
void EncryptedSocketUDP_changeKey(EncryptedSocketUDP* ptr, Array(u8) aes_key){
@@ -195,7 +195,7 @@ Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
try_void(
socket_sendto(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size),
Array_u8_sliceTo(ptr->send_buf, encrypted_size),
remote_end
)
);
@@ -209,11 +209,11 @@ Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
Deferral(1);
// There is some metadata at the start of each AES block
u32 size_to_receive = AESBlockEncryptor_calcDstSize(buffer.size);
u32 size_to_receive = AESBlockEncryptor_calcDstSize(buffer.len);
try(i32 received_size, i,
socket_recvfrom(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
Array_u8_sliceTo(ptr->recv_buf, size_to_receive),
flags,
remote_end
)
@@ -221,7 +221,7 @@ Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
try(u32 decrypted_size, u,
AESBlockDecryptor_decrypt(
&ptr->dec,
Array_sliceTo(ptr->recv_buf, received_size),
Array_u8_sliceTo(ptr->recv_buf, received_size),
buffer
)
);

8
src/network/encrypted_sockets.h
View File

@@ -28,14 +28,14 @@ Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
#define EncryptedSocketTCP_sendStruct(socket, structPtr)\
EncryptedSocketTCP_send(socket,\
Array_construct_size(structPtr, sizeof(*structPtr)))
struct_castTo_Array_u8(structPtr))
Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) buffer, SocketRecvFlag flags);
#define EncryptedSocketTCP_recvStruct(socket, structPtr)\
EncryptedSocketTCP_recv(socket,\
Array_construct_size(structPtr, sizeof(*structPtr)),\
struct_castTo_Array_u8(structPtr),\
SocketRecvFlag_WholeBuffer)
Result(void) EncryptedSocketTCP_sendRSA(EncryptedSocketTCP* ptr,
@@ -43,14 +43,14 @@ Result(void) EncryptedSocketTCP_sendRSA(EncryptedSocketTCP* ptr,
#define EncryptedSocketTCP_sendStructRSA(socket, rsa_enc, structPtr)\
EncryptedSocketTCP_sendRSA(socket, rsa_enc,\
Array_construct_size(structPtr, sizeof(*structPtr)))
struct_castTo_Array_u8(structPtr))
Result(u32) EncryptedSocketTCP_recvRSA(EncryptedSocketTCP* ptr,
RSADecryptor* rsa_dec, Array(u8) buffer, SocketRecvFlag flags);
#define EncryptedSocketTCP_recvStructRSA(socket, rsa_dec, structPtr)\
EncryptedSocketTCP_recvRSA(socket, rsa_dec,\
Array_construct_size(structPtr, sizeof(*structPtr)),\
struct_castTo_Array_u8(structPtr),\
SocketRecvFlag_WholeBuffer)
//////////////////////////////////////////////////////////////////////////////

16
src/network/socket.c
View File

@@ -60,11 +60,11 @@ 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);
i32 r = send(s, (void*)buffer.data, buffer.len, 0);
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if((u32)r != buffer.size){
if((u32)r != buffer.len){
return RESULT_ERROR_FMT("Socket was unable to send data");
}
return RESULT_VOID;
@@ -72,11 +72,11 @@ Result(void) socket_send(Socket s, Array(u8) buffer){
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));
i32 r = sendto(s, (void*)buffer.data, buffer.len, 0, (void*)&sockaddr, sizeof(sockaddr));
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if((u32)r != buffer.size){
if((u32)r != buffer.len){
return RESULT_ERROR_FMT("Socket was unable to send data");
}
return RESULT_VOID;
@@ -92,11 +92,11 @@ 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));
i32 r = recv(s, (void*)buffer.data, buffer.len, SocketRecvFlags_toStd(flags));
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.size))
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.len))
{
return RESULT_ERROR("Socket closed", false);
}
@@ -106,12 +106,12 @@ Result(i32) socket_recv(Socket s, Array(u8) buffer, SocketRecvFlag flags){
Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end){
struct sockaddr_in remote_addr = {0};
i32 sockaddr_size = sizeof(remote_addr);
i32 r = recvfrom(s, buffer.data, buffer.size, SocketRecvFlags_toStd(flags),
i32 r = recvfrom(s, (void*)buffer.data, buffer.len, SocketRecvFlags_toStd(flags),
(struct sockaddr*)&remote_addr, (void*)&sockaddr_size);
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.size))
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.len))
{
return RESULT_ERROR("Socket closed", false);
}

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

@@ -16,7 +16,7 @@ str validateUsername_cstr(char username[USERNAME_SIZE_MAX+1], str* out_username_
}
str validateUsername_str(str username){
if(username.size < USERNAME_SIZE_MIN || username.size > USERNAME_SIZE_MAX){
if(username.len < USERNAME_SIZE_MIN || username.len > USERNAME_SIZE_MAX){
return str_from_cstr(
sprintf_malloc(
"username length (in bytes) must be >= %i and <= %i\n",
@@ -25,7 +25,7 @@ str validateUsername_str(str username){
);
}
for(u32 i = 0; i < username.size; i++){
for(u32 i = 0; i < username.len; i++){
char c = username.data[i];
if (char_isLatinLower(c) ||
char_isLatinUpper(c) ||
@@ -56,8 +56,8 @@ Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* he
_PacketHeader_construct(ClientHandshake);
memset(ptr, 0, sizeof(*ptr));
try_assert(session_key.size == sizeof(ptr->session_key));
memcpy(ptr->session_key, session_key.data, session_key.size);
try_assert(session_key.len == sizeof(ptr->session_key));
memcpy(ptr->session_key, session_key.data, session_key.len);
Return RESULT_VOID;
}
@@ -97,10 +97,10 @@ Result(void) LoginRequest_tryConstruct(LoginRequest *ptr, PacketHeader* header,
if(name_error_str.data){
Return RESULT_ERROR(name_error_str.data, true);
}
memcpy(ptr->username, username.data, username.size);
memcpy(ptr->username, username.data, username.len);
try_assert(token.size == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.size);
try_assert(token.len == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.len);
Return RESULT_VOID;
}
@@ -126,10 +126,10 @@ Result(void) RegisterRequest_tryConstruct(RegisterRequest *ptr, PacketHeader* he
if(name_error_str.data){
Return RESULT_ERROR(name_error_str.data, true);
}
memcpy(ptr->username, username.data, username.size);
memcpy(ptr->username, username.data, username.len);
try_assert(token.size == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.size);
try_assert(token.len == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.len);
Return RESULT_VOID;
}