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 "unistd.h" // POSIX Standard
#include "stdio.h"
#include "pthread.h"

#include "sys/socket.h"
#include "arpa/inet.h"
#include "string.h" // memcpy


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

    FILE *input = fopen(cstring(temp.arena, filename), "r");
    string readBuffer;
    if (input) {
        struct stat st;
        stat((char *)filename.str, &st);
        uint64 fsize = st.st_size;
        readBuffer = PushString(arena, fsize);
        fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
        fclose(input);
    } else {
        readBuffer = PushString(arena, 0);
    }

    scratchEnd(temp);
    return readBuffer;
}

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

    bool result = false;
    FILE *output = fopen(cstring(temp.arena, filename), "w");
    if (output) {
        fwrite(contents, sizeof(byte), contentsLength, output);
        fclose(output);
        result = true;
    }

    scratchEnd(temp);
    return result;
}

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

    bool result = false;
    FILE *output = fopen(cstring(temp.arena, filename), "a");
    if (output) {
        fwrite(contents, sizeof(byte), contentsLength, output);
        fclose(output);
        result = true;
    }

    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:
            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);

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

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

Server serverInit(ServerInitInfo info) {
    Arena *arena = arenaAlloc(info.memory);

    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 */),
    };

    int bindErr = bind((int)(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) {
        // TODO(dledda): handle err
    }
}

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->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
    if (clientSock == -1) {
        // TODO(dledda): handle err
    }

    if (s->clients.length < s->clients.capacity) {
        AppendList(&s->clients, ((Socket){
            .handle=(SocketHandle *)(uint64)clientSock,
            .address=(Address *)clientAddr,
        }));
    }

    return &s->clients.data[s->clients.length - 1];
}

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 serverClose(Server *s) {
    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