knNetwork file structure changed

src/Network/knAddress.c

@@ -1,5 +1,8 @@
 #include "knAddress.h"
 
+ktId_define(knIPV4Address);
+ktId_define(knIPV4Endpoint);
+
 Maybe knIPV4Address_fromStr(char* addrStr){
     char* addrStr_src=addrStr;
     char* errmsg_extra="wrong char";
@@ -37,5 +40,5 @@ Maybe knIPV4Address_fromStr(char* addrStr){
                 break;
         }
     }
-    return SUCCESS(Uni(UInt64, (uint64)addr.address));
+    return SUCCESS(UniStack(knIPV4Address, addr));
 }

src/Network/knAddress.h

@@ -13,16 +13,18 @@ typedef union knIPV4Address {
     uint32 address;
     char bytes[4];
 } knIPV4Address;
+ktId_declare(knIPV4Address);
 
 #define knIPV4Address_fromBytes(A, B, C, D) (knIPV4Address){.bytes={A,B,C,D}}
 
-///@return Maybe<uint64> as Maybe<knIPV4Address>
+///@return Maybe<knIPV4Address> as Maybe<knIPV4Address>
 Maybe knIPV4Address_fromStr(char* addrStr);
 
 typedef struct knIPV4Endpoint {
     knIPV4Address address;
     knPort port;
 } knIPV4Endpoint;
+ktId_declare(knIPV4Endpoint);
 
 #define knIPV4Endpoint_create(ADDR, PORT) (knIPV4Endpoint){ADDR, PORT}
 

src/Network/knChanneledSocket.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#if __cplusplus
-extern "C" {
-#endif
-
-#include "knSocket.h"
-
-
-typedef struct knChanneledSocket{
-    union {
-        knSocket;
-        knSocket base;
-    };
-    uint16 channelsAmount;
-    knChannel** channels;
-} knChanneledSocket;
-
-#if __cplusplus
-}
-#endif

src/Network/knPackage.c

@@ -1,2 +0,0 @@
-#include "knPackage.h"
-

src/Network/knPackage.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#if __cplusplus
-extern "C" {
-#endif
-
-#include "../base/base.h"
-
-
-#define KNPAC_MAX_DATA_SIZE (65535-sizeof(knPackage)+sizeof(uint8*))
-
-
-typedef enum __attribute__((__packed__)) knPacVersion {
-    knPac_V1
-} knPacVersion;
-
-static const char knPacHeader[5]={'k','n','p','a','c'};
-
-typedef struct knPackage {
-    char header[5];             // knpac
-    knPacVersion version;       // protocol version
-    uint16 data_size;           // size of data block in bytes (1-KNPAC_MAX_DATA_SIZE)
-    uint32 channel_id;          // id of knChannel in socket
-    uint32 package_num;         // number in sequence of sent packages
-    uint64 data_hash;           // hash64 of data
-    uint8* data;                // ptr to data
-} knPackage;
-
-typedef struct knPackageQueueElem knPackageQueueElem;
-struct knPackageQueueElem {
-    union {
-        knPackage;
-        knPackage package;
-    };
-    knPackageQueueElem* previousElem;
-    knPackageQueueElem* nextElem;
-};
-
-typedef struct knChannel {
-    knPackageQueueElem* queueStart;
-} knChannel;
-
-#if __cplusplus
-}
-#endif

src/Network/knSocket.c

@@ -1,91 +1,5 @@
-#include "knSocket.h"
+#include "network.h"
 #include "stdSocketHeaders.h"
 
-
+ktId_define(knSocketProtocol);
-Maybe knSocket_open(knSocketProtocol sockType){
+ktId_define(knSocket);
-    knSocket* newSocket=malloc(sizeof(knSocket));
-    newSocket->type=sockType;
-    newSocket->channels=NULL;
-    newSocket->channelsAmount=0;
-    newSocket->localEndpoint=knIPV4Endpoint_create(knIPV4Address_fromBytes(0,0,0,0),0);
-    newSocket->remoteEndpoint=newSocket->localEndpoint;
-    switch(sockType){
-        default:
-            safethrow("unknown socket type", free(newSocket));
-            break;
-        case knSocketProtocol_TCP:
-            newSocket->socketfd=socket(AF_INET, SOCK_STREAM, 0);
-            if(newSocket->socketfd==-1)
-                safethrow("can't create TCP socket", free(newSocket));
-            break;
-        case knSocketProtocol_UDP:
-            newSocket->socketfd=socket(AF_INET, SOCK_DGRAM, 0);
-            if(newSocket->socketfd==-1)
-                safethrow("can't create UDP socket", free(newSocket));
-            break;
-    }
-    return SUCCESS(UniPtr(knSocketPtr, newSocket));
-}
-
-Maybe knSocket_close(knSocket* knsocket){
-    int rezult=
-#if KN_USE_WINSOCK
-    closesocket
-#else
-    close
-#endif
-    (knsocket->socketfd);
-    if(rezult==-1) {
-        safethrow("can't close socket",;);
-    }
-    else return SUCCESS(UniNull);
-}
-
-knChannel* __createChannel(){
-    knChannel* ch=malloc(sizeof(knChannel));
-    ch->queueStart=NULL;
-    return ch;
-}
-
-Maybe knSocket_createChannel(knSocket* sock){
-    if(sock->channelsAmount == 65535) 
-        safethrow("max amount of channels",;);
-    uint16 channelsAmountPrev=sock->channelsAmount;
-    sock->channelsAmount++;
-    if(channelsAmountPrev==0) 
-        sock->channels=malloc(sizeof(knChannel*));
-    else 
-        sock->channels=realloc(sock->channels, sock->channelsAmount*sizeof(knChannel*));
-    sock->channels[channelsAmountPrev]=__createChannel();
-    return SUCCESS(Uni(UInt64, channelsAmountPrev));
-}
-
-/*Maybe knSocket_bind(knSocket* sock, knIPV4Endpoint localEndp){
-    if(sock->localEndpoint.address.address!=0)
-        safethrow("socket is bound already",;);
-    struct sockaddr_in addr;
-    addr.sin_family=
-    bind(sock->socketfd);
-    sock->localEndpoint=localEndp;
-    return SUCCESS(UniNull);
-}
-
-Maybe knSocket_connect(knSocket* sock, knIPV4Endpoint remoteEndp){
-    if(sock->remoteEndpoint.address.address!=0)
-        safethrow("socket is connected already",;);
-    
-    sock->remoteEndpoint=remoteEndp;
-    return SUCCESS(UniNull);
-}
-
-Maybe knSocket_accept(knSocket* sock){
-
-}
-
-Maybe knSocket_send(knSocket* sock, uint16 destinationIndex, uint8* data, uint32 dataLength){
-
-}
-
-Maybe knSocket_recieve(knSocket* sock, uint16 destinationIndex, uint8* buffer, uint32 bufferLength){
-
-}*/

src/Network/knSocket.h

@@ -6,12 +6,12 @@ extern "C" {
 
 #include "../base/base.h"
 #include "knAddress.h"
-#include "knPackage.h"
 
 
 typedef enum __attribute__((__packed__)) knSocketProtocol {
     knSocketProtocol_TCP, knSocketProtocol_UDP, knSocket_Channeled
 } knSocketProtocol;
+ktId_declare(knSocketProtocol);
 
 typedef struct knSocket {
     knSocketProtocol type;
@@ -21,6 +21,7 @@ typedef struct knSocket {
     // uint16 channelsAmount;
     // knChannel** channels;
 } knSocket;
+ktId_declare(knSocket);
 
 ///@return Maybe<knSocket*> new socket
 Maybe knSocket_open(knSocketProtocol sockType);
@@ -28,9 +29,6 @@ Maybe knSocket_open(knSocketProtocol sockType);
 ///@return Maybe<void> error or nothing
 Maybe knSocket_close(knSocket* socket);
 
-///@return Maybe<uint64> channel index
-Maybe knSocket_createChannel(knSocket* socket);
-
 ///sets socket local endpoint
 ///@return Maybe<void> error or nothing
 Maybe knSocket_bind(knSocket* socket, knIPV4Endpoint localEndp);

src/Network/knSocketChanneled.c

@@ -0,0 +1,96 @@
+#include "network.h"
+#include "stdSocketHeaders.h"
+
+ktId_define(knPacVersion);
+ktId_define(knPackage);
+ktId_define(knPackageQueueElem);
+ktId_define(knChannel);
+ktId_define(knSocketChanneled);
+
+Maybe knSocketChanneled_open(knSocketProtocol sockType){
+    knSocketChanneled* newSocket=malloc(sizeof(knSocketChanneled));
+    newSocket->type=sockType;
+    newSocket->channels=NULL;
+    newSocket->channelsAmount=0;
+    newSocket->localEndpoint=knIPV4Endpoint_create(knIPV4Address_fromBytes(0,0,0,0),0);
+    newSocket->remoteEndpoint=newSocket->localEndpoint;
+    switch(sockType){
+        default:
+            safethrow("unknown socket type", free(newSocket));
+            break;
+        case knSocketProtocol_TCP:
+            newSocket->socketfd=socket(AF_INET, SOCK_STREAM, 0);
+            if(newSocket->socketfd==-1)
+                safethrow("can't create TCP socket", free(newSocket));
+            break;
+        case knSocketProtocol_UDP:
+            newSocket->socketfd=socket(AF_INET, SOCK_DGRAM, 0);
+            if(newSocket->socketfd==-1)
+                safethrow("can't create UDP socket", free(newSocket));
+            break;
+    }
+    return SUCCESS(UniPtr(knSocketChanneledPtr, newSocket));
+}
+
+Maybe knSocketChanneled_close(knSocketChanneled* knsocket){
+    int rezult=
+#if KN_USE_WINSOCK
+    closesocket
+#else
+    close
+#endif
+    (knsocket->socketfd);
+    if(rezult==-1) {
+        safethrow("can't close socket",;);
+    }
+    else return SUCCESS(UniNull);
+}
+
+knChannel* __createChannel(){
+    knChannel* ch=malloc(sizeof(knChannel));
+    ch->queueStart=NULL;
+    return ch;
+}
+
+Maybe knSocketChanneled_createChannel(knSocketChanneled* sock){
+    if(sock->channelsAmount == 65535) 
+        safethrow("max amount of channels",;);
+    uint16 channelsAmountPrev=sock->channelsAmount;
+    sock->channelsAmount++;
+    if(channelsAmountPrev==0) 
+        sock->channels=malloc(sizeof(knChannel*));
+    else 
+        sock->channels=realloc(sock->channels, sock->channelsAmount*sizeof(knChannel*));
+    sock->channels[channelsAmountPrev]=__createChannel();
+    return SUCCESS(UniUInt64(channelsAmountPrev));
+}
+
+/*Maybe knSocketChanneled_bind(knSocketChanneled* sock, knIPV4Endpoint localEndp){
+    if(sock->localEndpoint.address.address!=0)
+        safethrow("socket is bound already",;);
+    struct sockaddr_in addr;
+    addr.sin_family=
+    bind(sock->socketfd);
+    sock->localEndpoint=localEndp;
+    return SUCCESS(UniNull);
+}
+
+Maybe knSocketChanneled_connect(knSocketChanneled* sock, knIPV4Endpoint remoteEndp){
+    if(sock->remoteEndpoint.address.address!=0)
+        safethrow("socket is connected already",;);
+    
+    sock->remoteEndpoint=remoteEndp;
+    return SUCCESS(UniNull);
+}
+
+Maybe knSocketChanneled_accept(knSocketChanneled* sock){
+
+}
+
+Maybe knSocketChanneled_send(knSocketChanneled* sock, uint16 destinationIndex, uint8* data, uint32 dataLength){
+
+}
+
+Maybe knSocketChanneled_recieve(knSocketChanneled* sock, uint16 destinationIndex, uint8* buffer, uint32 bufferLength){
+
+}*/

src/Network/knSocketChanneled.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#if __cplusplus
+extern "C" {
+#endif
+
+#include "../base/base.h"
+#include "knSocket.h"
+
+#define KNPAC_MAX_DATA_SIZE (65535-sizeof(knPackage)+sizeof(uint8*))
+
+
+typedef enum __attribute__((__packed__)) knPacVersion {
+    knPac_V1
+} knPacVersion;
+ktId_declare(knPacVersion);
+
+static const char knPacHeader[5]={'k','n','p','a','c'};
+
+typedef struct knPackage {
+    char header[5];             // knpac
+    knPacVersion version;       // protocol version
+    uint16 data_size;           // size of data block in bytes (1-KNPAC_MAX_DATA_SIZE)
+    uint32 channel_id;          // id of knChannel in socket
+    uint32 package_num;         // number in sequence of sent packages
+    uint64 data_hash;           // hash64 of data
+    uint8* data;                // ptr to data
+} knPackage;
+ktId_declare(knPackage);
+
+typedef struct knPackageQueueElem knPackageQueueElem;
+struct knPackageQueueElem {
+    union {
+        knPackage;
+        knPackage package;
+    };
+    knPackageQueueElem* previousElem;
+    knPackageQueueElem* nextElem;
+};
+ktId_declare(knPackageQueueElem);
+
+typedef struct knChannel {
+    knPackageQueueElem* queueStart;
+} knChannel;
+ktId_declare(knChannel);
+
+typedef struct knSocketChanneled{
+    union {
+        knSocket;
+        knSocket base;
+    };
+    uint16 channelsAmount;
+    knChannel** channels;
+} knSocketChanneled;
+ktId_declare(knSocketChanneled);
+
+
+///@return Maybe<knSocket*> new socket
+Maybe knSocketChanneled_open(knSocketProtocol sockType);
+
+///@return Maybe<void> error or nothing
+Maybe knSocketChanneled_close(knSocket* socket);
+
+///@return Maybe<uint64> channel index
+Maybe knSocketChanneled_createChannel(knSocket* socket);
+
+///sets socket local endpoint
+///@return Maybe<void> error or nothing
+Maybe knSocketChanneled_bind(knSocket* socket, knIPV4Endpoint localEndp);
+
+///sets socket remote endpoint
+///@return Maybe<void> error or nothing
+Maybe knSocketChanneled_connect(knSocket* socket, knIPV4Endpoint remoteEndp);
+
+///@return Maybe<knSocket*> new socket connected to client
+Maybe knSocketChanneled_accept(knSocket* socket);
+
+///@param dataLength 0-4294967295
+///@return Maybe<void>
+Maybe knSocketChanneled_send(knSocket* socket, uint16 destinationIndex, uint8* data, uint32 dataLength);
+
+///@param buffer buffer for recieving data
+///@param bufferLength 0-4294967295
+///@return Maybe<uint64> recieved bytes amount
+Maybe knSocketChanneled_recieve(knSocket* socket, uint16 destinationIndex, uint8* buffer, uint32 bufferLength);
+
+#if __cplusplus
+}
+#endif

src/Network/network.h

@@ -11,9 +11,8 @@ extern "C" {
 #endif
 
 #include "knAddress.h"
-#include "knPackage.h"
 #include "knSocket.h"
-#include "knChanneledSocket.h"
+#include "knSocketChanneled.h"
 
 #if __cplusplus
 }

src/Network/stdSocketHeaders.h

@@ -4,9 +4,6 @@
 extern "C" {
 #endif
 
-#include "network.h"
-
-
 #if KN_USE_WINSOCK
     #include <winsock2.h>
 #else