Move utilities to util/

app/src/util/buffer_util.h

@@ -0,0 +1,46 @@
+#ifndef BUFFER_UTIL_H
+#define BUFFER_UTIL_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "config.h"
+
+static inline void
+buffer_write16be(uint8_t *buf, uint16_t value) {
+    buf[0] = value >> 8;
+    buf[1] = value;
+}
+
+static inline void
+buffer_write32be(uint8_t *buf, uint32_t value) {
+    buf[0] = value >> 24;
+    buf[1] = value >> 16;
+    buf[2] = value >> 8;
+    buf[3] = value;
+}
+
+static inline void
+buffer_write64be(uint8_t *buf, uint64_t value) {
+    buffer_write32be(buf, value >> 32);
+    buffer_write32be(&buf[4], (uint32_t) value);
+}
+
+static inline uint16_t
+buffer_read16be(const uint8_t *buf) {
+    return (buf[0] << 8) | buf[1];
+}
+
+static inline uint32_t
+buffer_read32be(const uint8_t *buf) {
+    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+static inline
+uint64_t buffer_read64be(const uint8_t *buf) {
+    uint32_t msb = buffer_read32be(buf);
+    uint32_t lsb = buffer_read32be(&buf[4]);
+    return ((uint64_t) msb << 32) | lsb;
+}
+
+#endif

app/src/util/cbuf.h

@@ -0,0 +1,52 @@
+// generic circular buffer (bounded queue) implementation
+#ifndef CBUF_H
+#define CBUF_H
+
+#include <stdbool.h>
+#include <unistd.h>
+
+#include "config.h"
+
+// To define a circular buffer type of 20 ints:
+//     struct cbuf_int CBUF(int, 20);
+//
+// data has length CAP + 1 to distinguish empty vs full.
+#define CBUF(TYPE, CAP) { \
+    TYPE data[(CAP) + 1]; \
+    size_t head; \
+    size_t tail; \
+}
+
+#define cbuf_size_(PCBUF) \
+    (sizeof((PCBUF)->data) / sizeof(*(PCBUF)->data))
+
+#define cbuf_is_empty(PCBUF) \
+    ((PCBUF)->head == (PCBUF)->tail)
+
+#define cbuf_is_full(PCBUF) \
+    (((PCBUF)->head + 1) % cbuf_size_(PCBUF) == (PCBUF)->tail)
+
+#define cbuf_init(PCBUF) \
+    (void) ((PCBUF)->head = (PCBUF)->tail = 0)
+
+#define cbuf_push(PCBUF, ITEM) \
+    ({ \
+        bool ok = !cbuf_is_full(PCBUF); \
+        if (ok) { \
+            (PCBUF)->data[(PCBUF)->head] = (ITEM); \
+            (PCBUF)->head = ((PCBUF)->head + 1) % cbuf_size_(PCBUF); \
+        } \
+        ok; \
+    })
+
+#define cbuf_take(PCBUF, PITEM) \
+    ({ \
+        bool ok = !cbuf_is_empty(PCBUF); \
+        if (ok) { \
+            *(PITEM) = (PCBUF)->data[(PCBUF)->tail]; \
+            (PCBUF)->tail = ((PCBUF)->tail + 1) % cbuf_size_(PCBUF); \
+        } \
+        ok; \
+    })
+
+#endif

app/src/util/lock.h

@@ -0,0 +1,52 @@
+#ifndef LOCK_H
+#define LOCK_H
+
+#include <stdint.h>
+#include <SDL2/SDL_mutex.h>
+
+#include "config.h"
+#include "log.h"
+
+static inline void
+mutex_lock(SDL_mutex *mutex) {
+    if (SDL_LockMutex(mutex)) {
+        LOGC("Could not lock mutex");
+        abort();
+    }
+}
+
+static inline void
+mutex_unlock(SDL_mutex *mutex) {
+    if (SDL_UnlockMutex(mutex)) {
+        LOGC("Could not unlock mutex");
+        abort();
+    }
+}
+
+static inline void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    if (SDL_CondWait(cond, mutex)) {
+        LOGC("Could not wait on condition");
+        abort();
+    }
+}
+
+static inline int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond, mutex, ms);
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout");
+        abort();
+    }
+    return r;
+}
+
+static inline void
+cond_signal(SDL_cond *cond) {
+    if (SDL_CondSignal(cond)) {
+        LOGC("Could not signal a condition");
+        abort();
+    }
+}
+
+#endif

app/src/util/log.h

@@ -0,0 +1,13 @@
+#ifndef LOG_H
+#define LOG_H
+
+#include <SDL2/SDL_log.h>
+
+#define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGW(...) SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+
+#endif

app/src/util/net.c

@@ -0,0 +1,117 @@
+#include "net.h"
+
+#include <stdio.h>
+
+#include "config.h"
+#include "log.h"
+
+#ifdef __WINDOWS__
+  typedef int socklen_t;
+#else
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <unistd.h>
+# define SOCKET_ERROR -1
+  typedef struct sockaddr_in SOCKADDR_IN;
+  typedef struct sockaddr SOCKADDR;
+  typedef struct in_addr IN_ADDR;
+#endif
+
+socket_t
+net_connect(uint32_t addr, uint16_t port) {
+    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+        perror("socket");
+        return INVALID_SOCKET;
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr);
+    sin.sin_port = htons(port);
+
+    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        perror("connect");
+        net_close(sock);
+        return INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+socket_t
+net_listen(uint32_t addr, uint16_t port, int backlog) {
+    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+        perror("socket");
+        return INVALID_SOCKET;
+    }
+
+    int reuse = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
+                   sizeof(reuse)) == -1) {
+        perror("setsockopt(SO_REUSEADDR)");
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
+    sin.sin_port = htons(port);
+
+    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        perror("bind");
+        net_close(sock);
+        return INVALID_SOCKET;
+    }
+
+    if (listen(sock, backlog) == SOCKET_ERROR) {
+        perror("listen");
+        net_close(sock);
+        return INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+socket_t
+net_accept(socket_t server_socket) {
+    SOCKADDR_IN csin;
+    socklen_t sinsize = sizeof(csin);
+    return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
+}
+
+ssize_t
+net_recv(socket_t socket, void *buf, size_t len) {
+    return recv(socket, buf, len, 0);
+}
+
+ssize_t
+net_recv_all(socket_t socket, void *buf, size_t len) {
+    return recv(socket, buf, len, MSG_WAITALL);
+}
+
+ssize_t
+net_send(socket_t socket, const void *buf, size_t len) {
+    return send(socket, buf, len, 0);
+}
+
+ssize_t
+net_send_all(socket_t socket, const void *buf, size_t len) {
+    ssize_t w = 0;
+    while (len > 0) {
+        w = send(socket, buf, len, 0);
+        if (w == -1) {
+            return -1;
+        }
+        len -= w;
+        buf = (char *) buf + w;
+    }
+    return w;
+}
+
+bool
+net_shutdown(socket_t socket, int how) {
+    return !shutdown(socket, how);
+}

app/src/util/net.h

@@ -0,0 +1,57 @@
+#ifndef NET_H
+#define NET_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <SDL2/SDL_platform.h>
+
+#ifdef __WINDOWS__
+# include <winsock2.h>
+  #define SHUT_RD SD_RECEIVE
+  #define SHUT_WR SD_SEND
+  #define SHUT_RDWR SD_BOTH
+  typedef SOCKET socket_t;
+#else
+# include <sys/socket.h>
+# define INVALID_SOCKET -1
+  typedef int socket_t;
+#endif
+
+#include "config.h"
+
+bool
+net_init(void);
+
+void
+net_cleanup(void);
+
+socket_t
+net_connect(uint32_t addr, uint16_t port);
+
+socket_t
+net_listen(uint32_t addr, uint16_t port, int backlog);
+
+socket_t
+net_accept(socket_t server_socket);
+
+// the _all versions wait/retry until len bytes have been written/read
+ssize_t
+net_recv(socket_t socket, void *buf, size_t len);
+
+ssize_t
+net_recv_all(socket_t socket, void *buf, size_t len);
+
+ssize_t
+net_send(socket_t socket, const void *buf, size_t len);
+
+ssize_t
+net_send_all(socket_t socket, const void *buf, size_t len);
+
+// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
+bool
+net_shutdown(socket_t socket, int how);
+
+bool
+net_close(socket_t socket);
+
+#endif

app/src/util/queue.h

@@ -0,0 +1,77 @@
+// generic intrusive FIFO queue
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <SDL2/SDL_assert.h>
+
+#include "config.h"
+
+// To define a queue type of "struct foo":
+//    struct queue_foo QUEUE(struct foo);
+#define QUEUE(TYPE) { \
+    TYPE *first; \
+    TYPE *last; \
+}
+
+#define queue_init(PQ) \
+    (void) ((PQ)->first = (PQ)->last = NULL)
+
+#define queue_is_empty(PQ) \
+    !(PQ)->first
+
+// NEXTFIELD is the field in the ITEM type used for intrusive linked-list
+//
+// For example:
+//    struct foo {
+//        int value;
+//        struct foo *next;
+//    };
+//
+//    // define the type "struct my_queue"
+//    struct my_queue QUEUE(struct foo);
+//
+//    struct my_queue queue;
+//    queue_init(&queue);
+//
+//    struct foo v1 = { .value = 42 };
+//    struct foo v2 = { .value = 27 };
+//
+//    queue_push(&queue, next, v1);
+//    queue_push(&queue, next, v2);
+//
+//    struct foo *foo;
+//    queue_take(&queue, next, &foo);
+//    assert(foo->value == 42);
+//    queue_take(&queue, next, &foo);
+//    assert(foo->value == 27);
+//    assert(queue_is_empty(&queue));
+//
+
+// push a new item into the queue
+#define queue_push(PQ, NEXTFIELD, ITEM) \
+    (void) ({ \
+        (ITEM)->NEXTFIELD = NULL; \
+        if (queue_is_empty(PQ)) { \
+            (PQ)->first = (PQ)->last = (ITEM); \
+        } else { \
+            (PQ)->last->NEXTFIELD = (ITEM); \
+            (PQ)->last = (ITEM); \
+        } \
+    })
+
+// take the next item and remove it from the queue (the queue must not be empty)
+// the result is stored in *(PITEM)
+// (without typeof(), we could not store a local variable having the correct
+// type so that we can "return" it)
+#define queue_take(PQ, NEXTFIELD, PITEM) \
+    (void) ({ \
+        SDL_assert(!queue_is_empty(PQ)); \
+        *(PITEM) = (PQ)->first; \
+        (PQ)->first = (PQ)->first->NEXTFIELD; \
+    })
+    // no need to update (PQ)->last if the queue is left empty:
+    // (PQ)->last is undefined if !(PQ)->first anyway
+
+#endif

app/src/util/str_util.c

@@ -0,0 +1,113 @@
+#include "str_util.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+# include <windows.h>
+# include <tchar.h>
+#endif
+
+#include <SDL2/SDL_stdinc.h>
+
+#include "config.h"
+
+size_t
+xstrncpy(char *dest, const char *src, size_t n) {
+    size_t i;
+    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
+        dest[i] = src[i];
+    if (n)
+        dest[i] = '\0';
+    return src[i] == '\0' ? i : n;
+}
+
+size_t
+xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
+    const char *const *remaining = tokens;
+    const char *token = *remaining++;
+    size_t i = 0;
+    while (token) {
+        if (i) {
+            dst[i++] = sep;
+            if (i == n)
+                goto truncated;
+        }
+        size_t w = xstrncpy(dst + i, token, n - i);
+        if (w >= n - i)
+            goto truncated;
+        i += w;
+        token = *remaining++;
+    }
+    return i;
+
+truncated:
+    dst[n - 1] = '\0';
+    return n;
+}
+
+char *
+strquote(const char *src) {
+    size_t len = strlen(src);
+    char *quoted = SDL_malloc(len + 3);
+    if (!quoted) {
+        return NULL;
+    }
+    memcpy(&quoted[1], src, len);
+    quoted[0] = '"';
+    quoted[len + 1] = '"';
+    quoted[len + 2] = '\0';
+    return quoted;
+}
+
+size_t
+utf8_truncation_index(const char *utf8, size_t max_len) {
+    size_t len = strlen(utf8);
+    if (len <= max_len) {
+        return len;
+    }
+    len = max_len;
+    // see UTF-8 encoding <https://en.wikipedia.org/wiki/UTF-8#Description>
+    while ((utf8[len] & 0x80) != 0 && (utf8[len] & 0xc0) != 0xc0) {
+        // the next byte is not the start of a new UTF-8 codepoint
+        // so if we would cut there, the character would be truncated
+        len--;
+    }
+    return len;
+}
+
+#ifdef _WIN32
+
+wchar_t *
+utf8_to_wide_char(const char *utf8) {
+    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+    if (!len) {
+        return NULL;
+    }
+
+    wchar_t *wide = SDL_malloc(len * sizeof(wchar_t));
+    if (!wide) {
+        return NULL;
+    }
+
+    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
+    return wide;
+}
+
+char *
+utf8_from_wide_char(const wchar_t *ws) {
+    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
+    if (!len) {
+        return NULL;
+    }
+
+    char *utf8 = SDL_malloc(len);
+    if (!utf8) {
+        return NULL;
+    }
+
+    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
+    return utf8;
+}
+
+#endif

app/src/util/str_util.h

@@ -0,0 +1,42 @@
+#ifndef STRUTIL_H
+#define STRUTIL_H
+
+#include <stddef.h>
+
+#include "config.h"
+
+// like strncpy, except:
+//  - it copies at most n-1 chars
+//  - the dest string is nul-terminated
+//  - it does not write useless bytes if strlen(src) < n
+//  - it returns the number of chars actually written (max n-1) if src has
+//    been copied completely, or n if src has been truncated
+size_t
+xstrncpy(char *dest, const char *src, size_t n);
+
+// join tokens by sep into dst
+// returns the number of chars actually written (max n-1) if no trucation
+// occurred, or n if truncated
+size_t
+xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
+
+// quote a string
+// returns the new allocated string, to be freed by the caller
+char *
+strquote(const char *src);
+
+// return the index to truncate a UTF-8 string at a valid position
+size_t
+utf8_truncation_index(const char *utf8, size_t max_len);
+
+#ifdef _WIN32
+// convert a UTF-8 string to a wchar_t string
+// returns the new allocated string, to be freed by the caller
+wchar_t *
+utf8_to_wide_char(const char *utf8);
+
+char *
+utf8_from_wide_char(const wchar_t *s);
+#endif
+
+#endif