test_udp

src/Network/network_types.c

@@ -1,49 +1,71 @@
-#include "network_types.h"
+#include "network_types.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;
-    char* errmsg_extra="wrong char";
+    char* errmsg_extra="wrong char";
-    u8 c;
+    u8 c;
-    knIPV4Address addr;
+    knIPV4Address addr;
-    addr.UintBigEndian=0;
+    addr.UintBigEndian=0;
-    u16 n=0;
+    u16 n=0;
-    for(u8 i=0; i<4; ){
+    for(u8 i=0; i<4; ){
-        c=*addrStr++;
+        c=*addrStr++;
-        switch (c){
+        switch (c){
-            case '\0':
+            case '\0':
-                if(i<3){
+                if(i<3){
-                    errmsg_extra="end of string";
+                    errmsg_extra="end of string";
-                    goto default_case;
+                    goto default_case;
-                }
+                }
-                
+                
-                addr.bytes[i++]=n;
+                addr.bytes[i++]=n;
-                n=0;
+                n=0;
-                break;
+                break;
-            case '.':
+            case '.':
-                addr.bytes[i++]=n;
+                addr.bytes[i++]=n;
-                n=0;
+                n=0;
-                break;
+                break;
-            case '0': case '1': case '2': case '3': case '4':
+            case '0': case '1': case '2': case '3': case '4':
-            case '5': case '6': case '7': case '8': case '9':
+            case '5': case '6': case '7': case '8': case '9':
-                n=n*10+c-'0';
+                n=n*10+c-'0';
-                if(n>255) {
+                if(n>255) {
-                    errmsg_extra="one part of address > 255";
+                    errmsg_extra="one part of address > 255";
-                    goto default_case;
+                    goto default_case;
-                }
+                }
-                break;
+                break;
-            default_case:
+            default_case:
-            default:
+            default:
-                u32 errmsgL=cptr_length(addrStr) + 80;
+                u32 errmsgL=cptr_length(addrStr) + 80;
-                char* errmsg=malloc(errmsgL);
+                char* errmsg=malloc(errmsgL);
-                IFMSC(sprintf_s(errmsg, errmsgL, "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra), 
+                IFMSC(sprintf_s(errmsg, errmsgL, "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra), 
-                      sprintf(  errmsg,          "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra));
+                      sprintf(  errmsg,          "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra));
-                safethrow(errmsg,;);
+                safethrow(errmsg,;);
-                break;
+                break;
-        }
+        }
-    }
+    }
-    //TODO UniStack for generic structs
+    //TODO UniStack for generic structs
-    return SUCCESS(UniUInt64(addr.UintBigEndian));
+    return SUCCESS(UniUInt64(addr.UintBigEndian));
-}
+}
+
+char* knIPV4Address_toString(knIPV4Address* address) {
+    char* a = toString_u64(address->bytes[0], 0, 0);
+    char* b = toString_u64(address->bytes[1], 0, 0);
+    char* c = toString_u64(address->bytes[2], 0, 0);
+    char* d = toString_u64(address->bytes[3], 0, 0);
+    char* s = cptr_concat(a,".",b,".",c,".",d);
+    free(a);
+    free(b);
+    free(c);
+    free(d);
+    return s;
+}
+
+char* knIPV4Endpoint_toString(knIPV4Endpoint* end) {
+    char* a = knIPV4Address_toString(&end->address);
+    char* p = toString_u64(end->port, 0, 0);
+    char* s = cptr_concat(a,":",p);
+    free(a);
+    free(p);
+    return s;
+}

src/Network/network_types.h

@@ -6,7 +6,6 @@ extern "C" {
 
 #include "../base/base.h"
 
-
 typedef u16 knPort;
 
 typedef union knIPV4Address {
@@ -25,6 +24,8 @@ Maybe knIPV4Address_fromStr(char* addrStr);
 #define knIPV4Address_ANY      knIPV4Address_fromBytes(0,0,0,0)
 #define knIPV4Address_LOOPBACK knIPV4Address_fromBytes(127,0,0,1)
 
+char* knIPV4Address_toString(knIPV4Address* address);
+
 
 typedef struct knIPV4Endpoint {
     knIPV4Address address;
@@ -36,6 +37,9 @@ ktid_declare(knIPV4Endpoint);
 
 #define knIPV4Endpoint_INVALID knIPV4Endpoint_create(knIPV4Address_INVALID, ~0)
 
+char* knIPV4Endpoint_toString(knIPV4Endpoint* end);
+
+
 typedef enum knShutdownType {
     knShutdownType_Receive = 0,
     knShutdownType_Send = 1,

tests/test_network.c

@@ -1,7 +1,6 @@
 #include "tests.h"
 #include "../src/Network/network.h"
-#include "pthread.h"
+#include <pthread.h>
-#include "../src/Network/socket_impl_includes.h"
 
 static void __test_knIPV4Address_fromStr(char* addrStr, u8 a, u8 b, u8 c, u8 d){
     tryLast(knIPV4Address_fromStr(addrStr), maybeAddr, ;)
@@ -143,7 +142,71 @@ static void test_tcp(){
 
 void test_udp(){
     kprintf("\e[96m----------[test_network/udp]----------\n");
+    knIPV4Endpoint serverEnd = knIPV4Endpoint_create(knIPV4Address_LOOPBACK, 4444);
+    knSocketUDP *socket_server, *socket_client;
+    // server
+    {
+        tryLast(knSocketUDP_open(true), m_socketS, ;);
+        socket_server=m_socketS.value.VoidPtr;
+        kprintf("\e[92mUDP server socket created\n");    
+        
+        tryLast(knSocketUDP_bind(socket_server, serverEnd), _m81775, ;)
+        kprintf("\e[92mserver socket is bound\n");
+    }
+    // client
+    {
+        tryLast(knSocketUDP_open(false), m_socketC, ;);
+        socket_client=m_socketC.value.VoidPtr;
+        kprintf("\e[92mUDP client socket created\n");
+        
+        const char client_msg[] = "ping";
+        tryLast(knSocketUDP_sendTo(socket_client, client_msg, sizeof(client_msg), serverEnd), _mu75q2, ;);
+        kprintf("\e[92mmessage sent to server\n\e[94m");
+    }
+    // server
+    {
+        char received_client_msg[32];
+        knIPV4Endpoint clientEnd = knIPV4Endpoint_INVALID;
+        tryLast(knSocketUDP_receiveAny(socket_server, received_client_msg, sizeof(received_client_msg), &clientEnd), m_recCount, ;);
+        u64 recCount = m_recCount.value.UInt64;
+        fwrite(received_client_msg, sizeof(char), recCount, stdout);
+        fputc('\n', stdout);
+        if(!cptr_equals(received_client_msg, "ping"))
+            throw("received_client_msg != \"ping\"");
+        kprintf("\e[92mmessage received by server\n");
 
+        const char server_msg[] = "pong";
+        tryLast(knSocketUDP_sendTo(socket_server, server_msg, sizeof(server_msg), clientEnd), _mu75q2, ;);
+        char* adrstr = knIPV4Endpoint_toString(&clientEnd);
+        kprintf("\e[92mmessage sent to client (%s)\n\e[94m", adrstr);
+        free(adrstr);
+        fflush(stdout);
+    }
+    // client
+    {
+        char received_server_msg[32];
+        knIPV4Endpoint senderEnd = knIPV4Endpoint_INVALID;
+        tryLast(knSocketUDP_receiveAny(socket_client, received_server_msg, sizeof(received_server_msg), &senderEnd), m_recCount, ;);
+        u64 recCount = m_recCount.value.UInt64;
+        fwrite(received_server_msg, sizeof(char), recCount, stdout);
+        fputc('\n', stdout);
+        if(!cptr_equals(received_server_msg, "pong"))
+            throw("received_server_msg != \"pong\"");
+        char* adrstr = knIPV4Endpoint_toString(&serverEnd);
+        kprintf("\e[92mmessage received by client (%s)\n", adrstr);
+        free(adrstr);
+        fflush(stdout);
+    }
+    // server
+    {
+        tryLast(knSocketUDP_close(socket_server), _m676, ;);
+        kprintf("\e[92mUDP server socket closed\n");
+    }
+    // client
+    {
+        tryLast(knSocketUDP_close(socket_client), _m964, ;);
+        kprintf("\e[92mUDP client socket closed\n");
+    }
     fflush(stdout);
 }