finished tcp functions

src/Network/network.c

@@ -1,5 +1,5 @@
 #include "network.h"
-#include "stdSocketHeaders.h"
+#include "socket_impl_includes.h"
 
 Maybe kn_tryInit(){
 #if _WIN32
@@ -10,8 +10,8 @@ Maybe kn_tryInit(){
         char* errcode = toString_hex(&startupResult, sizeof(int), 0 , 1, 1);
         safethrow(cptr_concat("WSAStartup failed with error: ", errcode), ;);
     }
-    return SUCCESS(UniNull);
 #endif
+    return SUCCESS(UniNull);
 }
 
 Maybe kt_tryDispose(){
@@ -22,6 +22,24 @@ Maybe kt_tryDispose(){
         char* errcode = toString_hex(&cleanupResult, sizeof(int), 0, 1, 1);
         safethrow(cptr_concat("WSAStartup failed with error: ", errcode), ;);
     }
-    return SUCCESS(UniNull);
 #endif
+    return SUCCESS(UniNull);
+}
+
+
+Maybe __kn_StdSocket_shutdown(i64 socketfd, knShutdownType direction){
+    if(shutdown(socketfd, SD_SEND) == -1)
+        safethrow("can't shutdown socket", ;);
+    return MaybeNull;
+}
+
+Maybe __kn_StdSocket_close(i64 socketfd){
+#if KN_USE_WINSOCK
+    if(closesocket(socketfd) == -1)
+#else
+    if(close(socket->socketfd) == -1)
+#endif
+        safethrow("can't close socket", ;);
+
+    return MaybeNull;
 }

src/Network/network.h

@@ -6,7 +6,7 @@ extern "C" {
 
 #include "../base/base.h"
 
-#include "knAddress.h"
+#include "network_types.h"
 #include "sockets/knSocketTCP.h"
 #include "sockets/knSocketUDP.h"
 #include "sockets/knSocketChanneled.h"
@@ -14,6 +14,15 @@ extern "C" {
 Maybe kn_tryInit();
 Maybe kt_tryDispose();
 
+
+
+/*       INTERNAL       */
+
+/// shutdown TCP/UDP/other std socket
+Maybe __kn_StdSocket_shutdown(i64 socketfd, knShutdownType direction);
+/// close TCP/UDP/other std socket
+Maybe __kn_StdSocket_close(i64 socketfd);
+
 #if __cplusplus
 }
 #endif

src/Network/network_types.c

@@ -1,4 +1,4 @@
-#include "knAddress.h"
+#include "network_types.h"
 
 ktid_define(knIPV4Address);
 ktid_define(knIPV4Endpoint);
@@ -8,7 +8,7 @@ Maybe knIPV4Address_fromStr(char* addrStr){
     char* errmsg_extra="wrong char";
     u8 c;
     knIPV4Address addr;
-    addr.u32=0;
+    addr.UintBigEndian=0;
     u16 n=0;
     for(u8 i=0; i<4; ){
         c=*addrStr++;
@@ -45,5 +45,5 @@ Maybe knIPV4Address_fromStr(char* addrStr){
         }
     }
     //TODO UniStack for generic structs
-    return SUCCESS(UniUInt64(addr.u32));
+    return SUCCESS(UniUInt64(addr.UintBigEndian));
 }

src/Network/network_types.h

@@ -10,12 +10,13 @@ extern "C" {
 typedef u16 knPort;
 
 typedef union knIPV4Address {
-    u32 u32;
+    u32 UintBigEndian;
     char bytes[4];
 } 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}})
+#define knIPV4Address_fromU32(N) ((knIPV4Address){.UintBigEndian=N})
 
 ///@return Maybe<knIPV4Address> as Maybe<knIPV4Address>
 Maybe knIPV4Address_fromStr(char* addrStr);
@@ -31,7 +32,13 @@ typedef struct knIPV4Endpoint {
 } knIPV4Endpoint;
 ktid_declare(knIPV4Endpoint);
 
-#define knIPV4Endpoint_create(ADDR, PORT) (knIPV4Endpoint){ADDR, PORT}
+#define knIPV4Endpoint_create(ADDR, PORT) ((knIPV4Endpoint){ADDR, PORT})
+
+typedef enum knShutdownType {
+    knShutdownType_Receive = 0,
+    knShutdownType_Send = 1,
+    knShutdownType_Both = 2,
+} knShutdownType;
 
 #if __cplusplus
 }

src/Network/sockets/knSocketChanneled.c

@@ -1,5 +1,5 @@
 #include "../network.h"
-#include "../stdSocketHeaders.h"
+#include "../socket_impl_includes.h"
 
 ktid_define(knPackage);
 ktid_define(knPackageQueueElem);

src/Network/sockets/knSocketChanneled.h

@@ -4,8 +4,7 @@
 extern "C" {
 #endif
 
-#include "../../base/base.h"
+#include "../network_types.h"
-#include "../knAddress.h"
 
 #define KNPAC_MAX_DATA_SIZE (65535-sizeof(knPackage)+sizeof(u8*))
 
@@ -74,7 +73,7 @@ Maybe knSocketChanneled_accept(knSocketChanneled* socket);
 ///@return Maybe<void>
 Maybe knSocketChanneled_send(knSocketChanneled* socket, u16 destinationIndex, u8* data, u32 dataLength);
 
-///@param buffer buffer for recieving data
+///@param buffer buffer for receiving data
 ///@param bufferLength 0-4294967295
 ///@return Maybe<u64> received bytes amount
 Maybe knSocketChanneled_receive(knSocketChanneled* socket, u16 destinationIndex, u8* buffer, u32 bufferLength);

src/Network/sockets/knSocketTCP.c

@@ -1,41 +1,35 @@
 #include "../network.h"
-#include "../stdSocketHeaders.h"
+#include "../socket_impl_includes.h"
 ktid_define(knSocketTCP);
 
 Maybe knSocketTCP_open(){
     knSocketTCP* newSocket=malloc(sizeof(knSocketTCP));
-    newSocket->localEndpoint=knIPV4Endpoint_create({.u32=INADDR_NONE},0);
+    newSocket->localEndpoint=knIPV4Endpoint_create(IPV4_NONE,0);
     newSocket->remoteEndpoint=newSocket->localEndpoint;
     newSocket->socketfd=socket(AF_INET, SOCK_STREAM, 0);
-    if(newSocket->socketfd==-1)
+    if(newSocket->socketfd==-1 || newSocket->socketfd == ~0)
         safethrow("can't create TCP socket", free(newSocket));
         
     return SUCCESS(UniHeapPtr(knSocketTCP, newSocket));
 }
 
-Maybe knSocketTCP_close(knSocketTCP* socket){
+Maybe knSocketTCP_shutdown(knSocketTCP* socket, knShutdownType direction){
-    int result=
+    try(__kn_StdSocket_shutdown(socket->socketfd, direction), _m875, ;);
-#if KN_USE_WINSOCK
+    return MaybeNull;
-        closesocket
+}
-#else
-        close
-#endif
-        (socket->socketfd);
-    if(result==-1)
-        safethrow("can't close socket",;);
 
+Maybe knSocketTCP_close(knSocketTCP* socket){
+    try(__kn_StdSocket_close(socket->socketfd), _m875, ;);
     socket->socketfd = 0;
-    socket->localEndpoint = knIPV4Endpoint_create(0, 0);
+    socket->localEndpoint = knIPV4Endpoint_create(IPV4_NONE, -1);
-    socket->remoteEndpoint = knIPV4Endpoint_create(0, 0);
+    socket->remoteEndpoint = knIPV4Endpoint_create(IPV4_NONE, -1);
     return MaybeNull;
 }
 
 Maybe knSocketTCP_listen(knSocketTCP* socket, knIPV4Endpoint localEndp){
-    if(socket->localEndpoint.address.u32!=INADDR_NONE)
-        safethrow("socket is bound already",;);
     struct sockaddr_in servaddr;
     servaddr.sin_family = AF_INET;
-    servaddr.sin_addr.s_addr = htonl(localEndp.address.u32);
+    servaddr.sin_addr.s_addr = localEndp.address.UintBigEndian;
     servaddr.sin_port = htons(localEndp.port);
     if(bind(socket->socketfd,(struct sockaddr*)&servaddr, sizeof(servaddr)) !=0)
         safethrow("socket bind failed",;);
@@ -46,11 +40,9 @@ Maybe knSocketTCP_listen(knSocketTCP* socket, knIPV4Endpoint localEndp){
 }
 
 Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEndp){
-    if(socket->remoteEndpoint.address.u32!=0)
-        safethrow("socket is connected already",;);
     struct sockaddr_in servaddr;
     servaddr.sin_family=AF_INET;
-    servaddr.sin_addr.s_addr = htonl(remoteEndp.address.u32);
+    servaddr.sin_addr.s_addr = remoteEndp.address.UintBigEndian;
     servaddr.sin_port = htons(remoteEndp.port);
     if(connect(socket->socketfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) !=0)
         safethrow("socket connect failed",;);
@@ -59,11 +51,47 @@ Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEndp){
 }
 
 Maybe knSocketTCP_accept(knSocketTCP* socket){
-    accept(socket->socketfd, )
+    struct sockaddr_in remoteAddr = {0};
+    int remoteAddrSize = sizeof(remoteAddr);
+    i64 client_fd = accept(socket->socketfd, (struct sockaddr*)&remoteAddr, &remoteAddrSize);
+    if(client_fd == -1 || client_fd == ~0)
+        safethrow("can't accept client connection", ;);
+    // if accept() didn't set remoteAddr for some reason
+    if(remoteAddr.sin_addr.s_addr == 0 && remoteAddr.sin_port == 0 && remoteAddr.sin_family == 0){
+        if(getpeername(client_fd, (struct sockaddr*)&remoteAddr, &remoteAddrSize) != 0)
+            safethrow("can't get connected client address", ;);
+    }
+
+    knSocketTCP* clientSocket = malloc(sizeof(knSocketTCP));
+    clientSocket->socketfd = client_fd;
+    clientSocket->localEndpoint = socket->localEndpoint;
+    clientSocket->remoteEndpoint = knIPV4Endpoint_create(
+        knIPV4Address_fromU32(remoteAddr.sin_addr.s_addr), 
+        remoteAddr.sin_port);
+    return SUCCESS(UniHeapPtr(knSocketTCP, clientSocket));
 }
 
 Maybe knSocketTCP_send(knSocketTCP* socket, char* data, u32 dataLength){
-
+    u32 sentTotal = 0;
+    while(sentTotal < dataLength){
+        int sentCount = send(socket->socketfd, data+sentTotal, dataLength-sentTotal, 0);
+        if(sentCount == -1){
+            safethrow(
+                cptr_concat("can't send ", toString_u64(dataLength-sentTotal,0,0),
+                    " bytes out of ", toString_u64(dataLength,0,0),
+                    " at index ", toString_u64(sentTotal,0,0),
+                    " to TCP socket"
+                ),
+                ;);
+        }
+        sentTotal += sentCount;
+    }
+    return MaybeNull;
 }
 
-Maybe knSocketTCP_receive(knSocketTCP* socket, char* buffer, u32 bufferLength);
+Maybe knSocketTCP_receive(knSocketTCP* socket, char* buffer, u32 bufferLength){
+    int receivedCount = recv(socket->socketfd, buffer, bufferLength, 0);
+    if(receivedCount == -1 || receivedCount == 0)
+        safethrow("can't receive data from TCP socket", ;)
+    return SUCCESS(UniUInt64(receivedCount));
+}

src/Network/sockets/knSocketTCP.h

@@ -4,19 +4,23 @@
 extern "C" {
 #endif
 
-#include "../../base/base.h"
+#include "../network_types.h"
-#include "../knAddress.h"
 
 typedef struct knSocketTCP {
     i64 socketfd;
     knIPV4Endpoint localEndpoint;
     knIPV4Endpoint remoteEndpoint;
+    // TODO socket status enum
 } knSocketTCP;
 ktid_declare(knSocketTCP);
 
 ///@return Maybe<knSocketTCP*> new socket
 Maybe knSocketTCP_open();
 
+///@param direction receive/send/both
+///@return Maybe<void> error or nothing
+Maybe knSocketTCP_shutdown(knSocketTCP* socket, knShutdownType direction);
+
 ///@return Maybe<void> error or nothing
 Maybe knSocketTCP_close(knSocketTCP* socket);
 
@@ -35,7 +39,7 @@ Maybe knSocketTCP_accept(knSocketTCP* socket);
 ///@return Maybe<void>
 Maybe knSocketTCP_send(knSocketTCP* socket, char* data, u32 dataLength);
 
-///@param buffer buffer for recieving data
+///@param buffer buffer for receiving data
 ///@param bufferLength 0-4294967295
 ///@return Maybe<u64> received bytes amount
 Maybe knSocketTCP_receive(knSocketTCP* socket, char* buffer, u32 bufferLength);

src/Network/sockets/knSocketUDP.c

@@ -1,5 +1,5 @@
 #include "../network.h"
-#include "../stdSocketHeaders.h"
+#include "../socket_impl_includes.h"
 ktid_define(knSocketUDP);
 
 Maybe knSocketUDP_open(){
@@ -12,19 +12,15 @@ Maybe knSocketUDP_open(){
     return SUCCESS(UniHeapPtr(knSocketUDP, newSocket));
 }
 
-Maybe knSocketUDP_close(knSocketUDP* socket){
+Maybe knSocketUDP_shutdown(knSocketUDP* socket, knShutdownType direction){
-    int result=
+    try(__kn_StdSocket_shutdown(socket->socketfd, direction), _m875, ;);
-#if KN_USE_WINSOCK
+    return MaybeNull;
-        closesocket
+}
-#else
-        close
-#endif
-        (socket->socketfd);
-    if(result==-1)
-        safethrow("can't close socket",;);
 
+Maybe knSocketUDP_close(knSocketUDP* socket){
+    try(__kn_StdSocket_close(socket->socketfd), _m875, ;);
     socket->socketfd = 0;
-    socket->localEndpoint = knIPV4Endpoint_create(0,0);
+    socket->localEndpoint = knIPV4Endpoint_create(IPV4_NONE, -1);
     return MaybeNull;
 }
 

src/Network/sockets/knSocketUDP.h

@@ -4,17 +4,22 @@
 extern "C" {
 #endif
 
-#include "knSocketUDP.h"
+#include "../network_types.h"
 
 typedef struct knSocketUDP {
     i64 socketfd;
     knIPV4Endpoint localEndpoint;
+    // TODO socket status enum
 } knSocketUDP;
 ktid_declare(knSocketUDP);
 
 ///@return Maybe<knSocketUDP*> new socket
 Maybe knSocketUDP_open();
 
+///@param direction receive/send/both
+///@return Maybe<void> error or nothing
+Maybe knSocketUDP_shutdown(knSocketUDP* socket, knShutdownType direction);
+
 ///@return Maybe<void> error or nothing
 Maybe knSocketUDP_close(knSocketUDP* socket);
 
@@ -29,7 +34,7 @@ Maybe knSocketUDP_accept(knSocketUDP* socket);
 ///@return Maybe<void>
 Maybe knSocketUDP_sendto(knSocketUDP* socket, char* data, u32 dataLength, knIPV4Endpoint destination);
 
-///@param buffer buffer for recieving data
+///@param buffer buffer for receiving data
 ///@param bufferLength 0-4294967295
 ///@return Maybe<u64> received bytes amount
 Maybe knSocketUDP_receive(knSocketUDP* socket, char* buffer, u32 bufferLength);

tests/test_network.c

@@ -4,9 +4,9 @@
 void __test_knIPV4Address_fromStr(char* addrStr, u8 a, u8 b, u8 c, u8 d){
     tryLast(knIPV4Address_fromStr(addrStr), maybeAddr, ;)
     knIPV4Address addr;
-    addr.u32=(u32)maybeAddr.value.UInt64;
+    addr.UintBigEndian=(u32)maybeAddr.value.UInt64;
     kprintf("\e[94mknIPV4Address_fromStr(\e[96m%s\e[94m) -> ", addrStr);
-    if(maybeAddr.value.UInt64!=knIPV4Address_fromBytes(a,b,c,d).u32){
+    if(maybeAddr.value.UInt64!=knIPV4Address_fromBytes(a,b,c,d).UintBigEndian){
         kprintf("\e[91m%u.%u.%u.%u\n", 
             (u8)addr.bytes[0], (u8)addr.bytes[1], (u8)addr.bytes[2], (u8)addr.bytes[3]);
         throw("knIPV4Address_fromStr returned wrong value");
@@ -42,15 +42,32 @@ void test_network(){
         socket=m_socket.value.VoidPtr;
         kprintf("\e[92mTCP socket created\n");
 
-        knIPV4Endpoint localEnd = knIPV4Endpoint_create(knIPV4Address_fromBytes(127,0,0,1), 4444);
+        knIPV4Endpoint localEnd = knIPV4Endpoint_create(IPV4_LOOPBACK, 4444);
         tryLast(knSocketTCP_listen(socket, localEnd), _m81775, ;)
+        kprintf("\e[92msocket is listening\n");
 
+        tryLast(knSocketTCP_accept(socket), m_connection, ;);
+        knSocketTCP* clientConnection = m_connection.value.VoidPtr;
+        kprintf("\e[92mclient connection accepted\n");
+
+        char buf[4096];
         while(true){
-            tryLast(knSocketTCP_accept(socket), m_connection, ;);
+            tryLast(knSocketTCP_receive(clientConnection, buf, sizeof(buf)), m_recCount, ;);
-            knSocketTCP* connection = m_connection.value.VoidPtr;
+            u64 recCount = m_recCount.value.UInt64;
-            knSocketTCP_receive()
+            fwrite(buf, sizeof(char), recCount, stdout);
+            // end of received data
+            if(recCount != sizeof(buf))
+                break;
         }
-        
+        kprintf("\e[92mmessage received\n");
+
+        const char msg[] = "pong";
+        tryLast(knSocketTCP_send(clientConnection, msg, sizeof(msg)), _mu75q2, ;);
+        kprintf("\e[92mmessage sent\n");
+
+        tryLast(knSocketTCP_shutdown(clientConnection, knShutdownType_Both), _m2351, ;);
+        tryLast(knSocketTCP_close(clientConnection), _m9776, ;);
+        kprintf("\e[92mclient connection closed\n");
 
         tryLast(knSocketTCP_close(socket), _m676, ;);
         kprintf("\e[92mTCP socket closed\n");