improving sockets, fixed some bugs

app.c

@@ -2,51 +2,102 @@
 
 #include "core.c"
 #include "signal.h"
+#include "stdlib.h"
 
 Server *server = NULL;
 
 void handleSigint(int dummy) {
     if (server) {
-        print("\n");
+        println("");
-        print("Closing server socket.\n");
+        println("Closing server socket.");
         serverClose(server);
-        print("Success\n.");
+        println("Success.");
     }
-    exit(0);
+    signal(SIGINT, SIG_DFL);
+    raise(SIGINT);
 }
 
 int djstd_entry(Arena *arena, StringList args) {
     signal(SIGINT, &handleSigint);
 
+    bool isServer = strEql(args.data[0], s("server"));
+    bool isClient = strEql(args.data[0], s("client"));
+
+    if (!isServer && !isClient || args.length < 2) {
+        println("Usage: [type] [port] ([remote_address])");
+        println("[type] is either 'server' or 'client'");
+        println("[remote_address] can be given if a client app, default is loopback");
+        return 0;
+    }
+
     int port = 8080;
-    Int32Result portParsed = parsePositiveInt(args.data[0]);
+    Int32Result portParsed = parsePositiveInt(args.data[1]);
     if (portParsed.valid) {
         port = portParsed.result;
     }
 
-    print("Starting server on port %d\n", port);
+    string addr = s("::1");
-    Server myserver = serverInit((ServerInitInfo){
+    if (!isServer && args.length > 2) {
-        .concurrentClients=16,
+        if (args.data[2].length > 0) {
-        .port=port,
+            addr = args.data[2];
-        .memory=Megabytes(64),
+        }
-    });
-
-    server = &myserver;
-
-    serverListen(&myserver);
-    Client *client = serverAccept(&myserver);
-
-    CharList buf = PushFullListZero(arena, CharList, 257);
-    uint64 bytesRead = clientRead(client, (void *)buf.data, buf.length - 1);
-
-    if (bytesRead > 0) {
-        print("Client said: %s\n", buf.data);
-        print("Now that's insightful.\n");
-    } else if (bytesRead == -1) {
-        print("Connection error\n");
     }
 
-    clientClose(client);
+    if (isServer) {
+        println("Starting server on port %d", port);
+        Server myserver = serverInit((ServerInitInfo){
+            .concurrentClients=16,
+            .port=port,
+            .memory=Megabytes(64),
+        });
+
+        server = &myserver;
+
+        serverListen(&myserver);
+        Socket *client = serverAccept(&myserver);
+
+        forever {
+            string buf = PushStringFill(arena, 256, 0);
+            uint64 bytesRead = socketRead(client, buf.str, buf.length - 1);
+
+            if (bytesRead > 0) {
+                buf.length = bytesRead;
+                println("Client said: %S", strSplit(arena, s("\n"), buf).data[0]);
+
+                println("Saying goodbye");
+                string message = s("Goodbye\n");
+                socketWrite(client, message.str, message.length);
+                break;
+            }
+            serverClose(&myserver);
+        }
+
+        socketClose(client);
+    } else {
+        println("Connecting to socket at %S on port %d", addr, port);
+        Socket sock = socketConnect(arena, (SocketConnectInfo){ .address=addr, .port=port });
+        println("CONNECTED");
+
+        string message;
+        uint64 bytesWritten;
+
+        string buf = PushStringFill(arena, 256, 0);
+
+        forever {
+            message = s("Howdy partner\n");
+            print("Saying: %S", message);
+            bytesWritten = socketWrite(&sock, message.str, message.length);
+
+            socketRead(&sock, buf.str, buf.length);
+            message = strSplit(arena, s("\n"), buf).data[0];
+            println("Received message: %S", message);
+            if (strEql(message, s("Goodbye"))) {
+                println("Quitting");
+                break;
+            }
+        }
+        socketClose(&sock);
+    }
 
     return 0;
 }

core.c

@@ -71,9 +71,6 @@ Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
     return scratch;
 }
 
-#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
-#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
-
 void scratchEnd(Scratch scratch) {
     arenaFreeFrom(scratch.arena, scratch.start);
 }
@@ -206,8 +203,8 @@ StringList strSplit(Arena *arena, string splitStr, string inputStr) {
         size_t splitCount = 0;
         size_t c = 0;
         size_t start = 0;
-        void *beginning = (char *)arena->memory + arena->head;
+        void *beginning = arena->memory + arena->head;
-        while (c < inputStr.length - splitStr.length) {
+        while (c < inputStr.length) {
             string mystr = strSlice(inputStr, c, c + splitStr.length);
             if (strEql(mystr, splitStr)) {
                 string *splitString = PushStruct(arena, string);
@@ -337,13 +334,20 @@ string formatTimeYmd(Arena *arena, Timestamp *time) {
     return buf;
 }
 
-void printStderr(const char *fmt, ...) {
+function void printStderr(const char *fmt, ...) {
     va_list argList;
     va_start(argList, fmt);
     os_print(StdStream_stdout, fmt, argList);
     va_end(argList);
 }
 
+function void printlnStderr(const char *fmt, ...) {
+    va_list argList;
+    va_start(argList, fmt);
+    os_println(StdStream_stdout, fmt, argList);
+    va_end(argList);
+}
+
 function void printStdout(const char *fmt, ...) {
     va_list argList;
     va_start(argList, fmt);
@@ -351,8 +355,27 @@ function void printStdout(const char *fmt, ...) {
     va_end(argList);
 }
 
+function void printlnStdout(const char *fmt, ...) {
+    va_list argList;
+    va_start(argList, fmt);
+    os_println(StdStream_stdout, fmt, argList);
+    va_end(argList);
+}
+
 void (*print)(const char *fmt, ...) = &printStdout;
-#define SetStdErr() DeferLoop(print = &printStderr, print = &printStdout)
+void (*println)(const char *fmt, ...) = &printlnStdout;
+
+void setStdout() {
+    print = &printStdout;
+    println = &printlnStdout;
+}
+
+void setStderr() {
+    print = &printStderr;
+    println = &printlnStderr;
+}
+
+#define UseStderr() DeferLoop(setStderr(), setStdout())
 
 // TODO(dledda): mat print functions
 /*

core.h

@@ -16,6 +16,9 @@
 #define function static
 #define global static
 #define local_persist static
+#define forever for (;;)
+
+#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
 
 // ### Types ###
 typedef int8_t int8;
@@ -26,7 +29,7 @@ typedef uint8_t uint8;
 typedef uint16_t uint16;
 typedef uint32_t uint32;
 typedef uint64_t uint64;
-typedef uint8_t byte;
+typedef char byte;
 typedef float real32;
 typedef double real64;
 typedef struct string string;
@@ -76,6 +79,7 @@ void scratchEnd(Scratch scratch);
 #define PushArrayZero(arena, type, size) (type *)pushSizeFill(arena, sizeof(type) * (size), 0)
 #define PushStruct(arena, type) (type *)pushSize(arena, sizeof(type))
 #define PushStructZero(arena, type) (type *)pushSizeFill(arena, sizeof(type), 0)
+#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
 
 // ### Vectors ###
 typedef union Vec2 Vec2;
@@ -300,7 +304,10 @@ typedef enum {
 DefineList(int, Int);
 void printIntList(IntList l);
 void printStrList(StringList l);
+void setStdout();
+void setStderr();
 extern void (*print)(const char *fmt, ...);
+extern void (*println)(const char *fmt, ...);
 
 // ### Loops ###
 #define EachIn(list, it) size_t it = 0; it < (list).length; it++

os.h

@@ -4,18 +4,19 @@
 #include "core.h"
 
 // ### Memory ###
-void *os_alloc(size_t capacity);
+void *os_alloc(uint64 capacity);
 void os_reserve(void *ptr);
 void os_decommit(void *ptr);
-void os_free(void *ptr, size_t freeSize);
+void os_free(void *ptr, uint64 freeSize);
 
 // ### File IO ###
 string os_readEntireFile(Arena *arena, string filename);
-bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength);
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
-bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength);
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
 
 // ### Standard IO ###
 void os_print(StdStream target, const char *fmt, va_list argList);
+void os_println(StdStream target, const char *fmt, va_list argList);
 
 // ### Multithreading ###
 typedef struct OS_Thread OS_Thread;
@@ -29,23 +30,24 @@ OS_Thread os_createThread(void *(*entry)(void *ctx), void *ctx);
 typedef struct Address Address;
 struct Address;
 
-typedef struct Socket Socket;
+typedef struct SocketHandle SocketHandle;
-struct Socket;
+struct SocketHandle;
 
-typedef struct Client Client;
+typedef struct Socket Socket;
-struct Client {
+struct Socket {
-    Address *clientAddressData;
+    const Address *address;
-    Socket *socket;
+    SocketHandle *handle;
+    bool closed;
 };
-DefineList(Client, Client);
+DefineList(Socket, Socket);
 
 typedef struct Server Server;
 struct Server {
     Arena *arena;
-    Address *serverAddressData;
+    Address *address;
-    uint32 serverPort;
+    uint32 port;
-    Socket *socket;
+    SocketHandle *handle;
-    ClientList clients;
+    SocketList clients;
     bool listening;
 };
 
@@ -56,13 +58,23 @@ struct ServerInitInfo {
     uint64 memory;
 };
 
+typedef struct SocketConnectInfo SocketConnectInfo;
+struct SocketConnectInfo {
+    string address;
+    uint16 port;
+};
+
+
+// Server/Client interface
 Server serverInit(ServerInitInfo info);
 void serverListen(Server *s);
-Client *serverAccept(Server *s);
+Socket *serverAccept(Server *s);
 void serverClose(Server *s);
 
-uint64 clientRead(Client *client, void *dest, size_t bytes);
+// Generic socket interface
-void clientWrite(Client *client);
+Socket socketConnect(Arena *arena, SocketConnectInfo info);
-void clientClose(Client *client);
+int64 socketRead(Socket *s, byte *dest, uint64 numBytes);
+int64 socketWrite(Socket *s, byte *source, uint64 numBytes);
+void socketClose(Socket *s);
 
 #endif

os_linux.c

@@ -10,12 +10,11 @@
 #include "pthread.h"
 
 #include "sys/socket.h"
-#include "netinet/in.h"
-#include "stdlib.h"
 #include "arpa/inet.h"
+#include "string.h" // memcpy
 
 
-void *os_alloc(size_t capacity) {
+void *os_alloc(uint64 capacity) {
     return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 }
 
@@ -25,7 +24,7 @@ void os_commit(void *ptr) {
 void os_decommit(void *ptr) {
 }
 
-void os_free(void *ptr, size_t size) {
+void os_free(void *ptr, uint64 size) {
     int err = munmap(ptr, size);
     Assert(err != -1);
 }
@@ -38,7 +37,7 @@ string os_readEntireFile(Arena *arena, string filename) {
     if (input) {
         struct stat st;
         stat((char *)filename.str, &st);
-        size_t fsize = st.st_size;
+        uint64 fsize = st.st_size;
         readBuffer = PushString(arena, fsize);
         fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
         fclose(input);
@@ -50,7 +49,7 @@ string os_readEntireFile(Arena *arena, string filename) {
     return readBuffer;
 }
 
-bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
     Scratch temp = scratchStart(&arena, 1);
 
     bool result = false;
@@ -65,7 +64,7 @@ bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, siz
     return result;
 }
 
-bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
     Scratch temp = scratchStart(&arena, 1);
 
     bool result = false;
@@ -80,6 +79,36 @@ bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t c
     return result;
 }
 
+void os_println(StdStream target, const char *fmt, va_list argList) {
+    Scratch temp = scratchStart(0, 0);
+
+    uint64 origLen = calcStringLen(fmt);
+    string fmtLn = PushString(temp.arena, origLen + 2);
+    memcpy(fmtLn.str, fmt, origLen);
+
+    fmtLn.str[fmtLn.length - 2] = '\n';
+    fmtLn.str[fmtLn.length - 1] = '\0';
+
+    string result = strPrintfv(temp.arena, fmtLn.str, argList);
+    // TODO(djledda): finish implementation without cstdlib
+    switch (target) {
+        case StdStream_stdin:
+            write(0, (const void *)result.str, result.length);
+            break;
+        case StdStream_stderr:
+            fflush(stderr);
+            write(2, (const void *)result.str, result.length);
+            break;
+        case StdStream_stdout:
+        default:
+            fflush(stdout);
+            write(1, (const void *)result.str, result.length);
+            break;
+    }
+
+    scratchEnd(temp);
+}
+
 void os_print(StdStream target, const char *fmt, va_list argList) {
     Scratch temp = scratchStart(0, 0);
 
@@ -122,14 +151,14 @@ Server serverInit(ServerInitInfo info) {
 
     Server server = {
         .arena=arena,
-        .serverAddressData=(Address *)serverAddr,
+        .address=(Address *)serverAddr,
-        .clients=PushListZero(arena, ClientList, info.concurrentClients),
+        .clients=PushListZero(arena, SocketList, info.concurrentClients),
         .listening=false,
-        .serverPort=info.port,
+        .port=info.port,
-        .socket=(Socket *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
+        .handle=(SocketHandle *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
     };
 
-    int bindErr = bind((int)(uint64)server.socket, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
+    int bindErr = bind((int)(uint64)server.handle, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
     if (bindErr == -1) {
         // TODO(dledda): handle err
     }
@@ -138,48 +167,70 @@ Server serverInit(ServerInitInfo info) {
 }
 
 void serverListen(Server *s) {
-    int listenErr = listen((uint64)s->socket, s->clients.capacity);
+    int listenErr = listen((uint64)s->handle, s->clients.capacity);
     if (listenErr == -1) {
         // TODO(dledda): handle err
     }
 }
 
-Client *serverAccept(Server *s) {
+Socket *serverAccept(Server *s) {
     struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
     socklen_t clientAddrLen = sizeof(*clientAddr);
 
-    uint64 clientSock = accept((int)(uint64)s->socket, (struct sockaddr *)clientAddr, &clientAddrLen);
+    uint64 clientSock = accept((int)(uint64)s->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
     if (clientSock == -1) {
         // TODO(dledda): handle err
     }
 
     if (s->clients.length < s->clients.capacity) {
-        AppendList(&s->clients, ((Client){
+        AppendList(&s->clients, ((Socket){
-            .socket=(Socket *)(uint64)clientSock,
+            .handle=(SocketHandle *)(uint64)clientSock,
-            .clientAddressData=(Address *)clientAddr,
+            .address=(Address *)clientAddr,
         }));
     }
 
     return &s->clients.data[s->clients.length - 1];
 }
 
-uint64 clientRead(Client *client, void *dest, size_t bytes) {
+int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
-    int bytesRead = read((uint64)client->socket, dest, bytes);
+    int64 bytesRead = read((uint64)socket->handle, dest, numBytes);
     if (bytesRead == -1) {
         // TODO(dledda): handle err
     }
     return bytesRead;
 }
 
-void clientWrite(Client *client) {
-}
-
-void clientClose(Client *client) {
-    close((int)(uint64)client->socket);
-}
-
 void serverClose(Server *s) {
-    close((int)(uint64)s->socket);
+    close((int)(uint64)s->handle);
+}
+
+void socketClose(Socket *s) {
+    close((int)(uint64)s->handle);
+}
+
+Socket socketConnect(Arena *arena, SocketConnectInfo info) {
+    int socketFd = socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */);
+    struct sockaddr_in6 *remoteAddr = PushStructZero(arena, struct sockaddr_in6);
+    remoteAddr->sin6_family = AF_INET6;
+    inet_pton(AF_INET6, cstring(arena, info.address), &remoteAddr->sin6_addr);
+    remoteAddr->sin6_port = htons(info.port);
+    int connectErr = connect(socketFd, (struct sockaddr *)remoteAddr, sizeof(*remoteAddr));
+    Socket result = {
+        .handle=(SocketHandle *)(uint64)socketFd,
+        .address=(Address *)remoteAddr,
+        .closed=false,
+    };
+    if (connectErr == -1) {
+        // TODO(dledda): handle err
+        result.closed = true;
+    }
+    return result;
+}
+
+int64 socketWrite(Socket *socket, byte *source, uint64 numBytes) {
+    int64 written = send((uint64)socket->handle, source, numBytes, MSG_NOSIGNAL);
+    if (written == -1) socket->closed = true;
+    return written;
 }
 
 #endif