From 0cf68e5eab13b31a67ffb241497c36b04479b516 Mon Sep 17 00:00:00 2001 From: cirospaciari Date: Sun, 15 Oct 2023 18:51:09 -0300 Subject: wip --- packages/bun-uws/src/ChunkedEncoding.h | 38 +++++++++++++++++----------------- packages/bun-uws/src/HttpParser.h | 38 +++++++++++++++++----------------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/packages/bun-uws/src/ChunkedEncoding.h b/packages/bun-uws/src/ChunkedEncoding.h index 55d61b94f..0e0ba437a 100644 --- a/packages/bun-uws/src/ChunkedEncoding.h +++ b/packages/bun-uws/src/ChunkedEncoding.h @@ -29,18 +29,18 @@ namespace uWS { - constexpr uint32_t STATE_HAS_SIZE = 0x80000000; - constexpr uint32_t STATE_IS_CHUNKED = 0x40000000; - constexpr uint32_t STATE_SIZE_MASK = 0x3FFFFFFF; - constexpr uint32_t STATE_IS_ERROR = 0xFFFFFFFF; - constexpr uint32_t STATE_SIZE_OVERFLOW = 0x0F000000; + constexpr uint64_t STATE_HAS_SIZE = 0x8000000000000000; + constexpr uint64_t STATE_IS_CHUNKED = 0x4000000000000000; + constexpr uint64_t STATE_SIZE_MASK = 0x3FFFFFFFFFFFFFFF; + constexpr uint64_t STATE_IS_ERROR = 0xFFFFFFFFFFFFFFFF; + constexpr uint64_t STATE_SIZE_OVERFLOW = 0x0F00000000000000; - inline unsigned int chunkSize(unsigned int state) { + 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, unsigned int &state) { + inline void consumeHexNumber(std::string_view &data, uint64_t &state) { /* Consume everything higher than 32 */ while (data.length() && data.data()[0] > 32) { @@ -51,7 +51,7 @@ namespace uWS { digit = (unsigned char) (digit - ('A' - ':')); } - unsigned int number = ((unsigned int) digit - (unsigned int) '0'); + uint64_t number = ((uint64_t) digit - (uint64_t) '0'); if (number > 16 || (chunkSize(state) & STATE_SIZE_OVERFLOW)) { state = STATE_IS_ERROR; @@ -59,7 +59,7 @@ namespace uWS { } // extract state bits - unsigned int bits = /*state &*/ STATE_IS_CHUNKED; + uint64_t bits = /*state &*/ STATE_IS_CHUNKED; state = (state & STATE_SIZE_MASK) * 16u + number; @@ -78,30 +78,30 @@ namespace uWS { } } - inline void decChunkSize(unsigned int &state, unsigned int by) { + inline void decChunkSize(uint64_t &state, uint64_t by) { - //unsigned int bits = state & STATE_IS_CHUNKED; + //uint64_t bits = state & STATE_IS_CHUNKED; state = (state & ~STATE_SIZE_MASK) | (chunkSize(state) - by); //state |= bits; } - inline bool hasChunkSize(unsigned int state) { + inline bool hasChunkSize(uint64_t state) { return state & STATE_HAS_SIZE; } /* Are we in the middle of parsing chunked encoding? */ - inline bool isParsingChunkedEncoding(unsigned int state) { + inline bool isParsingChunkedEncoding(uint64_t state) { return state & ~STATE_SIZE_MASK; } - inline bool isParsingInvalidChunkedEncoding(unsigned int state) { + inline bool isParsingInvalidChunkedEncoding(uint64_t state) { return state == STATE_IS_ERROR; } /* Returns next chunk (empty or not), or if all data was consumed, nullopt is returned. */ - static std::optional getNextChunk(std::string_view &data, unsigned int &state, bool trailer = false) { + static std::optional 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 @@ -166,7 +166,7 @@ namespace uWS { /* We will consume all our input data */ std::string_view emitSoon; if (chunkSize(state) > 2) { - unsigned int maximalAppEmit = chunkSize(state) - 2; + uint64_t maximalAppEmit = chunkSize(state) - 2; if (data.length() > maximalAppEmit) { emitSoon = data.substr(0, maximalAppEmit); } else { @@ -174,7 +174,7 @@ namespace uWS { emitSoon = data; } } - decChunkSize(state, (unsigned int) data.length()); + decChunkSize(state, (uint64_t) data.length()); state |= STATE_IS_CHUNKED; // new: decrease data by its size (bug) data.remove_prefix(data.length()); // ny bug fix för getNextChunk @@ -194,10 +194,10 @@ namespace uWS { std::string_view *data; std::optional chunk; - unsigned int *state; + uint64_t *state; bool trailer; - ChunkIterator(std::string_view *data, unsigned int *state, bool trailer = false) : data(data), state(state), trailer(trailer) { + ChunkIterator(std::string_view *data, uint64_t *state, bool trailer = false) : data(data), state(state), trailer(trailer) { chunk = uWS::getNextChunk(*data, *state, trailer); } diff --git a/packages/bun-uws/src/HttpParser.h b/packages/bun-uws/src/HttpParser.h index 3710f453b..31bf2a43c 100644 --- a/packages/bun-uws/src/HttpParser.h +++ b/packages/bun-uws/src/HttpParser.h @@ -199,29 +199,29 @@ namespace uWS private: std::string fallback; - /* This guy really has only 30 bits since we reserve two highest bits to chunked encoding parsing state */ - unsigned int remainingStreamingBytes = 0; + /* This guy really has only 62 bits since we reserve two highest bits to chunked encoding parsing state */ + std::uint64_t remainingStreamingBytes = 0; const size_t MAX_FALLBACK_SIZE = 1024 * 4; - /* Returns UINT_MAX on error. Maximum 999999999 is allowed. */ - static unsigned int toUnsignedInteger(std::string_view str) + /* Returns UINT64_MAX on error. Maximum 999999999999999999 is allowed. */ + static std::uint64_t toUnsignedInteger(std::string_view str) { - /* We assume at least 32-bit integer giving us safely 999999999 (9 number of 9s) */ - if (str.length() > 9) + /* We assume 999999999999999999 (18 number of 9s) */ + if (str.length() > 18) { - return UINT_MAX; + return UINT64_MAX; } - unsigned int unsignedIntegerValue = 0; + uint64_t unsignedIntegerValue = 0; for (char c : str) { /* As long as the letter is 0-9 we cannot overflow. */ if (c < '0' || c > '9') { - return UINT_MAX; + return UINT64_MAX; } - unsignedIntegerValue = unsignedIntegerValue * 10u + ((unsigned int)c - (unsigned int)'0'); + unsignedIntegerValue = unsignedIntegerValue * 10ull + ((uint64_t)c - (uint64_t)'0'); } return unsignedIntegerValue; } @@ -474,7 +474,7 @@ namespace uWS * or [consumed, nullptr] for "break; I am closed or upgraded to websocket" * or [whatever, fullptr] for "break and close me, I am a parser error!" */ template - std::pair fenceAndConsumePostPadded(char *data, unsigned int length, void *user, void *reserved, HttpRequest *req, MoveOnlyFunction &requestHandler, MoveOnlyFunction &dataHandler) + std::pair fenceAndConsumePostPadded(char *data, uint64_t length, void *user, void *reserved, HttpRequest *req, MoveOnlyFunction &requestHandler, MoveOnlyFunction &dataHandler) { /* How much data we CONSUMED (to throw away) */ @@ -574,16 +574,16 @@ namespace uWS { return {0, FULLPTR}; } - unsigned int consumed = (length - (unsigned int)dataToConsume.length()); + uint64_t consumed = (length - (uint64_t)dataToConsume.length()); data = (char *)dataToConsume.data(); - length = (unsigned int)dataToConsume.length(); + length = (uint64_t)dataToConsume.length(); consumedTotal += consumed; } } else if (contentLengthString.length()) { remainingStreamingBytes = toUnsignedInteger(contentLengthString); - if (remainingStreamingBytes == UINT_MAX) + if (remainingStreamingBytes == UINT16_MAX) { /* Parser error */ return {0, FULLPTR}; @@ -591,7 +591,7 @@ namespace uWS if (!CONSUME_MINIMALLY) { - unsigned int emittable = std::min(remainingStreamingBytes, length); + uint64_t emittable = std::min(remainingStreamingBytes, length); dataHandler(user, std::string_view(data, emittable), emittable == remainingStreamingBytes); remainingStreamingBytes -= emittable; @@ -616,7 +616,7 @@ namespace uWS } public: - void *consumePostPadded(char *data, unsigned int length, void *user, void *reserved, MoveOnlyFunction &&requestHandler, MoveOnlyFunction &&dataHandler, MoveOnlyFunction &&errorHandler) + void *consumePostPadded(char *data, uint64_t length, void *user, void *reserved, MoveOnlyFunction &&requestHandler, MoveOnlyFunction &&dataHandler, MoveOnlyFunction &&errorHandler) { /* This resets BloomFilter by construction, but later we also reset it again. * Optimize this to skip resetting twice (req could be made global) */ @@ -638,7 +638,7 @@ namespace uWS return FULLPTR; } data = (char *)dataToConsume.data(); - length = (unsigned int)dataToConsume.length(); + length = (uint64_t)dataToConsume.length(); } else { @@ -688,7 +688,7 @@ namespace uWS fallback.append(data, maxCopyDistance); // break here on break - std::pair consumed = fenceAndConsumePostPadded(fallback.data(), (unsigned int)fallback.length(), user, reserved, &req, requestHandler, dataHandler); + std::pair consumed = fenceAndConsumePostPadded(fallback.data(), (unsigned int)fallback.length(), user, reserved, &req, requestHandler, dataHandler); if (consumed.second != user) { return consumed.second; @@ -759,7 +759,7 @@ namespace uWS } } - std::pair consumed = fenceAndConsumePostPadded(data, length, user, reserved, &req, requestHandler, dataHandler); + std::pair consumed = fenceAndConsumePostPadded(data, length, user, reserved, &req, requestHandler, dataHandler); if (consumed.second != user) { return consumed.second; -- cgit v1.2.3