working chat app example with some rough edges

os_linux.c

@@ -143,9 +143,15 @@ OS_Thread os_createThread(void *(*entry)(void *), void *ctx) {
     return (OS_Thread){ .id=handle };
 }
 
+DefineList(ServerEvent, ServerEvent);
 typedef struct EPollServerEvents EPollServerEvents;
 struct EPollServerEvents {
     int epollFd;
+    int32 maxEvents;
+    int32 numEvents;
+    struct epoll_event *events;
+    bool err;
+    ServerEventList userEvents;
 };
 
 Server serverInit(ServerInitInfo info) {
@@ -153,6 +159,10 @@ Server serverInit(ServerInitInfo info) {
 
     EPollServerEvents *events = PushStructZero(arena, EPollServerEvents);
     events->epollFd = epoll_create1(0);
+    events->events = PushArrayZero(arena, struct epoll_event, info.maxEvents);
+    events->maxEvents = info.maxEvents;
+    events->numEvents = 0;
+    events->userEvents = PushListZero(arena, ServerEventList, info.maxEvents);
 
     struct sockaddr_in6 *serverAddr = PushStructZero(arena, struct sockaddr_in6);
     serverAddr->sin6_family = AF_INET6;
@@ -171,6 +181,12 @@ Server serverInit(ServerInitInfo info) {
 
     fcntl((uint64)server.handle, F_SETFL, fcntl((uint64)server.handle, F_GETFL, 0) | O_NONBLOCK);
 
+    struct epoll_event event = {
+        .data.fd=(uint64)server.handle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    epoll_ctl(events->epollFd, EPOLL_CTL_ADD, (int64)server.handle, &event);
+
     int bindErr = bind((uint64)server.handle, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
     if (bindErr == -1) {
         // TODO(dledda): handle err
@@ -182,7 +198,9 @@ Server serverInit(ServerInitInfo info) {
 void serverListen(Server *s) {
     int listenErr = listen((uint64)s->handle, s->clients.capacity);
     if (listenErr == -1) {
-        // TODO(dledda): handle err ?
+        s->listening = false;
+    } else {
+        s->listening = true;
     }
 }
 
@@ -193,10 +211,18 @@ Socket *serverAccept(Server *s) {
     uint64 clientSockHandle = accept((int)(uint64)s->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
     if (clientSockHandle == -1) {
         clientSockHandle = (uint64)NULL;
+        println("ERR server accept");
+        perror("accept");
     } else {
         fcntl((uint64)clientSockHandle, F_SETFL, fcntl((uint64)clientSockHandle, F_GETFL, 0) | O_NONBLOCK);
     }
 
+    struct epoll_event event = {
+        .data.fd=clientSockHandle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    epoll_ctl(((EPollServerEvents *)s->events)->epollFd, EPOLL_CTL_ADD, clientSockHandle, &event);
+
     if (s->clients.length < s->clients.capacity) {
         AppendList(&s->clients, ((Socket){
             .handle=(SocketHandle *)(uint64)clientSockHandle,
@@ -208,6 +234,58 @@ Socket *serverAccept(Server *s) {
     }
 }
 
+ServerEvent *serverGetNextEvent(Server *s) {
+    EPollServerEvents *serverEvents = ((EPollServerEvents *)s->events);
+
+    if (serverEvents->userEvents.length == 0) {
+        serverEvents->numEvents = epoll_wait(serverEvents->epollFd, serverEvents->events, serverEvents->maxEvents, -1);
+        if (serverEvents->numEvents == -1) {
+            serverEvents->err = true;
+            serverEvents->numEvents = 0;
+        } else {
+            serverEvents->userEvents.length = serverEvents->numEvents;
+            for (int32 i = 0; i < serverEvents->numEvents; i++) {
+                struct epoll_event *ev = &serverEvents->events[i];
+                if ((ev->events & EPOLLIN) && ev->data.fd == (int)(int64)s->handle) {
+                    serverEvents->userEvents.data[i] = (ServerEvent){
+                        .type=ServerEventType_AcceptClient,
+                        .tAcceptClient={},
+                    };
+                } else if (ev->events & EPOLLIN) {
+                    int64 fd = serverEvents->events[i].data.fd;
+                    Socket *client = NULL;
+                    ServerEvent serverEv = {
+                        .type=ServerEventType_ClientMessage,
+                    };
+
+                    for (EachIn(s->clients, j)) {
+                        if ((int64)s->clients.data[j].handle == fd) {
+                            client = &s->clients.data[j];
+                            serverEv.tClientMessage.client = client;
+                            serverEv.tClientMessage.clientId = j;
+                        }
+                    }
+
+                    if (client == NULL) {
+                        serverEv.type = ServerEventType_None;
+                    } else {
+                        serverEvents->userEvents.data[i] = serverEv;
+                    }
+                }
+            }
+        }
+
+    }
+
+    if (serverEvents->userEvents.length == 0) {
+        AppendList(&serverEvents->userEvents, (ServerEvent){ .type=ServerEventType_None });
+    }
+
+    // Pop next event
+    serverEvents->userEvents.length--;
+    return &serverEvents->userEvents.data[serverEvents->userEvents.length];
+}
+
 int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
     int64 bytesRead = read((uint64)socket->handle, dest, numBytes);
     if (bytesRead == -1) {
@@ -216,30 +294,66 @@ int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
     return bytesRead;
 }
 
+StringResult socketReadStr(Arena *arena, Socket *socket) {
+    byte *dest = PushArray(arena, byte, Kilobytes(256));
+    int64 bytesRead = read((uint64)socket->handle, dest, Kilobytes(1024));
+    bool err = bytesRead == -1 || bytesRead == 0;
+    if (err) {
+        arenaPopTo(arena, dest);
+    } else {
+        arenaPopTo(arena, dest + bytesRead);
+    }
+    return (StringResult){
+        .valid=!err,
+        .result=(string){
+            .str=dest,
+            .length=err ? 0 : bytesRead,
+        },
+    };
+}
+
 void serverClose(Server *s) {
     close((int)(uint64)s->handle);
 }
 
+bool serverHangupClient(Server *s, Socket *client) {
+    struct epoll_event eventUnsubscribe = {
+        .data.fd=(int)(int64)client->handle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    int err = epoll_ctl(((EPollServerEvents *)s->events)->epollFd, EPOLL_CTL_DEL, (int)(int64)client->handle, &eventUnsubscribe);
+    if (err == 0) {
+        for (EachIn(s->clients, i)) {
+            if (s->clients.data[i].handle == client->handle) {
+                ListRemove(&s->clients, i);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 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 */);
+    fcntl(socketFd, F_SETFL, fcntl(socketFd, F_GETFL, 0) | O_NONBLOCK);
+
     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,
+        //.closed=connectErr == -1,
     };
-    if (connectErr == -1) {
-        // TODO(dledda): handle err
-        result.closed = true;
-    }
+
     return result;
 }
 
@@ -249,4 +363,10 @@ int64 socketWrite(Socket *socket, byte *source, uint64 numBytes) {
     return written;
 }
 
+int64 socketWriteStr(Socket *socket, string data) {
+    int64 written = send((uint64)socket->handle, data.str, data.length, MSG_NOSIGNAL);
+    if (written == -1) socket->closed = true;
+    return written;
+}
+
 #endif