feat: add initial libhopper client library

Author: OldUser101

client/lib.c

@@ -1,5 +1,122 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #include "hopper/hopper.h"
 
-void hello() { printf("hello world\n"); }
+int get_open_flags(int flags) {
+    int open_flags = 0;
+
+    if (flags & HOPPER_IN)
+        open_flags |= O_WRONLY;
+    if (flags & HOPPER_OUT)
+        open_flags |= O_RDONLY;
+    if (flags & HOPPER_NONBLOCK)
+        open_flags |= O_NONBLOCK;
+
+    return open_flags;
+}
+
+char *get_pipe_path(struct hopper_pipe *pipe) {
+    char *path = (char *)malloc(sizeof(char) * PATH_MAX);
+    const char *suffix = (pipe->flags & HOPPER_IN ? "in" : "out");
+
+    // {HOPPER}/{ENDPOINT}/{NAME}.{TYPE}
+    sprintf(path, "%s/%s/%s.%s", pipe->hopper, pipe->endpoint, pipe->name,
+            suffix);
+
+    return path;
+}
+
+int hopper_open(struct hopper_pipe *pipe) {
+    int res = 0;
+
+    if (pipe->name == NULL || pipe->endpoint == NULL) {
+        // pipe and endpoint name are (obviously) required
+        errno = EINVAL;
+        return -1;
+    }
+
+    if ((pipe->flags & HOPPER_IN && pipe->flags & HOPPER_OUT) ||
+        (pipe->flags & ~HOPPER_IN && pipe->flags & ~HOPPER_OUT)) {
+        // either both or none of the input/output flags are set
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (pipe->hopper == NULL) {
+        // hopper path isn't overridden, get from environment
+        pipe->hopper = getenv("HOPPER_PATH");
+
+        if (pipe->hopper == NULL) {
+            // still don't have a valid path, can't open pipe
+            errno = ENOENT;
+            return -1;
+        }
+    }
+
+    char *pipe_path = get_pipe_path(pipe);
+    if (mknod(pipe_path, S_IFIFO | 0660, 0) < 0 && errno != EEXIST) {
+        // mknod failed in some way, preserve errno
+        res = -1;
+        goto cleanup;
+    }
+
+    int open_flags = get_open_flags(pipe->flags);
+    int fd = open(pipe_path, open_flags);
+    if (fd < 0) {
+        // preserve errno if open fails
+        res = -1;
+        goto cleanup;
+    }
+
+    // acquire a file lock on the fifo, we don't want other things using it
+    if (flock(fd, (pipe->flags & HOPPER_IN ? LOCK_EX : LOCK_SH) | LOCK_NB) !=
+        0) {
+        if (errno == EWOULDBLOCK)
+            errno = EBUSY; // this makes more sense for clients
+
+        res = -1;
+        close(fd);
+        goto cleanup;
+    }
+
+    pipe->fd = fd;
+
+cleanup:
+    free(pipe_path);
+    if (res != 0)
+        pipe->fd = -1;
+
+    return res;
+}
+
+void hopper_close(struct hopper_pipe *pipe) {
+    if (pipe->fd == -1)
+        return;
+
+    flock(pipe->fd, LOCK_UN);
+    close(pipe->fd);
+
+    pipe->fd = -1;
+}
+
+ssize_t hopper_read(struct hopper_pipe *pipe, void *dst, size_t len) {
+    ssize_t res = read(pipe->fd, dst, len);
+    if (res < 0 && errno == EWOULDBLOCK)
+        return 0; // EWOULDBLOCK isn't an error for non-block pipes
+    return res;
+}
+
+ssize_t hopper_write(struct hopper_pipe *pipe, void *src, size_t len) {
+    ssize_t res = write(pipe->fd, src, len);
+    if (res < 0 && errno == EWOULDBLOCK)
+        return 0; // EWOULDBLOCK isn't an error for non-block pipes
+    return res;
+}
+

include/hopper/hopper.h

@@ -1,6 +1,37 @@
 #ifndef hopper_h_INCLUDED
 #define hopper_h_INCLUDED
 
-void hello();
+#include <unistd.h>
+
+#define HOPPER_IN 1
+#define HOPPER_OUT 2
+#define HOPPER_NONBLOCK 4
+
+/// Structure representing a Hopper pipe
+struct hopper_pipe {
+    const char *name;
+    const char *endpoint;
+    const char *hopper;
+    int fd;
+    int flags;
+};
+
+/// Open a new Hopper pipe specified by `pipe`.
+/// Hopper location will be determined from the `HOPPER_PATH` environment
+/// variable, or can be overridden with the `hopper_pipe.hopper` string.
+/// -1 is returned on error, and errno is set.
+int hopper_open(struct hopper_pipe *pipe);
+
+/// Close a Hopper pipe previously opened by `hopper_open_pipe`.
+void hopper_close(struct hopper_pipe *pipe);
+
+/// Read up to `len` bytes from a Hopper pipe. Value returned indicates
+/// the number of bytes read. -1 is returned on error and errno is set.
+ssize_t hopper_read(struct hopper_pipe *pipe, void *dst, size_t len);
+
+/// Write up to `len` bytes into a Hopper pipe. Value returned indicates
+/// the number of bytes written. -1 is returned on error and errno is set.
+ssize_t hopper_write(struct hopper_pipe *pipe, void *src, size_t len);
 
 #endif // hopper_h_INCLUDED
+