opal-up 0.0.4 → 0.0.5

data/ext/up_ext/ProxyParser.h

@@ -25,139 +25,140 @@
 namespace uWS {
 
 struct proxy_hdr_v2 {
-    uint8_t sig[12];  /* hex 0D 0A 0D 0A 00 0D 0A 51 55 49 54 0A */
-    uint8_t ver_cmd;  /* protocol version and command */
-    uint8_t fam;      /* protocol family and address */
-    uint16_t len;     /* number of following bytes part of the header */
+  uint8_t sig[12]; /* hex 0D 0A 0D 0A 00 0D 0A 51 55 49 54 0A */
+  uint8_t ver_cmd; /* protocol version and command */
+  uint8_t fam;     /* protocol family and address */
+  uint16_t len;    /* number of following bytes part of the header */
 };
 
 union proxy_addr {
-    struct {        /* for TCP/UDP over IPv4, len = 12 */
-        uint32_t src_addr;
-        uint32_t dst_addr;
-        uint16_t src_port;
-        uint16_t dst_port;
-    } ipv4_addr;
-    struct {        /* for TCP/UDP over IPv6, len = 36 */
-            uint8_t  src_addr[16];
-            uint8_t  dst_addr[16];
-            uint16_t src_port;
-            uint16_t dst_port;
-    } ipv6_addr;
+  struct { /* for TCP/UDP over IPv4, len = 12 */
+    uint32_t src_addr;
+    uint32_t dst_addr;
+    uint16_t src_port;
+    uint16_t dst_port;
+  } ipv4_addr;
+  struct { /* for TCP/UDP over IPv6, len = 36 */
+    uint8_t src_addr[16];
+    uint8_t dst_addr[16];
+    uint16_t src_port;
+    uint16_t dst_port;
+  } ipv6_addr;
 };
 
 /* Byte swap for little-endian systems */
 /* Todo: This functions should be shared with the one in WebSocketProtocol.h! */
-template <typename T>
-T _cond_byte_swap(T value) {
-    uint32_t endian_test = 1;
-    if (*((char *)&endian_test)) {
-        union {
-            T i;
-            uint8_t b[sizeof(T)];
-        } src = { value }, dst;
-
-        for (unsigned int i = 0; i < sizeof(value); i++) {
-            dst.b[i] = src.b[sizeof(value) - 1 - i];
-        }
-
-        return dst.i;
+template <typename T> T _cond_byte_swap(T value) {
+  uint32_t endian_test = 1;
+  if (*((char *)&endian_test)) {
+    union {
+      T i;
+      uint8_t b[sizeof(T)];
+    } src = {value}, dst;
+
+    for (unsigned int i = 0; i < sizeof(value); i++) {
+      dst.b[i] = src.b[sizeof(value) - 1 - i];
     }
-    return value;
+
+    return dst.i;
+  }
+  return value;
 }
 
 struct ProxyParser {
 private:
-    union proxy_addr addr;
+  union proxy_addr addr;
 
-    /* Default family of 0 signals no proxy address */
-    uint8_t family = 0;
+  /* Default family of 0 signals no proxy address */
+  uint8_t family = 0;
 
 public:
-    /* Returns 4 or 16 bytes source address */
-    std::string_view getSourceAddress() {
-
-        // UNSPEC family and protocol
-        if (family == 0) {
-            return {};
-        }
-
-        if ((family & 0xf0) >> 4 == 1) {
-            /* Family 1 is INET4 */
-            return {(char *) &addr.ipv4_addr.src_addr, 4};
-        } else {
-            /* Family 2 is INET6 */
-            return {(char *) &addr.ipv6_addr.src_addr, 16};
-        }
+  /* Returns 4 or 16 bytes source address */
+  std::string_view getSourceAddress() {
+
+    // UNSPEC family and protocol
+    if (family == 0) {
+      return {};
     }
 
-    /* Returns [done, consumed] where done = false on failure */
-    std::pair<bool, unsigned int> parse(std::string_view data) {
+    if ((family & 0xf0) >> 4 == 1) {
+      /* Family 1 is INET4 */
+      return {(char *)&addr.ipv4_addr.src_addr, 4};
+    } else {
+      /* Family 2 is INET6 */
+      return {(char *)&addr.ipv6_addr.src_addr, 16};
+    }
+  }
 
-        /* We require at least four bytes to determine protocol */
-        if (data.length() < 4) {
-            return {false, 0};
-        }
+  /* Returns [done, consumed] where done = false on failure */
+  std::pair<bool, unsigned int> parse(std::string_view data) {
 
-        /* HTTP can never start with "\r\n\r\n", but PROXY always does */
-        if (memcmp(data.data(), "\r\n\r\n", 4)) {
-            /* This is HTTP, so be done */
-            return {true, 0};
-        }
+    /* We require at least four bytes to determine protocol */
+    if (data.length() < 4) {
+      return {false, 0};
+    }
 
-        /* We assume we are parsing PROXY V2 here */
+    /* HTTP can never start with "\r\n\r\n", but PROXY always does */
+    if (memcmp(data.data(), "\r\n\r\n", 4)) {
+      /* This is HTTP, so be done */
+      return {true, 0};
+    }
 
-        /* We require 16 bytes here */
-        if (data.length() < 16) {
-            return {false, 0};
-        }
+    /* We assume we are parsing PROXY V2 here */
 
-        /* Header is 16 bytes */
-        struct proxy_hdr_v2 header;
-        memcpy(&header, data.data(), 16);
+    /* We require 16 bytes here */
+    if (data.length() < 16) {
+      return {false, 0};
+    }
 
-        if (memcmp(header.sig, "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A", 12)) {
-            /* This is not PROXY protocol at all */
-            return {false, 0};
-        }
+    /* Header is 16 bytes */
+    struct proxy_hdr_v2 header;
+    memcpy(&header, data.data(), 16);
 
-        /* We only support version 2 */
-        if ((header.ver_cmd & 0xf0) >> 4 != 2) {
-            return {false, 0};
-        }
+    if (memcmp(header.sig, "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A",
+               12)) {
+      /* This is not PROXY protocol at all */
+      return {false, 0};
+    }
 
-        //printf("Version: %d\n", (header.ver_cmd & 0xf0) >> 4);
-        //printf("Command: %d\n", (header.ver_cmd & 0x0f));
+    /* We only support version 2 */
+    if ((header.ver_cmd & 0xf0) >> 4 != 2) {
+      return {false, 0};
+    }
+
+    // printf("Version: %d\n", (header.ver_cmd & 0xf0) >> 4);
+    // printf("Command: %d\n", (header.ver_cmd & 0x0f));
 
-        /* We get length in network byte order (todo: share this function with the rest) */
-        uint16_t hostLength = _cond_byte_swap<uint16_t>(header.len);
+    /* We get length in network byte order (todo: share this function with the
+     * rest) */
+    uint16_t hostLength = _cond_byte_swap<uint16_t>(header.len);
 
-        /* We must have all the data available */
-        if (data.length() < 16u + hostLength) {
-            return {false, 0};
-        }
+    /* We must have all the data available */
+    if (data.length() < 16u + hostLength) {
+      return {false, 0};
+    }
 
-        /* Payload cannot be more than sizeof proxy_addr */
-        if (sizeof(proxy_addr) < hostLength) {
-            return {false, 0};
-        }
+    /* Payload cannot be more than sizeof proxy_addr */
+    if (sizeof(proxy_addr) < hostLength) {
+      return {false, 0};
+    }
 
-        //printf("Family: %d\n", (header.fam & 0xf0) >> 4);
-        //printf("Transport: %d\n", (header.fam & 0x0f));
+    // printf("Family: %d\n", (header.fam & 0xf0) >> 4);
+    // printf("Transport: %d\n", (header.fam & 0x0f));
 
-        /* We have 0 family by default, and UNSPEC is 0 as well */
-        family = header.fam;
+    /* We have 0 family by default, and UNSPEC is 0 as well */
+    family = header.fam;
 
-        /* Copy payload */
-        memcpy(&addr, data.data() + 16, hostLength);
+    /* Copy payload */
+    memcpy(&addr, data.data() + 16, hostLength);
 
-        /* We consumed everything */
-        return {true, 16 + hostLength};
-    }
+    /* We consumed everything */
+    return {true, 16 + hostLength};
+  }
 };
 
-}
+} // namespace uWS
 
 #endif
 
-#endif // UWS_PROXY_PARSER_H
+#endif // UWS_PROXY_PARSER_H

data/ext/up_ext/QueryParser.h

@@ -24,97 +24,104 @@
 
 namespace uWS {
 
-    /* Takes raw query including initial '?' sign. Will inplace decode, so input will mutate */
-    static inline std::string_view getDecodedQueryValue(std::string_view key, std::string_view rawQuery) {
+/* Takes raw query including initial '?' sign. Will inplace decode, so input
+ * will mutate */
+static inline std::string_view getDecodedQueryValue(std::string_view key,
+                                                    std::string_view rawQuery) {
+
+  /* Can't have a value without a key */
+  if (!key.length()) {
+    return {};
+  }
+
+  /* Start with the whole querystring including initial '?' */
+  std::string_view queryString = rawQuery;
+
+  /* List of key, value could be cached for repeated fetches similar to how
+   * headers are, todo! */
+  while (queryString.length()) {
+    /* Find boundaries of this statement */
+    std::string_view statement =
+        queryString.substr(1, queryString.find('&', 1) - 1);
+
+    /* Only bother if first char of key match (early exit) */
+    if (statement.length() && statement[0] == key[0]) {
+      /* Equal sign must be present and not in the end of statement */
+      auto equality = statement.find('=');
+      if (equality != std::string_view::npos) {
+
+        std::string_view statementKey = statement.substr(0, equality);
+        std::string_view statementValue = statement.substr(equality + 1);
+
+        /* String comparison */
+        if (key == statementKey) {
+
+          /* Decode value inplace, put null at end if before length of original
+           */
+          char *in = (char *)statementValue.data();
+
+          /* Write offset */
+          unsigned int out = 0;
+
+          /* Walk over all chars until end or null char, decoding in place */
+          for (unsigned int i = 0; i < statementValue.length() && in[i]; i++) {
+            /* Only bother with '%' */
+            if (in[i] == '%') {
+              /* Do we have enough data for two bytes hex? */
+              if (i + 2 >= statementValue.length()) {
+                return {};
+              }
+
+              /* Two bytes hex */
+              int hex1 = in[i + 1] - '0';
+              if (hex1 > 9) {
+                hex1 &= 223;
+                hex1 -= 7;
+              }
+
+              int hex2 = in[i + 2] - '0';
+              if (hex2 > 9) {
+                hex2 &= 223;
+                hex2 -= 7;
+              }
+
+              *((unsigned char *)&in[out]) = (unsigned char)(hex1 * 16 + hex2);
+              i += 2;
+            } else {
+              /* Is this even a rule? */
+              if (in[i] == '+') {
+                in[out] = ' ';
+              } else {
+                in[out] = in[i];
+              }
+            }
 
-        /* Can't have a value without a key */
-        if (!key.length()) {
-            return {};
-        }
+            /* We always only write one char */
+            out++;
+          }
 
-        /* Start with the whole querystring including initial '?' */
-        std::string_view queryString = rawQuery;
-
-        /* List of key, value could be cached for repeated fetches similar to how headers are, todo! */
-        while (queryString.length()) {
-            /* Find boundaries of this statement */
-            std::string_view statement = queryString.substr(1, queryString.find('&', 1) - 1);
-
-            /* Only bother if first char of key match (early exit) */
-            if (statement.length() && statement[0] == key[0]) {
-                /* Equal sign must be present and not in the end of statement */
-                auto equality = statement.find('=');
-                if (equality != std::string_view::npos) {
-
-                    std::string_view statementKey = statement.substr(0, equality);
-                    std::string_view statementValue = statement.substr(equality + 1);
-
-                    /* String comparison */
-                    if (key == statementKey) {
-
-                        /* Decode value inplace, put null at end if before length of original */
-                        char *in = (char *) statementValue.data();
-
-                        /* Write offset */
-                        unsigned int out = 0;
-
-                        /* Walk over all chars until end or null char, decoding in place */
-                        for (unsigned int i = 0; i < statementValue.length() && in[i]; i++) {
-                                /* Only bother with '%' */
-                                if (in[i] == '%') {
-                                    /* Do we have enough data for two bytes hex? */
-                                    if (i + 2 >= statementValue.length()) {
-                                        return {};
-                                    }
-
-                                    /* Two bytes hex */
-                                    int hex1 = in[i + 1] - '0';
-                                    if (hex1 > 9) {
-                                        hex1 &= 223;
-                                        hex1 -= 7;
-                                    }
-
-                                    int hex2 = in[i + 2] - '0';
-                                    if (hex2 > 9) {
-                                        hex2 &= 223;
-                                        hex2 -= 7;
-                                    }
-
-                                    *((unsigned char *) &in[out]) = (unsigned char) (hex1 * 16 + hex2);
-                                    i += 2;
-                                } else {
-                                    /* Is this even a rule? */
-                                    if (in[i] == '+') {
-                                        in[out] = ' ';
-                                    } else {
-                                        in[out] = in[i];
-                                    }
-                                }
-
-                                /* We always only write one char */
-                                out++;
-                        }
-
-                        /* If decoded string is shorter than original, put null char to stop next read */
-                        if (out < statementValue.length()) {
-                            in[out] = 0;
-                        }
-
-                        return statementValue.substr(0, out);
-                    }
-                } else {
-                    /* This querystring is invalid, cannot parse it */
-                    return {nullptr, 0};
-                }
-            }
+          /* If decoded string is shorter than original, put null char to stop
+           * next read */
+          if (out < statementValue.length()) {
+            in[out] = 0;
+          }
 
-            queryString.remove_prefix(statement.length() + 1);
+          return statementValue.substr(0, out);
         }
-
-        /* Nothing found is given as nullptr, while empty string is given as some pointer to the given buffer */
+      } else {
+        /* This querystring is invalid, cannot parse it */
         return {nullptr, 0};
+      }
     }
 
+    queryString.remove_prefix(statement.length() + 1);
+  }
+
+  /* Nothing found is given as nullptr, while empty string is given as some
+   * pointer to the given buffer */
+  return {nullptr, 0};
 }
 
+} // namespace uWS
+
 #endif