Timerix/kerep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed errors

Browse Source
This commit is contained in:
timerix 2022-11-25 10:36:38 +06:00
parent 2efcf08ebe
commit 288c73104c
10 changed files with 42 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.vscode/launch.json vendored
View File

@ -11,19 +11,7 @@
"cwd": "${fileDirname}", "cwd": "${fileDirname}",
"externalConsole": false, "externalConsole": false,
"MIMode": "gdb", "MIMode": "gdb",
"miDebuggerPath": "gdb", "miDebuggerPath": "gdb"
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
},
{
"description": "Set Disassembly Flavor to Intel",
"text": "-gdb-set disassembly-flavor intel",
"ignoreFailures": true
}
]
}, },
{ {
"name": "(gdb-pipe) Debug", "name": "(gdb-pipe) Debug",

7
src/Network/knAddress.c
View File

@ -1,7 +1,7 @@
#include "knAddress.h" #include "knAddress.h"
ktId_define(knIPV4Address); ktid_define(knIPV4Address);
ktId_define(knIPV4Endpoint); ktid_define(knIPV4Endpoint);
Maybe knIPV4Address_fromStr(char* addrStr){ Maybe knIPV4Address_fromStr(char* addrStr){
char* addrStr_src=addrStr; char* addrStr_src=addrStr;
@ -40,5 +40,6 @@ Maybe knIPV4Address_fromStr(char* addrStr){
break; break;
} }
} }
return SUCCESS(UniStack(knIPV4Address, addr)); //TODO UniStack for generic structs
return SUCCESS(UniUInt64(addr.address));
} }

4
src/Network/knAddress.h
View File

@ -13,7 +13,7 @@ typedef union knIPV4Address {
uint32 address; uint32 address;
char bytes[4]; char bytes[4];
} knIPV4Address; } knIPV4Address;
ktId_declare(knIPV4Address); ktid_declare(knIPV4Address);
#define knIPV4Address_fromBytes(A, B, C, D) (knIPV4Address){.bytes={A,B,C,D}} #define knIPV4Address_fromBytes(A, B, C, D) (knIPV4Address){.bytes={A,B,C,D}}
@ -24,7 +24,7 @@ typedef struct knIPV4Endpoint {
knIPV4Address address; knIPV4Address address;
knPort port; knPort port;
} knIPV4Endpoint; } knIPV4Endpoint;
ktId_declare(knIPV4Endpoint); ktid_declare(knIPV4Endpoint);
#define knIPV4Endpoint_create(ADDR, PORT) (knIPV4Endpoint){ADDR, PORT} #define knIPV4Endpoint_create(ADDR, PORT) (knIPV4Endpoint){ADDR, PORT}

4
src/Network/knSocket.c
View File

@ -1,5 +1,5 @@
#include "network.h" #include "network.h"
#include "stdSocketHeaders.h" #include "stdSocketHeaders.h"
ktId_define(knSocketProtocol); ktid_define(knSocketProtocol);
ktId_define(knSocket); ktid_define(knSocket);

6
src/Network/knSocket.h
View File

@ -11,17 +11,15 @@ extern "C" {
typedef enum __attribute__((__packed__)) knSocketProtocol { typedef enum __attribute__((__packed__)) knSocketProtocol {
knSocketProtocol_TCP, knSocketProtocol_UDP, knSocket_Channeled knSocketProtocol_TCP, knSocketProtocol_UDP, knSocket_Channeled
} knSocketProtocol; } knSocketProtocol;
ktId_declare(knSocketProtocol); ktid_declare(knSocketProtocol);
typedef struct knSocket { typedef struct knSocket {
knSocketProtocol type; knSocketProtocol type;
int64 socketfd; int64 socketfd;
knIPV4Endpoint localEndpoint; knIPV4Endpoint localEndpoint;
knIPV4Endpoint remoteEndpoint; knIPV4Endpoint remoteEndpoint;
// uint16 channelsAmount;
// knChannel** channels;
} knSocket; } knSocket;
ktId_declare(knSocket); ktid_declare(knSocket);
///@return Maybe<knSocket*> new socket ///@return Maybe<knSocket*> new socket
Maybe knSocket_open(knSocketProtocol sockType); Maybe knSocket_open(knSocketProtocol sockType);

18
src/Network/knSocketChanneled.c
View File

@ -1,11 +1,11 @@
#include "network.h" #include "network.h"
#include "stdSocketHeaders.h" #include "stdSocketHeaders.h"
ktId_define(knPacVersion); ktid_define(knPacVersion);
ktId_define(knPackage); ktid_define(knPackage);
ktId_define(knPackageQueueElem); ktid_define(knPackageQueueElem);
ktId_define(knChannel); ktid_define(knChannel);
ktId_define(knSocketChanneled); ktid_define(knSocketChanneled);
Maybe knSocketChanneled_open(knSocketProtocol sockType){ Maybe knSocketChanneled_open(knSocketProtocol sockType){
knSocketChanneled* newSocket=malloc(sizeof(knSocketChanneled)); knSocketChanneled* newSocket=malloc(sizeof(knSocketChanneled));
@ -29,7 +29,7 @@ Maybe knSocketChanneled_open(knSocketProtocol sockType){
safethrow("can't create UDP socket", free(newSocket)); safethrow("can't create UDP socket", free(newSocket));
break; break;
} }
return SUCCESS(UniPtr(knSocketChanneledPtr, newSocket)); return SUCCESS(UniHeapPtr(knSocketChanneled, newSocket));
} }
Maybe knSocketChanneled_close(knSocketChanneled* knsocket){ Maybe knSocketChanneled_close(knSocketChanneled* knsocket){
@ -43,7 +43,7 @@ Maybe knSocketChanneled_close(knSocketChanneled* knsocket){
if(rezult==-1) { if(rezult==-1) {
safethrow("can't close socket",;); safethrow("can't close socket",;);
} }
else return SUCCESS(UniNull); else return MaybeNull;
} }
knChannel* __createChannel(){ knChannel* __createChannel(){
@ -72,7 +72,7 @@ Maybe knSocketChanneled_createChannel(knSocketChanneled* sock){
addr.sin_family= addr.sin_family=
bind(sock->socketfd); bind(sock->socketfd);
sock->localEndpoint=localEndp; sock->localEndpoint=localEndp;
return SUCCESS(UniNull); return MaybeNull;
} }
Maybe knSocketChanneled_connect(knSocketChanneled* sock, knIPV4Endpoint remoteEndp){ Maybe knSocketChanneled_connect(knSocketChanneled* sock, knIPV4Endpoint remoteEndp){
@ -80,7 +80,7 @@ Maybe knSocketChanneled_connect(knSocketChanneled* sock, knIPV4Endpoint remoteEn
safethrow("socket is connected already",;); safethrow("socket is connected already",;);
sock->remoteEndpoint=remoteEndp; sock->remoteEndpoint=remoteEndp;
return SUCCESS(UniNull); return MaybeNull;
} }
Maybe knSocketChanneled_accept(knSocketChanneled* sock){ Maybe knSocketChanneled_accept(knSocketChanneled* sock){

39
src/Network/knSocketChanneled.h
View File

@ -13,7 +13,7 @@ extern "C" {
typedef enum __attribute__((__packed__)) knPacVersion { typedef enum __attribute__((__packed__)) knPacVersion {
knPac_V1 knPac_V1
} knPacVersion; } knPacVersion;
ktId_declare(knPacVersion); ktid_declare(knPacVersion);
static const char knPacHeader[5]={'k','n','p','a','c'}; static const char knPacHeader[5]={'k','n','p','a','c'};
@ -26,63 +26,60 @@ typedef struct knPackage {
uint64 data_hash; // hash64 of data uint64 data_hash; // hash64 of data
uint8* data; // ptr to data uint8* data; // ptr to data
} knPackage; } knPackage;
ktId_declare(knPackage); ktid_declare(knPackage);
typedef struct knPackageQueueElem knPackageQueueElem; typedef struct knPackageQueueElem knPackageQueueElem;
struct knPackageQueueElem { struct knPackageQueueElem {
union {
knPackage;
knPackage package; knPackage package;
};
knPackageQueueElem* previousElem; knPackageQueueElem* previousElem;
knPackageQueueElem* nextElem; knPackageQueueElem* nextElem;
}; };
ktId_declare(knPackageQueueElem); ktid_declare(knPackageQueueElem);
typedef struct knChannel { typedef struct knChannel {
knPackageQueueElem* queueStart; knPackageQueueElem* queueStart;
} knChannel; } knChannel;
ktId_declare(knChannel); ktid_declare(knChannel);
typedef struct knSocketChanneled{ typedef struct knSocketChanneled{
union { knSocketProtocol type;
knSocket; int64 socketfd;
knSocket base; knIPV4Endpoint localEndpoint;
}; knIPV4Endpoint remoteEndpoint;
uint16 channelsAmount; uint16 channelsAmount;
knChannel** channels; knChannel** channels;
} knSocketChanneled; } knSocketChanneled;
ktId_declare(knSocketChanneled); ktid_declare(knSocketChanneled);
///@return Maybe<knSocket*> new socket ///@return Maybe<knSocketChanneled*> new socket
Maybe knSocketChanneled_open(knSocketProtocol sockType); Maybe knSocketChanneled_open(knSocketProtocol sockType);
///@return Maybe<void> error or nothing ///@return Maybe<void> error or nothing
Maybe knSocketChanneled_close(knSocket* socket); Maybe knSocketChanneled_close(knSocketChanneled* socket);
///@return Maybe<uint64> channel index ///@return Maybe<uint64> channel index
Maybe knSocketChanneled_createChannel(knSocket* socket); Maybe knSocketChanneled_createChannel(knSocketChanneled* socket);
///sets socket local endpoint ///sets socket local endpoint
///@return Maybe<void> error or nothing ///@return Maybe<void> error or nothing
Maybe knSocketChanneled_bind(knSocket* socket, knIPV4Endpoint localEndp); Maybe knSocketChanneled_bind(knSocketChanneled* socket, knIPV4Endpoint localEndp);
///sets socket remote endpoint ///sets socket remote endpoint
///@return Maybe<void> error or nothing ///@return Maybe<void> error or nothing
Maybe knSocketChanneled_connect(knSocket* socket, knIPV4Endpoint remoteEndp); Maybe knSocketChanneled_connect(knSocketChanneled* socket, knIPV4Endpoint remoteEndp);
///@return Maybe<knSocket*> new socket connected to client ///@return Maybe<knSocketChanneled*> new socket connected to client
Maybe knSocketChanneled_accept(knSocket* socket); Maybe knSocketChanneled_accept(knSocketChanneled* socket);
///@param dataLength 0-4294967295 ///@param dataLength 0-4294967295
///@return Maybe<void> ///@return Maybe<void>
Maybe knSocketChanneled_send(knSocket* socket, uint16 destinationIndex, uint8* data, uint32 dataLength); Maybe knSocketChanneled_send(knSocketChanneled* socket, uint16 destinationIndex, uint8* data, uint32 dataLength);
///@param buffer buffer for recieving data ///@param buffer buffer for recieving data
///@param bufferLength 0-4294967295 ///@param bufferLength 0-4294967295
///@return Maybe<uint64> recieved bytes amount ///@return Maybe<uint64> recieved bytes amount
Maybe knSocketChanneled_recieve(knSocket* socket, uint16 destinationIndex, uint8* buffer, uint32 bufferLength); Maybe knSocketChanneled_recieve(knSocketChanneled* socket, uint16 destinationIndex, uint8* buffer, uint32 bufferLength);
#if __cplusplus #if __cplusplus
} }

2
src/Network/network.h
View File

@ -6,7 +6,7 @@ extern "C" {
#include "../base/base.h" #include "../base/base.h"
#if defined(_MSC_VER) || defined(_WIN64) || defined(_WIN32) || 0 #if defined(_MSC_VER) || defined(_WIN64) || defined(_WIN32)
#define KN_USE_WINSOCK 1 #define KN_USE_WINSOCK 1
#endif #endif

0
src/base/type_system/ktId.h → src/base/type_system/ktid.h
View File

3
tests/test_network.c
View File

@ -31,12 +31,13 @@ void test_network(){
test_knIPV4Address_fromStr(127,0,0,1); test_knIPV4Address_fromStr(127,0,0,1);
test_knIPV4Address_fromStr(34,255,45,0); test_knIPV4Address_fromStr(34,255,45,0);
test_knIPV4Address_fromStr(3,3,3,128); test_knIPV4Address_fromStr(3,3,3,128);
/*
knSocket* s; knSocket* s;
tryLast(knSocket_open(knSocketProtocol_TCP), maybeS) tryLast(knSocket_open(knSocketProtocol_TCP), maybeS)
s=maybeS.value.VoidPtr; s=maybeS.value.VoidPtr;
printf("\e[92mTCP socket created\n"); printf("\e[92mTCP socket created\n");
tryLast(knSocket_close(s);,_); tryLast(knSocket_close(s);,_);
printf("\e[92mTCP socket closed\n"); printf("\e[92mTCP socket closed\n");
*/
})); }));
} }