Apply style changes, abide by strict aliasing

 - Remove internal sending step in packet pool.

Signed-off-by: Andrew Opalach <andrew@akon.city>

9 files changed, 60 insertions, 52 deletions

diff --git a/src/util/buffer.c b/src/util/buffer.c
index 0bd36b4..071d8bf 100644
--- a/src/util/buffer.c
+++ b/src/util/buffer.c
@@ -8,7 +8,7 @@
 void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size)
 {
     if (size > buf->alloc) {
-        buf->alloc = size < NNWT_BUFFER_SIZE ? NNWT_BUFFER_SIZE :
+        buf->alloc = (size < NNWT_BUFFER_SIZE) ? NNWT_BUFFER_SIZE :
             (size + NNWT_BUFFER_GROW) & ~NNWT_BUFFER_GROW;
         buf->data = (u8 *)(buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc));
     }
@@ -48,7 +48,7 @@ void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size)
 
 u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index)
 {
-    return &buf->data[index];
+    return buf->data + index;
 }
 
 void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size)
diff --git a/src/util/buffer.h b/src/util/buffer.h
index 612aae4..9b254d4 100644
--- a/src/util/buffer.h
+++ b/src/util/buffer.h
@@ -9,6 +9,10 @@ struct nn_buffer {
     u8 *data;
 };
 
+// A pun+dereference breaks on 32bit Android but isn't warned about by -Wstrict-aliasing=3.
+#define NNWT_BUFFER_READ_TYPE(buf, index, type, r) \
+    al_memcpy((void *)&(r), (void *)nn_buffer_get_ptr(buf, index), sizeof(type))
+
 void nn_buffer_init(struct nn_buffer *buf);
 void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size);
 size_t nn_buffer_get_size(struct nn_buffer *buf);
diff --git a/src/util/file/file.h b/src/util/file/file.h
index 03b82ba..91aa82c 100644
--- a/src/util/file/file.h
+++ b/src/util/file/file.h
@@ -4,18 +4,22 @@
 #include <al/lib.h>
 
 #ifdef NAUNET_NEEDS_STDIO_ASSIST
-#define _FILE_OFFSET_BITS 64
+// It seems meson adds _FILE_OFFSET_BITS=64 on all "linuxlike" compilers even MinGW.
+// https://github.com/mesonbuild/meson/commit/853634a48da025c59eef70161dba0d150833f60d
+// https://github.com/mesonbuild/meson/issues/12931
+// I don't think we necessarily want this on 32-bit Windows.
 #include <stdio.h>
 #ifdef NAUNET_ON_WINDOWS
+#if _FILE_OFFSET_BITS == 64
 #define fseek _fseeki64
 #define ftell _ftelli64
+#endif
 #else
 #define fseek fseeko
 #define ftell ftello
 #endif
 #else
 #ifdef NAUNET_ON_WINDOWS
-// @TODO:
 #else
 #include <dirent.h>
 #include <fcntl.h>
@@ -43,7 +47,6 @@ struct nn_file {
     FILE *file;
 #else
 #ifdef NAUNET_ON_WINDOWS
-    // @TODO:
 #else
     s32 fd;
 #endif
@@ -56,7 +59,6 @@ struct nn_dir {
 #ifdef NAUNET_NEEDS_STDIO_ASSIST
 #else
 #ifdef NAUNET_ON_WINDOWS
-    // @TODO:
 #else
     DIR *dir;
 #endif
diff --git a/src/util/file/file_linux.c b/src/util/file/file_linux.c
index 5a3621b..c87bc9d 100644
--- a/src/util/file/file_linux.c
+++ b/src/util/file/file_linux.c
@@ -38,13 +38,13 @@ static bool open_file_linux(s32 *fd, str *path, s32 flags)
 bool nn_file_open(struct nn_file *file, str *path, s32 flags)
 {
     file->flags = flags;
-    s32 oflags = flags & NNWT_FILE_READONLY ? O_RDONLY : O_RDWR;
+    s32 oflags = (flags & NNWT_FILE_READONLY) ? O_RDONLY : O_RDWR;
     if (flags & NNWT_FILE_CREATE) {
         oflags |= O_CREAT;
     }
 
     if (!open_file_linux(&file->fd, path, oflags)) {
-        error("open(%.*s) failed (%d: %s).", al_str_fmt(path), errno, nn_strerror(errno));
+        error("open(%.*s) failed (%d: %s).", al_str_x(path), errno, nn_strerror(errno));
         return false;
     }
 
@@ -128,10 +128,10 @@ bool nn_file_read(struct nn_file *file, void *buf, size_t size)
 
 void *nn_file_mmap(struct nn_file *file)
 {
-    s32 flags = PROT_READ | (file->flags & NNWT_FILE_READONLY ? 0 : PROT_WRITE);
+    s32 flags = PROT_READ | ((file->flags & NNWT_FILE_READONLY) ? 0 : PROT_WRITE);
     void *map = mmap(NULL, file->size, flags, MAP_SHARED, file->fd, 0L);
     if (map == MAP_FAILED) {
-        error("mmap(%.*s) failed (%s).", al_str_fmt(&file->path), nn_strerror(errno));
+        error("mmap(%.*s) failed (%s).", al_str_x(&file->path), nn_strerror(errno));
         return NULL;
     }
     return map;
@@ -170,7 +170,7 @@ bool nn_dir_open(struct nn_dir *dir, str *path)
     dir->dir = opendir(c_str);
     al_free(c_str);
     if (!dir->dir) {
-        error("opendir(%.*s) failed (%s).", al_str_fmt(path), nn_strerror(errno));
+        error("opendir(%.*s) failed (%s).", al_str_x(path), nn_strerror(errno));
         return false;
     }
     al_str_clone(&dir->path, path);
@@ -191,7 +191,7 @@ bool nn_dir_exists(str *path)
     al_free(c_str);
     if (!dir) {
         if (errno != ENOENT) {
-            error("opendir(%.*s) failed (%s).", al_str_fmt(path), nn_strerror(errno));
+            error("opendir(%.*s) failed (%s).", al_str_x(path), nn_strerror(errno));
         }
         return false;
     }
@@ -205,7 +205,7 @@ bool nn_dir_create(str *path)
     s32 ret = mkdir(c_str, 0755);
     al_free(c_str);
     if (ret == -1) {
-        error("mkdir(%.*s) failed (%s).", al_str_fmt(path), nn_strerror(errno));
+        error("mkdir(%.*s) failed (%s).", al_str_x(path), nn_strerror(errno));
         return false;
     }
     return true;
@@ -216,7 +216,7 @@ bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry)
     errno = 0;
     if (!(entry->entry = readdir(dir->dir))) {
         if (errno) {
-            error("readdir(%.*s) failed (%s).", al_str_fmt(&dir->path), nn_strerror(errno));
+            error("readdir(%.*s) failed (%s).", al_str_x(&dir->path), nn_strerror(errno));
         }
         return false;
     }
diff --git a/src/util/file/file_stdio.c b/src/util/file/file_stdio.c
index 3f58664..1969477 100644
--- a/src/util/file/file_stdio.c
+++ b/src/util/file/file_stdio.c
@@ -1,13 +1,19 @@
 #define AL_LOG_SECTION "file_stdio"
 #include <al/log.h>
+#include <al/lib.h>
 
 #include "../error.h"
 
-#ifndef NAUNET_NEEDS_STDIO_ASSIST
-#define NAUNET_NEEDS_STDIO_ASSIST
-#endif
 #include "file.h"
 
+/*
+#if defined NAUNET_ON_WINDOWS && defined AL_WE_32BIT
+AL_ASSERT_TYPE_SIZE(off_t, 4);
+#else
+AL_ASSERT_TYPE_SIZE(off_t, 8);
+#endif
+*/
+
 static inline bool open_stdio_file(FILE **file, str *path, const char *mode)
 {
     char *c_str = al_str_to_c_str(path);
@@ -15,7 +21,7 @@ static inline bool open_stdio_file(FILE **file, str *path, const char *mode)
     // Still sets errno, according to the Microsoft docs.
     errno_t ret = fopen_s(file, c_str, mode);
 #else
-    s32 ret = (*file = fopen(c_str, mode)) != NULL ? 0 : errno;
+    s32 ret = (*file = fopen(c_str, mode)) ? 0 : errno;
 #endif
     al_free(c_str);
     return ret == 0;
@@ -32,9 +38,9 @@ static bool query_filesize_stdio(struct nn_file *file)
 
 bool nn_file_open(struct nn_file *file, str *path, s32 flags)
 {
-    const char *mode = flags & NNWT_FILE_CREATE ? "wb+" : "rb+";
+    const char *mode = (flags & NNWT_FILE_CREATE) ? "wb+" : "rb+";
     if (!open_stdio_file(&file->file, path, mode)) {
-        error("fopen(%.*s) failed (%d: %s).", al_str_fmt(path), errno, nn_strerror(errno));
+        error("fopen(%.*s) failed (%d: %s).", al_str_x(path), errno, nn_strerror(errno));
         return false;
     }
 
diff --git a/src/util/packet.c b/src/util/packet.c
index ab2fa83..fe20b58 100644
--- a/src/util/packet.c
+++ b/src/util/packet.c
@@ -27,14 +27,21 @@ void nn_packet_reset(struct nn_packet *packet)
     packet->opaque = NULL;
 }
 
+u32 nn_packet_get_u32(struct nn_packet *packet, u32 index)
+{
+    u32 value;
+    NNWT_BUFFER_READ_TYPE(&packet->buffer, index, u32, value);
+    return value;
+}
+
 void nn_packet_write_size(struct nn_packet *packet)
 {
-    *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0)) = packet->windex;
+    nn_buffer_write(&packet->buffer, &packet->windex, 0, sizeof(u32));
 }
 
 u32 nn_packet_get_size(struct nn_packet *packet)
 {
-    return *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0));
+    return nn_packet_get_u32(packet, 0);
 }
 
 #define DEFINE_PACKET_WRITE_FUNC(type) \
@@ -81,23 +88,12 @@ void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf)
         return r; \
     }
 
-#define DEFINE_PACKET_READ_FUNC_EXT(type) \
-    type nn_packet_peek_##type(struct nn_packet *packet) \
-    { \
-        type r; \
-        NNWT_PACKET_PEEK_TYPE(packet, type, r); \
-        return r; \
-    }
-
 DEFINE_PACKET_READ_FUNC(u8)
-DEFINE_PACKET_READ_FUNC_EXT(u8)
 DEFINE_PACKET_READ_FUNC(s8)
 DEFINE_PACKET_READ_FUNC(u16)
 DEFINE_PACKET_READ_FUNC(s16)
 DEFINE_PACKET_READ_FUNC(u32)
-DEFINE_PACKET_READ_FUNC_EXT(u32)
 DEFINE_PACKET_READ_FUNC(s32)
-DEFINE_PACKET_READ_FUNC_EXT(s32)
 DEFINE_PACKET_READ_FUNC(u64)
 DEFINE_PACKET_READ_FUNC(s64)
 DEFINE_PACKET_READ_FUNC(f32)
diff --git a/src/util/packet.h b/src/util/packet.h
index 5659a70..7183837 100644
--- a/src/util/packet.h
+++ b/src/util/packet.h
@@ -7,7 +7,7 @@
 
 #include "../util/buffer.h"
 
-#define NNWT_PACKET_HEADER_LENGTH (u32)(sizeof(u32))
+#define NNWT_PACKET_HEADER_LENGTH (u32)(sizeof(u32)) // Just size for now.
 
 struct nn_packet {
     struct nn_buffer buffer;
@@ -16,24 +16,18 @@ struct nn_packet {
     void *opaque;
 };
 
-#define NNWT_PACKET_GET_ID(p) \
-    *((u32 *)nn_buffer_get_ptr(&p->buffer, NNWT_PACKET_HEADER_LENGTH + sizeof(s8)))
-
 #define NNWT_PACKET_WRITE_TYPE(p, type, v) \
     nn_buffer_write(&(p)->buffer, &(v), (p)->windex, sizeof(type)); \
     (p)->windex += (u32)sizeof(type)
 
 #define NNWT_PACKET_WRITE_DATA(p, data, length) \
-    nn_buffer_write(&(p)->buffer, (data), (p)->windex, (length)); \
+    nn_buffer_write(&(p)->buffer, data, (p)->windex, length); \
     (p)->windex += (u32)length
 
 #define NNWT_PACKET_READ_TYPE(p, type, r) \
-    r = *((type *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex)); \
+    NNWT_BUFFER_READ_TYPE(&(p)->buffer, (p)->rindex, type, r); \
     (p)->rindex += (u32)sizeof(type)
 
-#define NNWT_PACKET_PEEK_TYPE(p, type, r) \
-    r = *((type *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex))
-
 #define NNWT_PACKET_READ_DATA(p, length, r) \
     r = (void *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex); \
     (p)->rindex += (u32)length
@@ -42,6 +36,8 @@ struct nn_packet *nn_packet_create(void);
 struct nn_packet *nn_packet_clone(struct nn_packet *packet);
 void nn_packet_reset(struct nn_packet *packet);
 
+u32 nn_packet_get_u32(struct nn_packet *packet, u32 index);
+
 void nn_packet_write_size(struct nn_packet *packet);
 u32 nn_packet_get_size(struct nn_packet *packet);
 
@@ -61,14 +57,11 @@ void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf);
 
 bool nn_packet_read_bool(struct nn_packet *packet);
 u8 nn_packet_read_u8(struct nn_packet *packet);
-u8 nn_packet_peek_u8(struct nn_packet *packet);
 s8 nn_packet_read_s8(struct nn_packet *packet);
 u16 nn_packet_read_u16(struct nn_packet *packet);
 s16 nn_packet_read_s16(struct nn_packet *packet);
 u32 nn_packet_read_u32(struct nn_packet *packet);
-u32 nn_packet_peek_u32(struct nn_packet *packet);
 s32 nn_packet_read_s32(struct nn_packet *packet);
-s32 nn_packet_peek_s32(struct nn_packet *packet);
 u64 nn_packet_read_u64(struct nn_packet *packet);
 s64 nn_packet_read_s64(struct nn_packet *packet);
 f32 nn_packet_read_f32(struct nn_packet *packet);
diff --git a/src/util/thread/thread_linux.c b/src/util/thread/thread_linux.c
index f07fcb4..f5b480e 100644
--- a/src/util/thread/thread_linux.c
+++ b/src/util/thread/thread_linux.c
@@ -14,7 +14,8 @@ void nn_thread_sleep(nn_os_tstamp delay)
 
 void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)
 {
-    pthread_create(&thread->thread, NULL, func, userdata);
+    s32 ret = pthread_create(&thread->thread, NULL, func, userdata);
+    al_assert(ret == 0);
 }
 
 void nn_thread_set_priority(s32 policy, s32 priority)
@@ -51,22 +52,27 @@ void nn_thread_detach(struct nn_thread *thread)
 
 void nn_mutex_init(struct nn_mutex *mutex)
 {
-    pthread_mutex_init(&mutex->mutex, NULL);
+    s32 ret = pthread_mutex_init(&mutex->mutex, NULL);
+    // Linux manpage says this always returns 0.
+    al_assert(ret == 0);
 }
 
 void nn_mutex_lock(struct nn_mutex *mutex)
 {
-    pthread_mutex_lock(&mutex->mutex);
+    s32 ret = pthread_mutex_lock(&mutex->mutex);
+    al_assert(ret != EINVAL);
 }
 
 void nn_mutex_unlock(struct nn_mutex *mutex)
 {
-    pthread_mutex_unlock(&mutex->mutex);
+    s32 ret = pthread_mutex_unlock(&mutex->mutex);
+    al_assert(ret != EINVAL);
 }
 
 void nn_mutex_destroy(struct nn_mutex *mutex)
 {
-    pthread_mutex_destroy(&mutex->mutex);
+    s32 ret = pthread_mutex_destroy(&mutex->mutex);
+    al_assert(ret != EBUSY);
 }
 
 void nn_cond_init(struct nn_cond *cond)
@@ -96,5 +102,6 @@ void nn_cond_signal(struct nn_cond *cond)
 
 void nn_cond_destroy(struct nn_cond *cond)
 {
-    pthread_cond_destroy(&cond->cond);
+    s32 ret = pthread_cond_destroy(&cond->cond);
+    al_assert(ret != EBUSY);
 }
diff --git a/src/util/thread/thread_windows.c b/src/util/thread/thread_windows.c
index f1f1dd7..9ce85e2 100644
--- a/src/util/thread/thread_windows.c
+++ b/src/util/thread/thread_windows.c
@@ -4,7 +4,7 @@ NTSTATUS(__stdcall *NtDelayExecution)(BOOL Alertable, PLARGE_INTEGER DelayInterv
 
 void nn_thread_sleep(nn_os_tstamp delay)
 {
-    NtDelayExecution(false, &((LARGE_INTEGER){ .QuadPart = -(LONGLONG)(delay * 1E7L) }));
+    NtDelayExecution(false, &((LARGE_INTEGER){ .QuadPart = -(LONGLONG)(delay * 1e7L) }));
 }
 
 void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)