improving sockets, fixed some bugs

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,
-        .clients=PushListZero(arena, ClientList, info.concurrentClients),
+        .address=(Address *)serverAddr,
+        .clients=PushListZero(arena, SocketList, info.concurrentClients),
         .listening=false,
-        .serverPort=info.port,
-        .socket=(Socket *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
+        .port=info.port,
+        .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){
-            .socket=(Socket *)(uint64)clientSock,
-            .clientAddressData=(Address *)clientAddr,
+        AppendList(&s->clients, ((Socket){
+            .handle=(SocketHandle *)(uint64)clientSock,
+            .address=(Address *)clientAddr,
         }));
     }
 
     return &s->clients.data[s->clients.length - 1];
 }
 
-uint64 clientRead(Client *client, void *dest, size_t bytes) {
-    int bytesRead = read((uint64)client->socket, dest, bytes);
+int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
+    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