djstdlib/os_linux.c

#ifndef OS_IMPL_LINUX_C
#define OS_IMPL_LINUX_C

#include "os.h"

#include "sys/mman.h"
#include "sys/stat.h"
#include "string.h" // memcpy TODO(dledda): replace memcpy with custom impl?
#include "unistd.h" // POSIX Standard, read, write, close, open, etc.

#include "pthread.h"

#include "fcntl.h"
#include "sys/epoll.h"
#include "sys/socket.h"
#include "arpa/inet.h"


void *os_alloc(uint64 capacity) {
    return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}

void os_commit(void *ptr) {
}

void os_decommit(void *ptr) {
}

void os_free(void *ptr, uint64 size) {
    int err = munmap(ptr, size);
    Assert(err != -1);
}

string os_readEntireFile(Arena *arena, string filename) {
    Scratch temp = scratchStart(&arena, 1);

    int input = open(cstring(temp.arena, filename), O_RDONLY);
    string readBuffer;
    if (input) {
        struct stat st;
        stat((char *)filename.str, &st);
        uint64 fsize = st.st_size;
        readBuffer = PushString(arena, fsize);
        int64 bytesRead = read(input, readBuffer.str, readBuffer.length);
        close(input);
        if (bytesRead == -1) {
            arenaPopTo(arena, readBuffer.str);
            return s("");
        }
    } else {
        readBuffer = s("");
    }

    scratchEnd(temp);
    return readBuffer;
}

bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
    Scratch temp = scratchStart(&arena, 1);

    bool result = false;
    int output = open(cstring(temp.arena, filename), O_WRONLY);
    if (output) {
        int64 bytesWritten = write(output, contents, contentsLength);
        if (bytesWritten != -1) {
            result = true;
        }
        close(output);
    }

    scratchEnd(temp);
    return result;
}

bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
    Scratch temp = scratchStart(&arena, 1);

    bool result = false;
    int output = open(cstring(temp.arena, filename), O_APPEND);
    if (output) {
        int bytesWritten = write(output, contents, contentsLength);
        if (bytesWritten != -1) {
            result = true;
        }
        close(output);
    }

    scratchEnd(temp);
    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:
            write(2, (const void *)result.str, result.length);
            break;
        case StdStream_stdout:
        default:
            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);

    string result = strPrintfv(temp.arena, fmt, argList);
    // TODO(djledda): finish implementation without cstdlib
    switch (target) {
        case StdStream_stdin:
            write(0, (const void *)result.str, result.length);
            break;
        case StdStream_stderr:
            write(2, (const void *)result.str, result.length);
            break;
        case StdStream_stdout:
        default:
            write(1, (const void *)result.str, result.length);
            break;
    }

    scratchEnd(temp);
}

OS_Thread os_createThread(void *(*entry)(void *), void *ctx) {
    pthread_t handle;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_create(&handle, &attr, entry, ctx);
    pthread_attr_destroy(&attr);
    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) {
    Arena *arena = arenaAlloc(info.memory);

    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;
    serverAddr->sin6_port = htons(info.port);
    serverAddr->sin6_addr = in6addr_loopback;

    Server server = {
        .arena=arena,
        .address=(Address *)serverAddr,
        .clients=PushListZero(arena, SocketList, info.concurrentClients),
        .listening=false,
        .port=info.port,
        .handle=(SocketHandle *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
        .events=(ServerEvents *)events,
    };

    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
    }

    return server;
}

void serverListen(Server *s) {
    int listenErr = listen((uint64)s->handle, s->clients.capacity);
    if (listenErr == -1) {
        s->listening = false;
    } else {
        s->listening = true;
    }
}

Socket *serverAccept(Server *s) {
    struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
    socklen_t clientAddrLen = sizeof(*clientAddr);

    uint64 clientSockHandle = accept((int)(uint64)s->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
    if (clientSockHandle == -1) {
        clientSockHandle = (uint64)NULL;
    } 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,
            .address=(Address *)clientAddr,
        }));
        return &s->clients.data[s->clients.length - 1];
    } else {
        return PushStructZero(s->arena, Socket);
    }
}

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) {
        // TODO(dledda): handle err
    }
    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 */);
    if (!info.blocking) {
        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,
        // TODO(dledda): investigate error behaviour
    };

    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;
}

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