isomorfeus-iodine 0.7.44

data/ext/iodine/redis_engine.h

@@ -0,0 +1,79 @@
+/*
+Copyright: Boaz segev, 2016-2019
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_REDIS_ENGINE_H
+#define H_REDIS_ENGINE_H
+
+#include <fio.h>
+#include <fiobj.h>
+
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** possible arguments for the `redis_engine_create` function call */
+struct redis_engine_create_args {
+  /** Redis server's address, defaults to localhost. */
+  fio_str_info_s address;
+  /** Redis server's port, defaults to 6379. */
+  fio_str_info_s port;
+  /** Redis server's password, if any. */
+  fio_str_info_s auth;
+  /** A `ping` will be sent every `ping_interval` interval or inactivity. */
+  uint8_t ping_interval;
+};
+
+/**
+ * See the {fio.h} file for documentation about engines.
+ *
+ * The engine is active only after facil.io starts running.
+ *
+ * A `ping` will be sent every `ping_interval` interval or inactivity. The
+ * default value (0) will fallback to facil.io's maximum time of inactivity (5
+ * minutes) before polling on the connection's protocol.
+ *
+ * function names speak for themselves ;-)
+ *
+ * Note: The Redis engine assumes it will stay alive until all the messages and
+ * callbacks have been called (or facil.io exits)... If the engine is destroyed
+ * midway, memory leaks might occur (and little puppies might cry).
+ */
+fio_pubsub_engine_s *redis_engine_create(struct redis_engine_create_args);
+#define redis_engine_create(...)                                               \
+  redis_engine_create((struct redis_engine_create_args){__VA_ARGS__})
+
+/**
+ * Sends a Redis command through the engine's connection.
+ *
+ * The response will be sent back using the optional callback. `udata` is passed
+ * along untouched.
+ *
+ * The message will be resent on network failures, until a response validates
+ * the fact that the command was sent (or the engine is destroyed).
+ *
+ * Note: NEVER call Pub/Sub commands using this function, as it will violate the
+ * Redis connection's protocol (best case scenario, a disconnection will occur
+ * before and messages are lost).
+ */
+intptr_t redis_engine_send(fio_pubsub_engine_s *engine, FIOBJ command,
+                           void (*callback)(fio_pubsub_engine_s *e, FIOBJ reply,
+                                            void *udata),
+                           void *udata);
+
+/**
+ * See the {pubsub.h} file for documentation about engines.
+ *
+ * function names speak for themselves ;-)
+ */
+void redis_engine_destroy(fio_pubsub_engine_s *engine);
+
+/* support C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H_REDIS_ENGINE_H */

data/ext/iodine/resp_parser.h

@@ -0,0 +1,317 @@
+/*
+Copyright: Boaz segev, 2016-2019
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_RESP_PARSER_H
+/**
+ * This single file library is a RESP parser for Redis connections.
+ *
+ * To use this file, the `.c` file in which this file is included MUST define a
+ * number of callbacks, as later inticated.
+ *
+ * When feeding the parser, the parser will inform of any trailing bytes (bytes
+ * at the end of the buffer that could not be parsed). These bytes should be
+ * resent to the parser along with more data. Zero is a valid return value.
+ *
+ * Note: mostly, callback return vaslues are ignored.
+ */
+#define H_RESP_PARSER_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* *****************************************************************************
+The Parser
+***************************************************************************** */
+
+typedef struct resp_parser_s {
+  /* for internal use - (array / object countdown) */
+  intptr_t obj_countdown;
+  /* for internal use - (string byte consumption) */
+  intptr_t expecting;
+} resp_parser_s;
+
+/**
+ * Returns the number of bytes to be resent. i.e., for a return value 5, the
+ * last 5 bytes in the buffer need to be resent to the parser.
+ */
+static size_t resp_parse(resp_parser_s *parser, const void *buffer,
+                         size_t length);
+
+/* *****************************************************************************
+Required Parser Callbacks (to be defined by the including file)
+***************************************************************************** */
+
+/** a local static callback, called when the RESP message is complete. */
+static int resp_on_message(resp_parser_s *parser);
+
+/** a local static callback, called when a Number object is parsed. */
+static int resp_on_number(resp_parser_s *parser, int64_t num);
+/** a local static callback, called when a OK message is received. */
+static int resp_on_okay(resp_parser_s *parser);
+/** a local static callback, called when NULL is received. */
+static int resp_on_null(resp_parser_s *parser);
+
+/**
+ * a local static callback, called when a String should be allocated.
+ *
+ * `str_len` is the expected number of bytes that will fill the final string
+ * object, without any NUL byte marker (the string might be binary).
+ *
+ * If this function returns any value besides 0, parsing is stopped.
+ */
+static int resp_on_start_string(resp_parser_s *parser, size_t str_len);
+/** a local static callback, called as String objects are streamed. */
+static int resp_on_string_chunk(resp_parser_s *parser, void *data, size_t len);
+/** a local static callback, called when a String object had finished streaming.
+ */
+static int resp_on_end_string(resp_parser_s *parser);
+
+/** a local static callback, called an error message is received. */
+static int resp_on_err_msg(resp_parser_s *parser, void *data, size_t len);
+
+/**
+ * a local static callback, called when an Array should be allocated.
+ *
+ * `array_len` is the expected number of objects that will fill the Array
+ * object.
+ *
+ * There's no `resp_on_end_array` callback since the RESP protocol assumes the
+ * message is finished along with the Array (`resp_on_message` is called).
+ * However, just in case a non-conforming client/server sends nested Arrays, the
+ * callback should test against possible overflow or nested Array endings.
+ *
+ * If this function returns any value besides 0, parsing is stopped.
+ */
+static int resp_on_start_array(resp_parser_s *parser, size_t array_len);
+
+/** a local static callback, called when a parser / protocol error occurs. */
+static int resp_on_parser_error(resp_parser_s *parser);
+
+/* *****************************************************************************
+Seeking the new line...
+***************************************************************************** */
+
+#if FIO_MEMCHAR
+
+/**
+ * This seems to be faster on some systems, especially for smaller distances.
+ *
+ * On newer systems, `memchr` should be faster.
+ */
+static inline int seek2ch(uint8_t **buffer, register const uint8_t *limit,
+                          const uint8_t c) {
+  if (**buffer == c)
+    return 1;
+
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+  /* too short for this mess */
+  if ((uintptr_t)limit <= 16 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
+    goto finish;
+
+  /* align memory */
+  {
+    const uint8_t *alignment =
+        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+    if (limit >= alignment) {
+      while (*buffer < alignment) {
+        if (**buffer == c)
+          return 1;
+        *buffer += 1;
+      }
+    }
+  }
+  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+#else
+  const uint8_t *limit64 = (uint8_t *)limit - 7;
+#endif
+  uint64_t wanted1 = 0x0101010101010101ULL * c;
+  for (; *buffer < limit64; *buffer += 8) {
+    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
+    if ((t0 & t1)) {
+      break;
+    }
+  }
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+finish:
+#endif
+  while (*buffer < limit) {
+    if (**buffer == c)
+      return 1;
+    (*buffer)++;
+  }
+  return 0;
+}
+
+#else
+
+/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
+inline static uint8_t seek2ch(uint8_t **pos, const uint8_t *limit, uint8_t ch) {
+  /* This is library based alternative that is sometimes slower  */
+  if (*pos >= limit || **pos == ch) {
+    return 0;
+  }
+  uint8_t *tmp = (uint8_t *)memchr(*pos, ch, limit - (*pos));
+  if (tmp) {
+    *pos = tmp;
+    return 1;
+  }
+  *pos = (uint8_t *)limit;
+  return 0;
+}
+
+#endif
+
+/* *****************************************************************************
+Parsing RESP requests
+***************************************************************************** */
+
+/**
+ * Returns the number of bytes to be resent. i.e., for a return value 5, the
+ * last 5 bytes in the buffer need to be resent to the parser.
+ */
+static size_t resp_parse(resp_parser_s *parser, const void *buffer,
+                         size_t length) {
+  if (!parser->obj_countdown)
+    parser->obj_countdown = 1; /* always expect something... */
+  uint8_t *pos = (uint8_t *)buffer;
+  const uint8_t *stop = pos + length;
+  while (pos < stop) {
+    uint8_t *eol;
+    if (parser->expecting) {
+      if (pos + parser->expecting + 2 > stop) {
+        /* read, but make sure the buffer includes the new line markers */
+        size_t tmp = (size_t)((uintptr_t)stop - (uintptr_t)pos);
+        if ((intptr_t)tmp >= parser->expecting)
+          tmp = parser->expecting - 1;
+        resp_on_string_chunk(parser, (void *)pos, tmp);
+        parser->expecting -= tmp;
+        return (size_t)((uintptr_t)stop - ((uintptr_t)pos + tmp)); /* 0 or 1 */
+      } else {
+        resp_on_string_chunk(parser, (void *)pos, parser->expecting);
+        resp_on_end_string(parser);
+        pos += parser->expecting;
+        if (pos[0] == '\r')
+          ++pos;
+        if (pos[0] == '\n')
+          ++pos;
+        parser->expecting = 0;
+        --parser->obj_countdown;
+        if (parser->obj_countdown <= 0) {
+          parser->obj_countdown = 1;
+          if (resp_on_message(parser))
+            goto finish;
+        }
+        continue;
+      }
+    }
+    eol = pos;
+    if (seek2ch(&eol, stop, '\n') == 0)
+      break;
+    switch (*pos) {
+    case '+':
+      if (pos[1] == 'O' && pos[2] == 'K' && pos[3] == '\r' && pos[4] == '\n') {
+        resp_on_okay(parser);
+        --parser->obj_countdown;
+        break;
+      }
+      if (resp_on_start_string(parser,
+                               (size_t)((uintptr_t)eol - (uintptr_t)pos - 2))) {
+        pos = eol + 1;
+        goto finish;
+      }
+      resp_on_string_chunk(parser, (void *)(pos + 1),
+                           (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
+      resp_on_end_string(parser);
+      --parser->obj_countdown;
+      break;
+    case '-':
+      resp_on_err_msg(parser, pos,
+                      (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
+      --parser->obj_countdown;
+      break;
+    case '*': /* fallthrough */
+    case '$': /* fallthrough */
+    case ':': {
+      uint8_t id = *pos;
+      uint8_t inv = 0;
+      int64_t i = 0;
+      ++pos;
+      if (pos[0] == '-') {
+        inv = 1;
+        ++pos;
+      }
+      while ((size_t)(pos[0] - (uint8_t)'0') <= 9) {
+        i = (i * 10) + (pos[0] - ((uint8_t)'0'));
+        ++pos;
+      }
+      if (inv)
+        i = i * -1;
+
+      switch (id) {
+      case ':':
+        resp_on_number(parser, i);
+        --parser->obj_countdown;
+        break;
+      case '$':
+        if (i < 0) {
+          resp_on_null(parser);
+          --parser->obj_countdown;
+        } else if (i == 0) {
+          resp_on_start_string(parser, 0);
+          resp_on_end_string(parser);
+          --parser->obj_countdown;
+          eol += 2; /* consume the extra "\r\n" */
+        } else {
+          if (resp_on_start_string(parser, i)) {
+            pos = eol + 1;
+            goto finish;
+          }
+          parser->expecting = i;
+        }
+        break;
+      case '*':
+        if (i < 0) {
+          resp_on_null(parser);
+        } else {
+          if (resp_on_start_array(parser, i)) {
+            pos = eol + 1;
+            goto finish;
+          }
+          parser->obj_countdown += i;
+        }
+        --parser->obj_countdown;
+        break;
+      }
+    } break;
+    default:
+      if (!parser->obj_countdown && !parser->expecting) {
+        /* possible (probable) inline command... for server authoring. */
+        /* Not Supported, PRs are welcome. */
+        resp_on_parser_error(parser);
+        return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+      } else {
+        resp_on_parser_error(parser);
+        return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+      }
+    }
+    pos = eol + 1;
+    if (parser->obj_countdown <= 0 && !parser->expecting) {
+      parser->obj_countdown = 1;
+      resp_on_message(parser);
+    }
+  }
+finish:
+  return (size_t)((uintptr_t)stop - (uintptr_t)pos);
+}
+
+#endif /* H_RESP_PARSER_H */