opal-up 0.0.4 → 0.0.5

data/ext/up_ext/AsyncSocketData.h

@@ -23,65 +23,49 @@
 namespace uWS {
 
 struct BackPressure {
-    std::string buffer;
-    unsigned int pendingRemoval = 0;
-    BackPressure(BackPressure &&other) {
-        buffer = std::move(other.buffer);
-        pendingRemoval = other.pendingRemoval;
-    }
-    BackPressure() = default;
-    void append(const char *data, size_t length) {
-        buffer.append(data, length);
-    }
-    void erase(unsigned int length) {
-        pendingRemoval += length;
-        /* Always erase a minimum of 1/32th the current backpressure */
-        if (pendingRemoval > (buffer.length() >> 5)) {
-            buffer.erase(0, pendingRemoval);
-            pendingRemoval = 0;
-        }
-    }
-    size_t length() {
-        return buffer.length() - pendingRemoval;
-    }
-    void clear() {
-        pendingRemoval = 0;
-        buffer.clear();
-    }
-    void reserve(size_t length) {
-        buffer.reserve(length + pendingRemoval);
-    }
-    void resize(size_t length) {
-        buffer.resize(length + pendingRemoval);
-    }
-    const char *data() {
-        return buffer.data() + pendingRemoval;
-    }
-    size_t size() {
-        return length();
-    }
-    /* The total length, incuding pending removal */
-    size_t totalLength() {
-        return buffer.length();
+  std::string buffer;
+  unsigned int pendingRemoval = 0;
+  BackPressure(BackPressure &&other) {
+    buffer = std::move(other.buffer);
+    pendingRemoval = other.pendingRemoval;
+  }
+  BackPressure() = default;
+  void append(const char *data, size_t length) { buffer.append(data, length); }
+  void erase(unsigned int length) {
+    pendingRemoval += length;
+    /* Always erase a minimum of 1/32th the current backpressure */
+    if (pendingRemoval > (buffer.length() >> 5)) {
+      buffer.erase(0, pendingRemoval);
+      pendingRemoval = 0;
     }
+  }
+  size_t length() { return buffer.length() - pendingRemoval; }
+  void clear() {
+    pendingRemoval = 0;
+    buffer.clear();
+  }
+  void reserve(size_t length) { buffer.reserve(length + pendingRemoval); }
+  void resize(size_t length) { buffer.resize(length + pendingRemoval); }
+  const char *data() { return buffer.data() + pendingRemoval; }
+  size_t size() { return length(); }
+  /* The total length, incuding pending removal */
+  size_t totalLength() { return buffer.length(); }
 };
 
 /* Depending on how we want AsyncSocket to function, this will need to change */
 
-template <bool SSL>
-struct AsyncSocketData {
-    /* This will do for now */
-    BackPressure buffer;
+template <bool SSL> struct AsyncSocketData {
+  /* This will do for now */
+  BackPressure buffer;
 
-    /* Allow move constructing us */
-    AsyncSocketData(BackPressure &&backpressure) : buffer(std::move(backpressure)) {
-
-    }
+  /* Allow move constructing us */
+  AsyncSocketData(BackPressure &&backpressure)
+      : buffer(std::move(backpressure)) {}
 
-    /* Or emppty */
-    AsyncSocketData() = default;
+  /* Or emppty */
+  AsyncSocketData() = default;
 };
 
-}
+} // namespace uWS
 
 #endif // UWS_ASYNCSOCKETDATA_H

data/ext/up_ext/BloomFilter.h

@@ -21,63 +21,58 @@
 /* This filter has no false positives or collisions for the standard
  * and non-standard common request headers */
 
+#include <bitset>
 #include <cstdint>
 #include <string_view>
-#include <bitset>
 
 namespace uWS {
 
 struct BloomFilter {
 private:
-    std::bitset<256> filter;
-    static inline uint32_t perfectHash(uint32_t features) {
-        return features *= 1843993368;
-    }
+  std::bitset<256> filter;
+  static inline uint32_t perfectHash(uint32_t features) {
+    return features *= 1843993368;
+  }
 
-    union ScrambleArea {
-        unsigned char p[4];
-        uint32_t val;
-    };
-
-    ScrambleArea getFeatures(std::string_view key) {
-        ScrambleArea s;
-        s.p[0] = reinterpret_cast<const unsigned char&>(key[0]);
-        s.p[1] = reinterpret_cast<const unsigned char&>(key[key.length() - 1]);
-        s.p[2] = reinterpret_cast<const unsigned char&>(key[key.length() - 2]);
-        s.p[3] = reinterpret_cast<const unsigned char&>(key[key.length() >> 1]);
-        return s;
-    }
+  union ScrambleArea {
+    unsigned char p[4];
+    uint32_t val;
+  };
+
+  ScrambleArea getFeatures(std::string_view key) {
+    ScrambleArea s;
+    s.p[0] = reinterpret_cast<const unsigned char &>(key[0]);
+    s.p[1] = reinterpret_cast<const unsigned char &>(key[key.length() - 1]);
+    s.p[2] = reinterpret_cast<const unsigned char &>(key[key.length() - 2]);
+    s.p[3] = reinterpret_cast<const unsigned char &>(key[key.length() >> 1]);
+    return s;
+  }
 
 public:
-    bool mightHave(std::string_view key) {
-        if (key.length() < 2) {
-            return true;
-        }
-    
-        ScrambleArea s = getFeatures(key);
-        s.val = perfectHash(s.val);
-        return filter[s.p[0]] &&
-        filter[s.p[1]] &&
-        filter[s.p[2]] &&
-        filter[s.p[3]];
+  bool mightHave(std::string_view key) {
+    if (key.length() < 2) {
+      return true;
     }
 
-    void add(std::string_view key) {
-        if (key.length() >= 2) {
-            ScrambleArea s = getFeatures(key);
-            s.val = perfectHash(s.val);
-            filter[s.p[0]] = 1;
-            filter[s.p[1]] = 1;
-            filter[s.p[2]] = 1;
-            filter[s.p[3]] = 1;
-        }
-    }
+    ScrambleArea s = getFeatures(key);
+    s.val = perfectHash(s.val);
+    return filter[s.p[0]] && filter[s.p[1]] && filter[s.p[2]] && filter[s.p[3]];
+  }
 
-    void reset() {
-        filter.reset();
+  void add(std::string_view key) {
+    if (key.length() >= 2) {
+      ScrambleArea s = getFeatures(key);
+      s.val = perfectHash(s.val);
+      filter[s.p[0]] = 1;
+      filter[s.p[1]] = 1;
+      filter[s.p[2]] = 1;
+      filter[s.p[3]] = 1;
     }
+  }
+
+  void reset() { filter.reset(); }
 };
 
-}
+} // namespace uWS
 
 #endif // UWS_BLOOMFILTER_H

data/ext/up_ext/ChunkedEncoding.h

@@ -20,217 +20,216 @@
 
 /* Independent chunked encoding parser, used by HttpParser. */
 
-#include <string>
-#include <cstring>
-#include <algorithm>
-#include <string_view>
 #include "MoveOnlyFunction.h"
+#include <algorithm>
+#include <cstring>
 #include <optional>
+#include <string>
+#include <string_view>
 
 namespace uWS {
 
-    constexpr uint64_t STATE_HAS_SIZE = 1ull << (sizeof(uint64_t) * 8 - 1);//0x80000000;
-    constexpr uint64_t STATE_IS_CHUNKED = 1ull << (sizeof(uint64_t) * 8 - 2);//0x40000000;
-    constexpr uint64_t STATE_SIZE_MASK = ~(3ull << (sizeof(uint64_t) * 8 - 2));//0x3FFFFFFF;
-    constexpr uint64_t STATE_IS_ERROR = ~0ull;//0xFFFFFFFF;
-    constexpr uint64_t STATE_SIZE_OVERFLOW = 0x0Full << (sizeof(uint64_t) * 8 - 8);//0x0F000000;
+constexpr uint64_t STATE_HAS_SIZE =
+    1ull << (sizeof(uint64_t) * 8 - 1); // 0x80000000;
+constexpr uint64_t STATE_IS_CHUNKED =
+    1ull << (sizeof(uint64_t) * 8 - 2); // 0x40000000;
+constexpr uint64_t STATE_SIZE_MASK =
+    ~(3ull << (sizeof(uint64_t) * 8 - 2)); // 0x3FFFFFFF;
+constexpr uint64_t STATE_IS_ERROR = ~0ull; // 0xFFFFFFFF;
+constexpr uint64_t STATE_SIZE_OVERFLOW =
+    0x0Full << (sizeof(uint64_t) * 8 - 8); // 0x0F000000;
+
+inline uint64_t chunkSize(uint64_t state) { return state & STATE_SIZE_MASK; }
+
+/* Reads hex number until CR or out of data to consume. Updates state. Returns
+ * bytes consumed. */
+inline void consumeHexNumber(std::string_view &data, uint64_t &state) {
+  /* Consume everything higher than 32 */
+  while (data.length() && data.data()[0] > 32) {
+
+    unsigned char digit = (unsigned char)data.data()[0];
+    if (digit >= 'a') {
+      digit = (unsigned char)(digit - ('a' - ':'));
+    } else if (digit >= 'A') {
+      digit = (unsigned char)(digit - ('A' - ':'));
+    }
+
+    unsigned int number = ((unsigned int)digit - (unsigned int)'0');
 
-    inline uint64_t chunkSize(uint64_t state) {
-        return state & STATE_SIZE_MASK;
+    if (number > 16 || (chunkSize(state) & STATE_SIZE_OVERFLOW)) {
+      state = STATE_IS_ERROR;
+      return;
     }
 
-    /* Reads hex number until CR or out of data to consume. Updates state. Returns bytes consumed. */
-    inline void consumeHexNumber(std::string_view &data, uint64_t &state) {
-        /* Consume everything higher than 32 */
-        while (data.length() && data.data()[0] > 32) {
+    // extract state bits
+    uint64_t bits = /*state &*/ STATE_IS_CHUNKED;
+
+    state = (state & STATE_SIZE_MASK) * 16ull + number;
+
+    state |= bits;
+    data.remove_prefix(1);
+  }
+  /* Consume everything not /n */
+  while (data.length() && data.data()[0] != '\n') {
+    data.remove_prefix(1);
+  }
+  /* Now we stand on \n so consume it and enable size */
+  if (data.length()) {
+    state += 2; // include the two last /r/n
+    state |= STATE_HAS_SIZE | STATE_IS_CHUNKED;
+    data.remove_prefix(1);
+  }
+}
 
-            unsigned char digit = (unsigned char)data.data()[0];
-            if (digit >= 'a') {
-                digit = (unsigned char) (digit - ('a' - ':'));
-            } else if (digit >= 'A') {
-                digit = (unsigned char) (digit - ('A' - ':'));
-            }
+inline void decChunkSize(uint64_t &state, unsigned int by) {
 
-            unsigned int number = ((unsigned int) digit - (unsigned int) '0');
+  // unsigned int bits = state & STATE_IS_CHUNKED;
 
-            if (number > 16 || (chunkSize(state) & STATE_SIZE_OVERFLOW)) {
-                state = STATE_IS_ERROR;
-                return;
-            }
+  state = (state & ~STATE_SIZE_MASK) | (chunkSize(state) - by);
 
-            // extract state bits
-            uint64_t bits = /*state &*/ STATE_IS_CHUNKED;
+  // state |= bits;
+}
 
-            state = (state & STATE_SIZE_MASK) * 16ull + number;
+inline bool hasChunkSize(uint64_t state) { return state & STATE_HAS_SIZE; }
 
-            state |= bits;
-            data.remove_prefix(1);
-        }
-        /* Consume everything not /n */
-        while (data.length() && data.data()[0] != '\n') {
-            data.remove_prefix(1);
-        }
-        /* Now we stand on \n so consume it and enable size */
-        if (data.length()) {
-            state += 2; // include the two last /r/n
-            state |= STATE_HAS_SIZE | STATE_IS_CHUNKED;
-            data.remove_prefix(1);
-        }
-    }
+/* Are we in the middle of parsing chunked encoding? */
+inline bool isParsingChunkedEncoding(uint64_t state) {
+  return state & ~STATE_SIZE_MASK;
+}
 
-    inline void decChunkSize(uint64_t &state, unsigned int by) {
+inline bool isParsingInvalidChunkedEncoding(uint64_t state) {
+  return state == STATE_IS_ERROR;
+}
 
-        //unsigned int bits = state & STATE_IS_CHUNKED;
+/* Returns next chunk (empty or not), or if all data was consumed, nullopt is
+ * returned. */
+static std::optional<std::string_view>
+getNextChunk(std::string_view &data, uint64_t &state, bool trailer = false) {
 
-        state = (state & ~STATE_SIZE_MASK) | (chunkSize(state) - by);
+  while (data.length()) {
 
-        //state |= bits;
-    }
+    // if in "drop trailer mode", just drop up to what we have as size
+    if (((state & STATE_IS_CHUNKED) == 0) && hasChunkSize(state) &&
+        chunkSize(state)) {
 
-    inline bool hasChunkSize(uint64_t state) {
-        return state & STATE_HAS_SIZE;
-    }
+      // printf("Parsing trailer now\n");
 
-    /* Are we in the middle of parsing chunked encoding? */
-    inline bool isParsingChunkedEncoding(uint64_t state) {
-        return state & ~STATE_SIZE_MASK;
-    }
+      while (data.length() && chunkSize(state)) {
+        data.remove_prefix(1);
+        decChunkSize(state, 1);
 
-    inline bool isParsingInvalidChunkedEncoding(uint64_t state) {
-        return state == STATE_IS_ERROR;
-    }
+        if (chunkSize(state) == 0) {
 
-    /* Returns next chunk (empty or not), or if all data was consumed, nullopt is returned. */
-    static std::optional<std::string_view> getNextChunk(std::string_view &data, uint64_t &state, bool trailer = false) {
-
-        while (data.length()) {
-
-            // if in "drop trailer mode", just drop up to what we have as size
-            if (((state & STATE_IS_CHUNKED) == 0) && hasChunkSize(state) && chunkSize(state)) {
-
-                //printf("Parsing trailer now\n");
-
-                while(data.length() && chunkSize(state)) {
-                    data.remove_prefix(1);
-                    decChunkSize(state, 1);
-
-                    if (chunkSize(state) == 0) {
-
-                        /* This is an actual place where we need 0 as state */
-                        state = 0;
-
-                        /* The parser MUST stop consuming here */
-                        return std::nullopt;
-                    }
-                }
-                continue;
-            }
-
-            if (!hasChunkSize(state)) {
-                consumeHexNumber(data, state);
-                if (isParsingInvalidChunkedEncoding(state)) {
-                    return std::nullopt;
-                }
-                if (hasChunkSize(state) && chunkSize(state) == 2) {
-
-                    //printf("Setting state to trailer-parsing and emitting empty chunk\n");
-
-                    // set trailer state and increase size to 4
-                    if (trailer) {
-                        state = 4 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
-                    } else {
-                        state = 2 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
-                    }
-
-                    return std::string_view(nullptr, 0);
-                }
-                continue;
-            }
-
-            // do we have data to emit all?
-            if (data.length() >= chunkSize(state)) {
-                // emit all but 2 bytes then reset state to 0 and goto beginning
-                // not fin
-                std::string_view emitSoon;
-                bool shouldEmit = false;
-                if (chunkSize(state) > 2) {
-                    emitSoon = std::string_view(data.data(), chunkSize(state) - 2);
-                    shouldEmit = true;
-                }
-                data.remove_prefix(chunkSize(state));
-                state = STATE_IS_CHUNKED;
-                if (shouldEmit) {
-                    return emitSoon;
-                }
-                continue;
-            } else {
-                /* We will consume all our input data */
-                std::string_view emitSoon;
-                if (chunkSize(state) > 2) {
-                    uint64_t maximalAppEmit = chunkSize(state) - 2;
-                    if (data.length() > maximalAppEmit) {
-                        emitSoon = data.substr(0, maximalAppEmit);
-                    } else {
-                        //cb(data);
-                        emitSoon = data;
-                    }
-                }
-                decChunkSize(state, (unsigned int) data.length());
-                state |= STATE_IS_CHUNKED;
-                // new: decrease data by its size (bug)
-                data.remove_prefix(data.length()); // ny bug fix för getNextChunk
-                if (emitSoon.length()) {
-                    return emitSoon;
-                } else {
-                    return std::nullopt;
-                }
-            }
-        }
+          /* This is an actual place where we need 0 as state */
+          state = 0;
 
-        return std::nullopt;
+          /* The parser MUST stop consuming here */
+          return std::nullopt;
+        }
+      }
+      continue;
     }
 
-    /* This is really just a wrapper for convenience */
-    struct ChunkIterator {
+    if (!hasChunkSize(state)) {
+      consumeHexNumber(data, state);
+      if (isParsingInvalidChunkedEncoding(state)) {
+        return std::nullopt;
+      }
+      if (hasChunkSize(state) && chunkSize(state) == 2) {
 
-        std::string_view *data;
-        std::optional<std::string_view> chunk;
-        uint64_t *state;
-        bool trailer;
+        // printf("Setting state to trailer-parsing and emitting empty
+        // chunk\n");
 
-        ChunkIterator(std::string_view *data, uint64_t *state, bool trailer = false) : data(data), state(state), trailer(trailer) {
-            chunk = uWS::getNextChunk(*data, *state, trailer);
+        // set trailer state and increase size to 4
+        if (trailer) {
+          state = 4 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
+        } else {
+          state = 2 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
         }
 
-        ChunkIterator() {
+        return std::string_view(nullptr, 0);
+      }
+      continue;
+    }
 
+    // do we have data to emit all?
+    if (data.length() >= chunkSize(state)) {
+      // emit all but 2 bytes then reset state to 0 and goto beginning
+      // not fin
+      std::string_view emitSoon;
+      bool shouldEmit = false;
+      if (chunkSize(state) > 2) {
+        emitSoon = std::string_view(data.data(), chunkSize(state) - 2);
+        shouldEmit = true;
+      }
+      data.remove_prefix(chunkSize(state));
+      state = STATE_IS_CHUNKED;
+      if (shouldEmit) {
+        return emitSoon;
+      }
+      continue;
+    } else {
+      /* We will consume all our input data */
+      std::string_view emitSoon;
+      if (chunkSize(state) > 2) {
+        uint64_t maximalAppEmit = chunkSize(state) - 2;
+        if (data.length() > maximalAppEmit) {
+          emitSoon = data.substr(0, maximalAppEmit);
+        } else {
+          // cb(data);
+          emitSoon = data;
         }
+      }
+      decChunkSize(state, (unsigned int)data.length());
+      state |= STATE_IS_CHUNKED;
+      // new: decrease data by its size (bug)
+      data.remove_prefix(data.length()); // ny bug fix för getNextChunk
+      if (emitSoon.length()) {
+        return emitSoon;
+      } else {
+        return std::nullopt;
+      }
+    }
+  }
 
-        ChunkIterator begin() {
-            return *this;
-        }
+  return std::nullopt;
+}
 
-        ChunkIterator end() {
-            return ChunkIterator();
-        }
+/* This is really just a wrapper for convenience */
+struct ChunkIterator {
 
-        std::string_view operator*() {
-            if (!chunk.has_value()) {
-                std::abort();
-            }
-            return chunk.value();
-        }
+  std::string_view *data;
+  std::optional<std::string_view> chunk;
+  uint64_t *state;
+  bool trailer;
 
-        bool operator!=(const ChunkIterator &other) const {
-            return other.chunk.has_value() != chunk.has_value();
-        }
+  ChunkIterator(std::string_view *data, uint64_t *state, bool trailer = false)
+      : data(data), state(state), trailer(trailer) {
+    chunk = uWS::getNextChunk(*data, *state, trailer);
+  }
 
-        ChunkIterator &operator++() {
-            chunk = uWS::getNextChunk(*data, *state, trailer);
-            return *this;
-        }
+  ChunkIterator() {}
 
-    };
-}
+  ChunkIterator begin() { return *this; }
+
+  ChunkIterator end() { return ChunkIterator(); }
+
+  std::string_view operator*() {
+    if (!chunk.has_value()) {
+      std::abort();
+    }
+    return chunk.value();
+  }
+
+  bool operator!=(const ChunkIterator &other) const {
+    return other.chunk.has_value() != chunk.has_value();
+  }
+
+  ChunkIterator &operator++() {
+    chunk = uWS::getNextChunk(*data, *state, trailer);
+    return *this;
+  }
+};
+} // namespace uWS
 
 #endif // UWS_CHUNKEDENCODING_H

data/ext/up_ext/ClientApp.h

@@ -4,33 +4,30 @@
 
 namespace uWS {
 
-    struct WebSocketClientBehavior {
-        MoveOnlyFunction<void()> open;
-        MoveOnlyFunction<void()> message;
-        MoveOnlyFunction<void()> close;
-        //MoveOnlyFunction<void()> failed;
+struct WebSocketClientBehavior {
+  MoveOnlyFunction<void()> open;
+  MoveOnlyFunction<void()> message;
+  MoveOnlyFunction<void()> close;
+  // MoveOnlyFunction<void()> failed;
+};
 
-    };
+struct ClientApp {
 
-    struct ClientApp {
+  WebSocketContext<0, false, int> *webSocketContext;
+  // behöver ett nytt http context med minimal klient, som slår om till den
+  // riktiga websocketcontext om samma storlek på httpsocket och websocket blir
+  // det enkel övergång
 
-        WebSocketContext<0, false, int> *webSocketContext;
-        // behöver ett nytt http context med minimal klient, som slår om till den riktiga websocketcontext
-        // om samma storlek på httpsocket och websocket blir det enkel övergång
+  ClientApp(WebSocketClientBehavior &&behavior) {
+    // webSocketContext = WebSocketContext<0, false, int>::create();
+  }
 
-        ClientApp(WebSocketClientBehavior &&behavior) {
-            //webSocketContext = WebSocketContext<0, false, int>::create();
-        }
+  ClientApp &&connect(std::string url, std::string protocol = "") {
 
-        ClientApp &&connect(std::string url, std::string protocol = "") {
+    return std::move(*this);
+  }
 
-            return std::move(*this);
-        }
+  void run() {}
+};
 
-        void run() {
-
-        }
-
-    };
-
-}
+} // namespace uWS