From 749488937e239b708d79aaca77250f52ef726b53 Mon Sep 17 00:00:00 2001 From: Stephen Gallagher Date: Wed, 31 Jul 2024 13:39:48 -0400 Subject: [PATCH] Import from Fedora Rawhide Signed-off-by: Stephen Gallagher --- .gitignore | 1 + 0001-Replace-http-parser-with-llhttp.patch | 15030 ++++++++++++++++ ...oving-untracked-files-by-path-in-sub.patch | 76 - libgit2.spec | 288 +- sources | 2 +- 5 files changed, 15086 insertions(+), 311 deletions(-) create mode 100644 0001-Replace-http-parser-with-llhttp.patch delete mode 100644 0001-checkout-Fix-removing-untracked-files-by-path-in-sub.patch diff --git a/.gitignore b/.gitignore index f60666f..f9fe0ca 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,4 @@ /libgit2-1.0.0.tar.gz /libgit2-1.0.1.tar.gz /libgit2-1.1.0.tar.gz +/libgit2-1.7.2.tar.gz diff --git a/0001-Replace-http-parser-with-llhttp.patch b/0001-Replace-http-parser-with-llhttp.patch new file mode 100644 index 0000000..4581339 --- /dev/null +++ b/0001-Replace-http-parser-with-llhttp.patch @@ -0,0 +1,15030 @@ +From 40a79eaf933167eca17c7dc52190776fe743f34a Mon Sep 17 00:00:00 2001 +From: Edward Thomson +Date: Tue, 23 Apr 2024 08:05:54 +0100 +Subject: [PATCH] Replace http-parser with llhttp + +Signed-off-by: Stephen Gallagher +--- + cmake/FindLLHTTP.cmake | 39 + + cmake/SelectHTTPParser.cmake | 27 +- + deps/http-parser/CMakeLists.txt | 6 - + deps/http-parser/COPYING | 23 - + deps/http-parser/http_parser.c | 2182 ------ + deps/http-parser/http_parser.h | 305 - + deps/llhttp/CMakeLists.txt | 8 + + deps/llhttp/LICENSE-MIT | 22 + + deps/llhttp/api.c | 510 ++ + deps/llhttp/http.c | 170 + + deps/llhttp/llhttp.c | 10168 ++++++++++++++++++++++++++ + deps/llhttp/llhttp.h | 897 +++ + script/valgrind.supp | 7 + + src/libgit2/transports/http.c | 1 - + src/libgit2/transports/httpclient.c | 108 +- + src/libgit2/transports/httpparser.c | 126 + + src/libgit2/transports/httpparser.h | 99 + + src/util/git2_features.h.in | 4 + + src/util/net.c | 1 - + 19 files changed, 12125 insertions(+), 2578 deletions(-) + create mode 100644 cmake/FindLLHTTP.cmake + delete mode 100644 deps/http-parser/CMakeLists.txt + delete mode 100644 deps/http-parser/COPYING + delete mode 100644 deps/http-parser/http_parser.c + delete mode 100644 deps/http-parser/http_parser.h + create mode 100644 deps/llhttp/CMakeLists.txt + create mode 100644 deps/llhttp/LICENSE-MIT + create mode 100644 deps/llhttp/api.c + create mode 100644 deps/llhttp/http.c + create mode 100644 deps/llhttp/llhttp.c + create mode 100644 deps/llhttp/llhttp.h + create mode 100644 src/libgit2/transports/httpparser.c + create mode 100644 src/libgit2/transports/httpparser.h + +diff --git a/cmake/FindLLHTTP.cmake b/cmake/FindLLHTTP.cmake +new file mode 100644 +index 0000000000000000000000000000000000000000..a87d335d048dcb7aae8f75f533fa107674a0fdcd +--- /dev/null ++++ b/cmake/FindLLHTTP.cmake +@@ -0,0 +1,39 @@ ++# - Try to find llhttp ++# ++# Defines the following variables: ++# ++# LLHTTP_FOUND - system has llhttp ++# LLHTTP_INCLUDE_DIR - the llhttp include directory ++# LLHTTP_LIBRARIES - Link these to use llhttp ++# LLHTTP_VERSION_MAJOR - major version ++# LLHTTP_VERSION_MINOR - minor version ++# LLHTTP_VERSION_STRING - the version of llhttp found ++ ++# Find the header and library ++find_path(LLHTTP_INCLUDE_DIR NAMES llhttp.h) ++find_library(LLHTTP_LIBRARY NAMES llhttp libllhttp) ++ ++# Found the header, read version ++if(LLHTTP_INCLUDE_DIR AND EXISTS "${LLHTTP_INCLUDE_DIR}/llhttp.h") ++ file(READ "${LLHTTP_INCLUDE_DIR}/llhttp.h" LLHTTP_H) ++ if(LLHTTP_H) ++ string(REGEX REPLACE ".*#define[\t ]+LLHTTP_VERSION_MAJOR[\t ]+([0-9]+).*" "\\1" LLHTTP_VERSION_MAJOR "${LLHTTP_H}") ++ string(REGEX REPLACE ".*#define[\t ]+LLHTTP_VERSION_MINOR[\t ]+([0-9]+).*" "\\1" LLHTTP_VERSION_MINOR "${LLHTTP_H}") ++ set(LLHTTP_VERSION_STRING "${LLHTTP_VERSION_MAJOR}.${LLHTTP_VERSION_MINOR}") ++ endif() ++ unset(LLHTTP_H) ++endif() ++ ++# Handle the QUIETLY and REQUIRED arguments and set LLHTTP_FOUND ++# to TRUE if all listed variables are TRUE ++include(FindPackageHandleStandardArgs) ++find_package_handle_standard_args(LLHTTP REQUIRED_VARS LLHTTP_INCLUDE_DIR LLHTTP_LIBRARY) ++ ++# Hide advanced variables ++mark_as_advanced(LLHTTP_INCLUDE_DIR LLHTTP_LIBRARY) ++ ++# Set standard variables ++if(LLHTTP_FOUND) ++ set(LLHTTP_LIBRARIES ${LLHTTP_LIBRARY}) ++ set(LLHTTP_INCLUDE_DIRS ${LLHTTP_INCLUDE_DIR}) ++endif() +diff --git a/cmake/SelectHTTPParser.cmake b/cmake/SelectHTTPParser.cmake +index 955aea3308cb920d16967231591b8a1b0917720b..4fc1f6968e6d6a2b115b8c9fb9aa978b92c21976 100644 +--- a/cmake/SelectHTTPParser.cmake ++++ b/cmake/SelectHTTPParser.cmake +@@ -1,19 +1,32 @@ + # Optional external dependency: http-parser +-if(USE_HTTP_PARSER STREQUAL "system") ++if(USE_HTTP_PARSER STREQUAL "http-parser") + find_package(HTTPParser) + + if(HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2) + list(APPEND LIBGIT2_SYSTEM_INCLUDES ${HTTP_PARSER_INCLUDE_DIRS}) + list(APPEND LIBGIT2_SYSTEM_LIBS ${HTTP_PARSER_LIBRARIES}) + list(APPEND LIBGIT2_PC_LIBS "-lhttp_parser") +- add_feature_info(http-parser ON "http-parser support (system)") ++ set(GIT_HTTPPARSER_HTTPPARSER 1) ++ add_feature_info(http-parser ON "using http-parser (system)") + else() + message(FATAL_ERROR "http-parser support was requested but not found") + endif() ++elseif(USE_HTTP_PARSER STREQUAL "llhttp") ++ find_package(LLHTTP) ++ ++ if(LLHTTP_FOUND AND LLHTTP_VERSION_MAJOR EQUAL 9) ++ list(APPEND LIBGIT2_SYSTEM_INCLUDES ${LLHTTP_INCLUDE_DIRS}) ++ list(APPEND LIBGIT2_SYSTEM_LIBS ${LLHTTP_LIBRARIES}) ++ list(APPEND LIBGIT2_PC_LIBS "-lllhttp") ++ set(GIT_HTTPPARSER_LLHTTP 1) ++ add_feature_info(http-parser ON "using llhttp (system)") ++ else() ++ message(FATAL_ERROR "llhttp support was requested but not found") ++ endif() + else() +- message(STATUS "http-parser version 2 was not found or disabled; using bundled 3rd-party sources.") +- add_subdirectory("${PROJECT_SOURCE_DIR}/deps/http-parser" "${PROJECT_BINARY_DIR}/deps/http-parser") +- list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/http-parser") +- list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") +- add_feature_info(http-parser ON "http-parser support (bundled)") ++ add_subdirectory("${PROJECT_SOURCE_DIR}/deps/llhttp" "${PROJECT_BINARY_DIR}/deps/llhttp") ++ list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/llhttp") ++ list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") ++ set(GIT_HTTPPARSER_BUILTIN 1) ++ add_feature_info(http-parser ON "using bundled parser") + endif() +diff --git a/deps/http-parser/CMakeLists.txt b/deps/http-parser/CMakeLists.txt +deleted file mode 100644 +index b9da2496f75dcf69626811575e6ae18f199b2f33..0000000000000000000000000000000000000000 +--- a/deps/http-parser/CMakeLists.txt ++++ /dev/null +@@ -1,6 +0,0 @@ +-file(GLOB SRC_HTTP "*.c" "*.h") +-list(SORT SRC_HTTP) +- +-add_library(http-parser OBJECT ${SRC_HTTP}) +- +-enable_warnings(implicit-fallthrough=1) +diff --git a/deps/http-parser/COPYING b/deps/http-parser/COPYING +deleted file mode 100644 +index 58010b388945f9af90a54e7c0f5177de893a4ad7..0000000000000000000000000000000000000000 +--- a/deps/http-parser/COPYING ++++ /dev/null +@@ -1,23 +0,0 @@ +-http_parser.c is based on src/http/ngx_http_parse.c from NGINX copyright +-Igor Sysoev. +- +-Additional changes are licensed under the same terms as NGINX and +-copyright Joyent, Inc. and other Node contributors. All rights reserved. +- +-Permission is hereby granted, free of charge, to any person obtaining a copy +-of this software and associated documentation files (the "Software"), to +-deal in the Software without restriction, including without limitation the +-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +-sell copies of the Software, and to permit persons to whom the Software is +-furnished to do so, subject to the following conditions: +- +-The above copyright notice and this permission notice shall be included in +-all copies or substantial portions of the Software. +- +-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +-IN THE SOFTWARE. +diff --git a/deps/http-parser/http_parser.c b/deps/http-parser/http_parser.c +deleted file mode 100644 +index 1bcd330e5b57ec9fffb2ef2f0d5121451f6277c3..0000000000000000000000000000000000000000 +--- a/deps/http-parser/http_parser.c ++++ /dev/null +@@ -1,2182 +0,0 @@ +-/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev +- * +- * Additional changes are licensed under the same terms as NGINX and +- * copyright Joyent, Inc. and other Node contributors. All rights reserved. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a copy +- * of this software and associated documentation files (the "Software"), to +- * deal in the Software without restriction, including without limitation the +- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +- * sell copies of the Software, and to permit persons to whom the Software is +- * furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +- * IN THE SOFTWARE. +- */ +-#include "http_parser.h" +-#include +-#include +-#include +-#include +-#include +-#include +- +-#ifndef ULLONG_MAX +-# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */ +-#endif +- +-#ifndef MIN +-# define MIN(a,b) ((a) < (b) ? (a) : (b)) +-#endif +- +-#ifndef ARRAY_SIZE +-# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) +-#endif +- +-#ifndef BIT_AT +-# define BIT_AT(a, i) \ +- (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \ +- (1 << ((unsigned int) (i) & 7)))) +-#endif +- +-#ifndef ELEM_AT +-# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v)) +-#endif +- +-#define SET_ERRNO(e) \ +-do { \ +- parser->http_errno = (e); \ +-} while(0) +- +- +-/* Run the notify callback FOR, returning ER if it fails */ +-#define CALLBACK_NOTIFY_(FOR, ER) \ +-do { \ +- assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ +- \ +- if (settings->on_##FOR) { \ +- if (0 != settings->on_##FOR(parser)) { \ +- SET_ERRNO(HPE_CB_##FOR); \ +- } \ +- \ +- /* We either errored above or got paused; get out */ \ +- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ +- return (ER); \ +- } \ +- } \ +-} while (0) +- +-/* Run the notify callback FOR and consume the current byte */ +-#define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1) +- +-/* Run the notify callback FOR and don't consume the current byte */ +-#define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data) +- +-/* Run data callback FOR with LEN bytes, returning ER if it fails */ +-#define CALLBACK_DATA_(FOR, LEN, ER) \ +-do { \ +- assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ +- \ +- if (FOR##_mark) { \ +- if (settings->on_##FOR) { \ +- if (0 != settings->on_##FOR(parser, FOR##_mark, (LEN))) { \ +- SET_ERRNO(HPE_CB_##FOR); \ +- } \ +- \ +- /* We either errored above or got paused; get out */ \ +- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ +- return (ER); \ +- } \ +- } \ +- FOR##_mark = NULL; \ +- } \ +-} while (0) +- +-/* Run the data callback FOR and consume the current byte */ +-#define CALLBACK_DATA(FOR) \ +- CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1) +- +-/* Run the data callback FOR and don't consume the current byte */ +-#define CALLBACK_DATA_NOADVANCE(FOR) \ +- CALLBACK_DATA_(FOR, p - FOR##_mark, p - data) +- +-/* Set the mark FOR; non-destructive if mark is already set */ +-#define MARK(FOR) \ +-do { \ +- if (!FOR##_mark) { \ +- FOR##_mark = p; \ +- } \ +-} while (0) +- +- +-#define PROXY_CONNECTION "proxy-connection" +-#define CONNECTION "connection" +-#define CONTENT_LENGTH "content-length" +-#define TRANSFER_ENCODING "transfer-encoding" +-#define UPGRADE "upgrade" +-#define CHUNKED "chunked" +-#define KEEP_ALIVE "keep-alive" +-#define CLOSE "close" +- +- +-static const char *method_strings[] = +- { +-#define XX(num, name, string) #string, +- HTTP_METHOD_MAP(XX) +-#undef XX +- }; +- +- +-/* Tokens as defined by rfc 2616. Also lowercases them. +- * token = 1* +- * separators = "(" | ")" | "<" | ">" | "@" +- * | "," | ";" | ":" | "\" | <"> +- * | "/" | "[" | "]" | "?" | "=" +- * | "{" | "}" | SP | HT +- */ +-static const char tokens[256] = { +-/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ +- 0, 0, 0, 0, 0, 0, 0, 0, +-/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ +- 0, 0, 0, 0, 0, 0, 0, 0, +-/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ +- 0, 0, 0, 0, 0, 0, 0, 0, +-/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ +- 0, 0, 0, 0, 0, 0, 0, 0, +-/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ +- 0, '!', 0, '#', '$', '%', '&', '\'', +-/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ +- 0, 0, '*', '+', 0, '-', '.', 0, +-/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ +- '0', '1', '2', '3', '4', '5', '6', '7', +-/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ +- '8', '9', 0, 0, 0, 0, 0, 0, +-/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ +- 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', +-/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ +- 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', +-/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ +- 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', +-/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ +- 'x', 'y', 'z', 0, 0, 0, '^', '_', +-/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ +- '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', +-/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ +- 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', +-/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ +- 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', +-/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ +- 'x', 'y', 'z', 0, '|', 0, '~', 0 }; +- +- +-static const int8_t unhex[256] = +- {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 +- ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +- }; +- +- +-#if HTTP_PARSER_STRICT +-# define T(v) 0 +-#else +-# define T(v) v +-#endif +- +- +-static const uint8_t normal_url_char[32] = { +-/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ +- 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +-/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ +- 0 | T(2) | 0 | 0 | T(16) | 0 | 0 | 0, +-/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ +- 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +-/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ +- 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +-/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ +- 0 | 2 | 4 | 0 | 16 | 32 | 64 | 128, +-/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, +-/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +-/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ +- 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, }; +- +-#undef T +- +-enum state +- { s_dead = 1 /* important that this is > 0 */ +- +- , s_start_req_or_res +- , s_res_or_resp_H +- , s_start_res +- , s_res_H +- , s_res_HT +- , s_res_HTT +- , s_res_HTTP +- , s_res_first_http_major +- , s_res_http_major +- , s_res_first_http_minor +- , s_res_http_minor +- , s_res_first_status_code +- , s_res_status_code +- , s_res_status +- , s_res_line_almost_done +- +- , s_start_req +- +- , s_req_method +- , s_req_spaces_before_url +- , s_req_schema +- , s_req_schema_slash +- , s_req_schema_slash_slash +- , s_req_server_start +- , s_req_server +- , s_req_server_with_at +- , s_req_path +- , s_req_query_string_start +- , s_req_query_string +- , s_req_fragment_start +- , s_req_fragment +- , s_req_http_start +- , s_req_http_H +- , s_req_http_HT +- , s_req_http_HTT +- , s_req_http_HTTP +- , s_req_first_http_major +- , s_req_http_major +- , s_req_first_http_minor +- , s_req_http_minor +- , s_req_line_almost_done +- +- , s_header_field_start +- , s_header_field +- , s_header_value_start +- , s_header_value +- , s_header_value_lws +- +- , s_header_almost_done +- +- , s_chunk_size_start +- , s_chunk_size +- , s_chunk_parameters +- , s_chunk_size_almost_done +- +- , s_headers_almost_done +- , s_headers_done +- +- /* Important: 's_headers_done' must be the last 'header' state. All +- * states beyond this must be 'body' states. It is used for overflow +- * checking. See the PARSING_HEADER() macro. +- */ +- +- , s_chunk_data +- , s_chunk_data_almost_done +- , s_chunk_data_done +- +- , s_body_identity +- , s_body_identity_eof +- +- , s_message_done +- }; +- +- +-#define PARSING_HEADER(state) (state <= s_headers_done) +- +- +-enum header_states +- { h_general = 0 +- , h_C +- , h_CO +- , h_CON +- +- , h_matching_connection +- , h_matching_proxy_connection +- , h_matching_content_length +- , h_matching_transfer_encoding +- , h_matching_upgrade +- +- , h_connection +- , h_content_length +- , h_transfer_encoding +- , h_upgrade +- +- , h_matching_transfer_encoding_chunked +- , h_matching_connection_keep_alive +- , h_matching_connection_close +- +- , h_transfer_encoding_chunked +- , h_connection_keep_alive +- , h_connection_close +- }; +- +-enum http_host_state +- { +- s_http_host_dead = 1 +- , s_http_userinfo_start +- , s_http_userinfo +- , s_http_host_start +- , s_http_host_v6_start +- , s_http_host +- , s_http_host_v6 +- , s_http_host_v6_end +- , s_http_host_port_start +- , s_http_host_port +-}; +- +-/* Macros for character classes; depends on strict-mode */ +-#define CR '\r' +-#define LF '\n' +-#define LOWER(c) (unsigned char)(c | 0x20) +-#define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z') +-#define IS_NUM(c) ((c) >= '0' && (c) <= '9') +-#define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c)) +-#define IS_HEX(c) (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f')) +-#define IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \ +- (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \ +- (c) == ')') +-#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \ +- (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \ +- (c) == '$' || (c) == ',') +- +-#if HTTP_PARSER_STRICT +-#define TOKEN(c) (tokens[(unsigned char)c]) +-#define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c)) +-#define IS_HOST_CHAR(c) (IS_ALPHANUM(c) || (c) == '.' || (c) == '-') +-#else +-#define TOKEN(c) ((c == ' ') ? ' ' : tokens[(unsigned char)c]) +-#define IS_URL_CHAR(c) \ +- (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80)) +-#define IS_HOST_CHAR(c) \ +- (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_') +-#endif +- +- +-#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res) +- +- +-#if HTTP_PARSER_STRICT +-# define STRICT_CHECK(cond) \ +-do { \ +- if (cond) { \ +- SET_ERRNO(HPE_STRICT); \ +- goto error; \ +- } \ +-} while (0) +-# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead) +-#else +-# define STRICT_CHECK(cond) +-# define NEW_MESSAGE() start_state +-#endif +- +- +-/* Map errno values to strings for human-readable output */ +-#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s }, +-static struct { +- const char *name; +- const char *description; +-} http_strerror_tab[] = { +- HTTP_ERRNO_MAP(HTTP_STRERROR_GEN) +-}; +-#undef HTTP_STRERROR_GEN +- +-int http_message_needs_eof(const http_parser *parser); +- +-/* Our URL parser. +- * +- * This is designed to be shared by http_parser_execute() for URL validation, +- * hence it has a state transition + byte-for-byte interface. In addition, it +- * is meant to be embedded in http_parser_parse_url(), which does the dirty +- * work of turning state transitions URL components for its API. +- * +- * This function should only be invoked with non-space characters. It is +- * assumed that the caller cares about (and can detect) the transition between +- * URL and non-URL states by looking for these. +- */ +-static enum state +-parse_url_char(enum state s, const char ch) +-{ +- if (ch == ' ' || ch == '\r' || ch == '\n') { +- return s_dead; +- } +- +-#if HTTP_PARSER_STRICT +- if (ch == '\t' || ch == '\f') { +- return s_dead; +- } +-#endif +- +- switch (s) { +- case s_req_spaces_before_url: +- /* Proxied requests are followed by scheme of an absolute URI (alpha). +- * All methods except CONNECT are followed by '/' or '*'. +- */ +- +- if (ch == '/' || ch == '*') { +- return s_req_path; +- } +- +- /* The schema must start with an alpha character. After that, it may +- * consist of digits, '+', '-' or '.', followed by a ':'. +- */ +- if (IS_ALPHA(ch)) { +- return s_req_schema; +- } +- +- break; +- +- case s_req_schema: +- if (IS_ALPHANUM(ch) || ch == '+' || ch == '-' || ch == '.') { +- return s; +- } +- +- if (ch == ':') { +- return s_req_schema_slash; +- } +- +- break; +- +- case s_req_schema_slash: +- if (ch == '/') { +- return s_req_schema_slash_slash; +- } +- +- break; +- +- case s_req_schema_slash_slash: +- if (ch == '/') { +- return s_req_server_start; +- } +- +- break; +- +- case s_req_server_with_at: +- if (ch == '@') { +- return s_dead; +- } +- +- /* FALLTHROUGH */ +- case s_req_server_start: +- case s_req_server: +- if (ch == '/') { +- return s_req_path; +- } +- +- if (ch == '?') { +- return s_req_query_string_start; +- } +- +- if (ch == '@') { +- return s_req_server_with_at; +- } +- +- if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') { +- return s_req_server; +- } +- +- break; +- +- case s_req_path: +- if (IS_URL_CHAR(ch)) { +- return s; +- } +- +- switch (ch) { +- case '?': +- return s_req_query_string_start; +- +- case '#': +- return s_req_fragment_start; +- } +- +- break; +- +- case s_req_query_string_start: +- case s_req_query_string: +- if (IS_URL_CHAR(ch)) { +- return s_req_query_string; +- } +- +- switch (ch) { +- case '?': +- /* allow extra '?' in query string */ +- return s_req_query_string; +- +- case '#': +- return s_req_fragment_start; +- } +- +- break; +- +- case s_req_fragment_start: +- if (IS_URL_CHAR(ch)) { +- return s_req_fragment; +- } +- +- switch (ch) { +- case '?': +- return s_req_fragment; +- +- case '#': +- return s; +- } +- +- break; +- +- case s_req_fragment: +- if (IS_URL_CHAR(ch)) { +- return s; +- } +- +- switch (ch) { +- case '?': +- case '#': +- return s; +- } +- +- break; +- +- default: +- break; +- } +- +- /* We should never fall out of the switch above unless there's an error */ +- return s_dead; +-} +- +-size_t http_parser_execute (http_parser *parser, +- const http_parser_settings *settings, +- const char *data, +- size_t len) +-{ +- char c, ch; +- int8_t unhex_val; +- const char *p = data; +- const char *header_field_mark = 0; +- const char *header_value_mark = 0; +- const char *url_mark = 0; +- const char *body_mark = 0; +- +- /* We're in an error state. Don't bother doing anything. */ +- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { +- return 0; +- } +- +- if (len == 0) { +- switch (parser->state) { +- case s_body_identity_eof: +- /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if +- * we got paused. +- */ +- CALLBACK_NOTIFY_NOADVANCE(message_complete); +- return 0; +- +- case s_dead: +- case s_start_req_or_res: +- case s_start_res: +- case s_start_req: +- return 0; +- +- default: +- SET_ERRNO(HPE_INVALID_EOF_STATE); +- return 1; +- } +- } +- +- +- if (parser->state == s_header_field) +- header_field_mark = data; +- if (parser->state == s_header_value) +- header_value_mark = data; +- switch (parser->state) { +- case s_req_path: +- case s_req_schema: +- case s_req_schema_slash: +- case s_req_schema_slash_slash: +- case s_req_server_start: +- case s_req_server: +- case s_req_server_with_at: +- case s_req_query_string_start: +- case s_req_query_string: +- case s_req_fragment_start: +- case s_req_fragment: +- url_mark = data; +- break; +- } +- +- for (p=data; p != data + len; p++) { +- ch = *p; +- +- if (PARSING_HEADER(parser->state)) { +- ++parser->nread; +- /* Buffer overflow attack */ +- if (parser->nread > HTTP_MAX_HEADER_SIZE) { +- SET_ERRNO(HPE_HEADER_OVERFLOW); +- goto error; +- } +- } +- +- reexecute_byte: +- switch (parser->state) { +- +- case s_dead: +- /* this state is used after a 'Connection: close' message +- * the parser will error out if it reads another message +- */ +- if (ch == CR || ch == LF) +- break; +- +- SET_ERRNO(HPE_CLOSED_CONNECTION); +- goto error; +- +- case s_start_req_or_res: +- { +- if (ch == CR || ch == LF) +- break; +- parser->flags = 0; +- parser->content_length = ULLONG_MAX; +- +- if (ch == 'H') { +- parser->state = s_res_or_resp_H; +- +- CALLBACK_NOTIFY(message_begin); +- } else { +- parser->type = HTTP_REQUEST; +- parser->state = s_start_req; +- goto reexecute_byte; +- } +- +- break; +- } +- +- case s_res_or_resp_H: +- if (ch == 'T') { +- parser->type = HTTP_RESPONSE; +- parser->state = s_res_HT; +- } else { +- if (ch != 'E') { +- SET_ERRNO(HPE_INVALID_CONSTANT); +- goto error; +- } +- +- parser->type = HTTP_REQUEST; +- parser->method = HTTP_HEAD; +- parser->index = 2; +- parser->state = s_req_method; +- } +- break; +- +- case s_start_res: +- { +- parser->flags = 0; +- parser->content_length = ULLONG_MAX; +- +- switch (ch) { +- case 'H': +- parser->state = s_res_H; +- break; +- +- case CR: +- case LF: +- break; +- +- default: +- SET_ERRNO(HPE_INVALID_CONSTANT); +- goto error; +- } +- +- CALLBACK_NOTIFY(message_begin); +- break; +- } +- +- case s_res_H: +- STRICT_CHECK(ch != 'T'); +- parser->state = s_res_HT; +- break; +- +- case s_res_HT: +- STRICT_CHECK(ch != 'T'); +- parser->state = s_res_HTT; +- break; +- +- case s_res_HTT: +- STRICT_CHECK(ch != 'P'); +- parser->state = s_res_HTTP; +- break; +- +- case s_res_HTTP: +- STRICT_CHECK(ch != '/'); +- parser->state = s_res_first_http_major; +- break; +- +- case s_res_first_http_major: +- if (ch < '0' || ch > '9') { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_major = ch - '0'; +- parser->state = s_res_http_major; +- break; +- +- /* major HTTP version or dot */ +- case s_res_http_major: +- { +- if (ch == '.') { +- parser->state = s_res_first_http_minor; +- break; +- } +- +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_major *= 10; +- parser->http_major += ch - '0'; +- +- if (parser->http_major > 999) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- break; +- } +- +- /* first digit of minor HTTP version */ +- case s_res_first_http_minor: +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_minor = ch - '0'; +- parser->state = s_res_http_minor; +- break; +- +- /* minor HTTP version or end of request line */ +- case s_res_http_minor: +- { +- if (ch == ' ') { +- parser->state = s_res_first_status_code; +- break; +- } +- +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_minor *= 10; +- parser->http_minor += ch - '0'; +- +- if (parser->http_minor > 999) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- break; +- } +- +- case s_res_first_status_code: +- { +- if (!IS_NUM(ch)) { +- if (ch == ' ') { +- break; +- } +- +- SET_ERRNO(HPE_INVALID_STATUS); +- goto error; +- } +- parser->status_code = ch - '0'; +- parser->state = s_res_status_code; +- break; +- } +- +- case s_res_status_code: +- { +- if (!IS_NUM(ch)) { +- switch (ch) { +- case ' ': +- parser->state = s_res_status; +- break; +- case CR: +- parser->state = s_res_line_almost_done; +- break; +- case LF: +- parser->state = s_header_field_start; +- break; +- default: +- SET_ERRNO(HPE_INVALID_STATUS); +- goto error; +- } +- break; +- } +- +- parser->status_code *= 10; +- parser->status_code += ch - '0'; +- +- if (parser->status_code > 999) { +- SET_ERRNO(HPE_INVALID_STATUS); +- goto error; +- } +- +- break; +- } +- +- case s_res_status: +- /* the human readable status. e.g. "NOT FOUND" +- * we are not humans so just ignore this */ +- if (ch == CR) { +- parser->state = s_res_line_almost_done; +- break; +- } +- +- if (ch == LF) { +- parser->state = s_header_field_start; +- break; +- } +- break; +- +- case s_res_line_almost_done: +- STRICT_CHECK(ch != LF); +- parser->state = s_header_field_start; +- break; +- +- case s_start_req: +- { +- if (ch == CR || ch == LF) +- break; +- parser->flags = 0; +- parser->content_length = ULLONG_MAX; +- +- if (!IS_ALPHA(ch)) { +- SET_ERRNO(HPE_INVALID_METHOD); +- goto error; +- } +- +- parser->method = (enum http_method) 0; +- parser->index = 1; +- switch (ch) { +- case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break; +- case 'D': parser->method = HTTP_DELETE; break; +- case 'G': parser->method = HTTP_GET; break; +- case 'H': parser->method = HTTP_HEAD; break; +- case 'L': parser->method = HTTP_LOCK; break; +- case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break; +- case 'N': parser->method = HTTP_NOTIFY; break; +- case 'O': parser->method = HTTP_OPTIONS; break; +- case 'P': parser->method = HTTP_POST; +- /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ +- break; +- case 'R': parser->method = HTTP_REPORT; break; +- case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH */ break; +- case 'T': parser->method = HTTP_TRACE; break; +- case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break; +- default: +- SET_ERRNO(HPE_INVALID_METHOD); +- goto error; +- } +- parser->state = s_req_method; +- +- CALLBACK_NOTIFY(message_begin); +- +- break; +- } +- +- case s_req_method: +- { +- const char *matcher; +- if (ch == '\0') { +- SET_ERRNO(HPE_INVALID_METHOD); +- goto error; +- } +- +- matcher = method_strings[parser->method]; +- if (ch == ' ' && matcher[parser->index] == '\0') { +- parser->state = s_req_spaces_before_url; +- } else if (ch == matcher[parser->index]) { +- ; /* nada */ +- } else if (parser->method == HTTP_CONNECT) { +- if (parser->index == 1 && ch == 'H') { +- parser->method = HTTP_CHECKOUT; +- } else if (parser->index == 2 && ch == 'P') { +- parser->method = HTTP_COPY; +- } else { +- goto error; +- } +- } else if (parser->method == HTTP_MKCOL) { +- if (parser->index == 1 && ch == 'O') { +- parser->method = HTTP_MOVE; +- } else if (parser->index == 1 && ch == 'E') { +- parser->method = HTTP_MERGE; +- } else if (parser->index == 1 && ch == '-') { +- parser->method = HTTP_MSEARCH; +- } else if (parser->index == 2 && ch == 'A') { +- parser->method = HTTP_MKACTIVITY; +- } else { +- goto error; +- } +- } else if (parser->method == HTTP_SUBSCRIBE) { +- if (parser->index == 1 && ch == 'E') { +- parser->method = HTTP_SEARCH; +- } else { +- goto error; +- } +- } else if (parser->index == 1 && parser->method == HTTP_POST) { +- if (ch == 'R') { +- parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */ +- } else if (ch == 'U') { +- parser->method = HTTP_PUT; /* or HTTP_PURGE */ +- } else if (ch == 'A') { +- parser->method = HTTP_PATCH; +- } else { +- goto error; +- } +- } else if (parser->index == 2) { +- if (parser->method == HTTP_PUT) { +- if (ch == 'R') parser->method = HTTP_PURGE; +- } else if (parser->method == HTTP_UNLOCK) { +- if (ch == 'S') parser->method = HTTP_UNSUBSCRIBE; +- } +- } else if (parser->index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') { +- parser->method = HTTP_PROPPATCH; +- } else { +- SET_ERRNO(HPE_INVALID_METHOD); +- goto error; +- } +- +- ++parser->index; +- break; +- } +- +- case s_req_spaces_before_url: +- { +- if (ch == ' ') break; +- +- MARK(url); +- if (parser->method == HTTP_CONNECT) { +- parser->state = s_req_server_start; +- } +- +- parser->state = parse_url_char((enum state)parser->state, ch); +- if (parser->state == s_dead) { +- SET_ERRNO(HPE_INVALID_URL); +- goto error; +- } +- +- break; +- } +- +- case s_req_schema: +- case s_req_schema_slash: +- case s_req_schema_slash_slash: +- case s_req_server_start: +- { +- switch (ch) { +- /* No whitespace allowed here */ +- case ' ': +- case CR: +- case LF: +- SET_ERRNO(HPE_INVALID_URL); +- goto error; +- default: +- parser->state = parse_url_char((enum state)parser->state, ch); +- if (parser->state == s_dead) { +- SET_ERRNO(HPE_INVALID_URL); +- goto error; +- } +- } +- +- break; +- } +- +- case s_req_server: +- case s_req_server_with_at: +- case s_req_path: +- case s_req_query_string_start: +- case s_req_query_string: +- case s_req_fragment_start: +- case s_req_fragment: +- { +- switch (ch) { +- case ' ': +- parser->state = s_req_http_start; +- CALLBACK_DATA(url); +- break; +- case CR: +- case LF: +- parser->http_major = 0; +- parser->http_minor = 9; +- parser->state = (ch == CR) ? +- s_req_line_almost_done : +- s_header_field_start; +- CALLBACK_DATA(url); +- break; +- default: +- parser->state = parse_url_char((enum state)parser->state, ch); +- if (parser->state == s_dead) { +- SET_ERRNO(HPE_INVALID_URL); +- goto error; +- } +- } +- break; +- } +- +- case s_req_http_start: +- switch (ch) { +- case 'H': +- parser->state = s_req_http_H; +- break; +- case ' ': +- break; +- default: +- SET_ERRNO(HPE_INVALID_CONSTANT); +- goto error; +- } +- break; +- +- case s_req_http_H: +- STRICT_CHECK(ch != 'T'); +- parser->state = s_req_http_HT; +- break; +- +- case s_req_http_HT: +- STRICT_CHECK(ch != 'T'); +- parser->state = s_req_http_HTT; +- break; +- +- case s_req_http_HTT: +- STRICT_CHECK(ch != 'P'); +- parser->state = s_req_http_HTTP; +- break; +- +- case s_req_http_HTTP: +- STRICT_CHECK(ch != '/'); +- parser->state = s_req_first_http_major; +- break; +- +- /* first digit of major HTTP version */ +- case s_req_first_http_major: +- if (ch < '1' || ch > '9') { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_major = ch - '0'; +- parser->state = s_req_http_major; +- break; +- +- /* major HTTP version or dot */ +- case s_req_http_major: +- { +- if (ch == '.') { +- parser->state = s_req_first_http_minor; +- break; +- } +- +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_major *= 10; +- parser->http_major += ch - '0'; +- +- if (parser->http_major > 999) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- break; +- } +- +- /* first digit of minor HTTP version */ +- case s_req_first_http_minor: +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_minor = ch - '0'; +- parser->state = s_req_http_minor; +- break; +- +- /* minor HTTP version or end of request line */ +- case s_req_http_minor: +- { +- if (ch == CR) { +- parser->state = s_req_line_almost_done; +- break; +- } +- +- if (ch == LF) { +- parser->state = s_header_field_start; +- break; +- } +- +- /* XXX allow spaces after digit? */ +- +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- parser->http_minor *= 10; +- parser->http_minor += ch - '0'; +- +- if (parser->http_minor > 999) { +- SET_ERRNO(HPE_INVALID_VERSION); +- goto error; +- } +- +- break; +- } +- +- /* end of request line */ +- case s_req_line_almost_done: +- { +- if (ch != LF) { +- SET_ERRNO(HPE_LF_EXPECTED); +- goto error; +- } +- +- parser->state = s_header_field_start; +- break; +- } +- +- case s_header_field_start: +- { +- if (ch == CR) { +- parser->state = s_headers_almost_done; +- break; +- } +- +- if (ch == LF) { +- /* they might be just sending \n instead of \r\n so this would be +- * the second \n to denote the end of headers*/ +- parser->state = s_headers_almost_done; +- goto reexecute_byte; +- } +- +- c = TOKEN(ch); +- +- if (!c) { +- SET_ERRNO(HPE_INVALID_HEADER_TOKEN); +- goto error; +- } +- +- MARK(header_field); +- +- parser->index = 0; +- parser->state = s_header_field; +- +- switch (c) { +- case 'c': +- parser->header_state = h_C; +- break; +- +- case 'p': +- parser->header_state = h_matching_proxy_connection; +- break; +- +- case 't': +- parser->header_state = h_matching_transfer_encoding; +- break; +- +- case 'u': +- parser->header_state = h_matching_upgrade; +- break; +- +- default: +- parser->header_state = h_general; +- break; +- } +- break; +- } +- +- case s_header_field: +- { +- c = TOKEN(ch); +- +- if (c) { +- switch (parser->header_state) { +- case h_general: +- break; +- +- case h_C: +- parser->index++; +- parser->header_state = (c == 'o' ? h_CO : h_general); +- break; +- +- case h_CO: +- parser->index++; +- parser->header_state = (c == 'n' ? h_CON : h_general); +- break; +- +- case h_CON: +- parser->index++; +- switch (c) { +- case 'n': +- parser->header_state = h_matching_connection; +- break; +- case 't': +- parser->header_state = h_matching_content_length; +- break; +- default: +- parser->header_state = h_general; +- break; +- } +- break; +- +- /* connection */ +- +- case h_matching_connection: +- parser->index++; +- if (parser->index > sizeof(CONNECTION)-1 +- || c != CONNECTION[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(CONNECTION)-2) { +- parser->header_state = h_connection; +- } +- break; +- +- /* proxy-connection */ +- +- case h_matching_proxy_connection: +- parser->index++; +- if (parser->index > sizeof(PROXY_CONNECTION)-1 +- || c != PROXY_CONNECTION[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(PROXY_CONNECTION)-2) { +- parser->header_state = h_connection; +- } +- break; +- +- /* content-length */ +- +- case h_matching_content_length: +- parser->index++; +- if (parser->index > sizeof(CONTENT_LENGTH)-1 +- || c != CONTENT_LENGTH[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(CONTENT_LENGTH)-2) { +- parser->header_state = h_content_length; +- } +- break; +- +- /* transfer-encoding */ +- +- case h_matching_transfer_encoding: +- parser->index++; +- if (parser->index > sizeof(TRANSFER_ENCODING)-1 +- || c != TRANSFER_ENCODING[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) { +- parser->header_state = h_transfer_encoding; +- } +- break; +- +- /* upgrade */ +- +- case h_matching_upgrade: +- parser->index++; +- if (parser->index > sizeof(UPGRADE)-1 +- || c != UPGRADE[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(UPGRADE)-2) { +- parser->header_state = h_upgrade; +- } +- break; +- +- case h_connection: +- case h_content_length: +- case h_transfer_encoding: +- case h_upgrade: +- if (ch != ' ') parser->header_state = h_general; +- break; +- +- default: +- assert(0 && "Unknown header_state"); +- break; +- } +- break; +- } +- +- if (ch == ':') { +- parser->state = s_header_value_start; +- CALLBACK_DATA(header_field); +- break; +- } +- +- if (ch == CR) { +- parser->state = s_header_almost_done; +- CALLBACK_DATA(header_field); +- break; +- } +- +- if (ch == LF) { +- parser->state = s_header_field_start; +- CALLBACK_DATA(header_field); +- break; +- } +- +- SET_ERRNO(HPE_INVALID_HEADER_TOKEN); +- goto error; +- } +- +- case s_header_value_start: +- { +- if (ch == ' ' || ch == '\t') break; +- +- MARK(header_value); +- +- parser->state = s_header_value; +- parser->index = 0; +- +- if (ch == CR) { +- parser->header_state = h_general; +- parser->state = s_header_almost_done; +- CALLBACK_DATA(header_value); +- break; +- } +- +- if (ch == LF) { +- parser->state = s_header_field_start; +- CALLBACK_DATA(header_value); +- break; +- } +- +- c = LOWER(ch); +- +- switch (parser->header_state) { +- case h_upgrade: +- parser->flags |= F_UPGRADE; +- parser->header_state = h_general; +- break; +- +- case h_transfer_encoding: +- /* looking for 'Transfer-Encoding: chunked' */ +- if ('c' == c) { +- parser->header_state = h_matching_transfer_encoding_chunked; +- } else { +- parser->header_state = h_general; +- } +- break; +- +- case h_content_length: +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); +- goto error; +- } +- +- parser->content_length = ch - '0'; +- break; +- +- case h_connection: +- /* looking for 'Connection: keep-alive' */ +- if (c == 'k') { +- parser->header_state = h_matching_connection_keep_alive; +- /* looking for 'Connection: close' */ +- } else if (c == 'c') { +- parser->header_state = h_matching_connection_close; +- } else { +- parser->header_state = h_general; +- } +- break; +- +- default: +- parser->header_state = h_general; +- break; +- } +- break; +- } +- +- case s_header_value: +- { +- +- if (ch == CR) { +- parser->state = s_header_almost_done; +- CALLBACK_DATA(header_value); +- break; +- } +- +- if (ch == LF) { +- parser->state = s_header_almost_done; +- CALLBACK_DATA_NOADVANCE(header_value); +- goto reexecute_byte; +- } +- +- c = LOWER(ch); +- +- switch (parser->header_state) { +- case h_general: +- break; +- +- case h_connection: +- case h_transfer_encoding: +- assert(0 && "Shouldn't get here."); +- break; +- +- case h_content_length: +- { +- uint64_t t; +- +- if (ch == ' ') break; +- +- if (!IS_NUM(ch)) { +- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); +- goto error; +- } +- +- t = parser->content_length; +- t *= 10; +- t += ch - '0'; +- +- /* Overflow? */ +- if (t < parser->content_length || t == ULLONG_MAX) { +- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); +- goto error; +- } +- +- parser->content_length = t; +- break; +- } +- +- /* Transfer-Encoding: chunked */ +- case h_matching_transfer_encoding_chunked: +- parser->index++; +- if (parser->index > sizeof(CHUNKED)-1 +- || c != CHUNKED[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(CHUNKED)-2) { +- parser->header_state = h_transfer_encoding_chunked; +- } +- break; +- +- /* looking for 'Connection: keep-alive' */ +- case h_matching_connection_keep_alive: +- parser->index++; +- if (parser->index > sizeof(KEEP_ALIVE)-1 +- || c != KEEP_ALIVE[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(KEEP_ALIVE)-2) { +- parser->header_state = h_connection_keep_alive; +- } +- break; +- +- /* looking for 'Connection: close' */ +- case h_matching_connection_close: +- parser->index++; +- if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) { +- parser->header_state = h_general; +- } else if (parser->index == sizeof(CLOSE)-2) { +- parser->header_state = h_connection_close; +- } +- break; +- +- case h_transfer_encoding_chunked: +- case h_connection_keep_alive: +- case h_connection_close: +- if (ch != ' ') parser->header_state = h_general; +- break; +- +- default: +- parser->state = s_header_value; +- parser->header_state = h_general; +- break; +- } +- break; +- } +- +- case s_header_almost_done: +- { +- STRICT_CHECK(ch != LF); +- +- parser->state = s_header_value_lws; +- +- switch (parser->header_state) { +- case h_connection_keep_alive: +- parser->flags |= F_CONNECTION_KEEP_ALIVE; +- break; +- case h_connection_close: +- parser->flags |= F_CONNECTION_CLOSE; +- break; +- case h_transfer_encoding_chunked: +- parser->flags |= F_CHUNKED; +- break; +- default: +- break; +- } +- +- break; +- } +- +- case s_header_value_lws: +- { +- if (ch == ' ' || ch == '\t') +- parser->state = s_header_value_start; +- else +- { +- parser->state = s_header_field_start; +- goto reexecute_byte; +- } +- break; +- } +- +- case s_headers_almost_done: +- { +- STRICT_CHECK(ch != LF); +- +- if (parser->flags & F_TRAILING) { +- /* End of a chunked request */ +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- break; +- } +- +- parser->state = s_headers_done; +- +- /* Set this here so that on_headers_complete() callbacks can see it */ +- parser->upgrade = +- (parser->flags & F_UPGRADE || parser->method == HTTP_CONNECT); +- +- /* Here we call the headers_complete callback. This is somewhat +- * different than other callbacks because if the user returns 1, we +- * will interpret that as saying that this message has no body. This +- * is needed for the annoying case of recieving a response to a HEAD +- * request. +- * +- * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so +- * we have to simulate it by handling a change in errno below. +- */ +- if (settings->on_headers_complete) { +- switch (settings->on_headers_complete(parser)) { +- case 0: +- break; +- +- case 1: +- parser->flags |= F_SKIPBODY; +- break; +- +- default: +- SET_ERRNO(HPE_CB_headers_complete); +- return p - data; /* Error */ +- } +- } +- +- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { +- return p - data; +- } +- +- goto reexecute_byte; +- } +- +- case s_headers_done: +- { +- STRICT_CHECK(ch != LF); +- +- parser->nread = 0; +- +- /* Exit, the rest of the connect is in a different protocol. */ +- if (parser->upgrade) { +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- return (p - data) + 1; +- } +- +- if (parser->flags & F_SKIPBODY) { +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- } else if (parser->flags & F_CHUNKED) { +- /* chunked encoding - ignore Content-Length header */ +- parser->state = s_chunk_size_start; +- } else { +- if (parser->content_length == 0) { +- /* Content-Length header given but zero: Content-Length: 0\r\n */ +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- } else if (parser->content_length != ULLONG_MAX) { +- /* Content-Length header given and non-zero */ +- parser->state = s_body_identity; +- } else { +- if (parser->type == HTTP_REQUEST || +- !http_message_needs_eof(parser)) { +- /* Assume content-length 0 - read the next */ +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- } else { +- /* Read body until EOF */ +- parser->state = s_body_identity_eof; +- } +- } +- } +- +- break; +- } +- +- case s_body_identity: +- { +- uint64_t to_read = MIN(parser->content_length, +- (uint64_t) ((data + len) - p)); +- +- assert(parser->content_length != 0 +- && parser->content_length != ULLONG_MAX); +- +- /* The difference between advancing content_length and p is because +- * the latter will automaticaly advance on the next loop iteration. +- * Further, if content_length ends up at 0, we want to see the last +- * byte again for our message complete callback. +- */ +- MARK(body); +- parser->content_length -= to_read; +- p += to_read - 1; +- +- if (parser->content_length == 0) { +- parser->state = s_message_done; +- +- /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte. +- * +- * The alternative to doing this is to wait for the next byte to +- * trigger the data callback, just as in every other case. The +- * problem with this is that this makes it difficult for the test +- * harness to distinguish between complete-on-EOF and +- * complete-on-length. It's not clear that this distinction is +- * important for applications, but let's keep it for now. +- */ +- CALLBACK_DATA_(body, p - body_mark + 1, p - data); +- goto reexecute_byte; +- } +- +- break; +- } +- +- /* read until EOF */ +- case s_body_identity_eof: +- MARK(body); +- p = data + len - 1; +- +- break; +- +- case s_message_done: +- parser->state = NEW_MESSAGE(); +- CALLBACK_NOTIFY(message_complete); +- break; +- +- case s_chunk_size_start: +- { +- assert(parser->nread == 1); +- assert(parser->flags & F_CHUNKED); +- +- unhex_val = unhex[(unsigned char)ch]; +- if (unhex_val == -1) { +- SET_ERRNO(HPE_INVALID_CHUNK_SIZE); +- goto error; +- } +- +- parser->content_length = unhex_val; +- parser->state = s_chunk_size; +- break; +- } +- +- case s_chunk_size: +- { +- uint64_t t; +- +- assert(parser->flags & F_CHUNKED); +- +- if (ch == CR) { +- parser->state = s_chunk_size_almost_done; +- break; +- } +- +- unhex_val = unhex[(unsigned char)ch]; +- +- if (unhex_val == -1) { +- if (ch == ';' || ch == ' ') { +- parser->state = s_chunk_parameters; +- break; +- } +- +- SET_ERRNO(HPE_INVALID_CHUNK_SIZE); +- goto error; +- } +- +- t = parser->content_length; +- t *= 16; +- t += unhex_val; +- +- /* Overflow? */ +- if (t < parser->content_length || t == ULLONG_MAX) { +- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); +- goto error; +- } +- +- parser->content_length = t; +- break; +- } +- +- case s_chunk_parameters: +- { +- assert(parser->flags & F_CHUNKED); +- /* just ignore this. TODO check for overflow */ +- if (ch == CR) { +- parser->state = s_chunk_size_almost_done; +- break; +- } +- break; +- } +- +- case s_chunk_size_almost_done: +- { +- assert(parser->flags & F_CHUNKED); +- STRICT_CHECK(ch != LF); +- +- parser->nread = 0; +- +- if (parser->content_length == 0) { +- parser->flags |= F_TRAILING; +- parser->state = s_header_field_start; +- } else { +- parser->state = s_chunk_data; +- } +- break; +- } +- +- case s_chunk_data: +- { +- uint64_t to_read = MIN(parser->content_length, +- (uint64_t) ((data + len) - p)); +- +- assert(parser->flags & F_CHUNKED); +- assert(parser->content_length != 0 +- && parser->content_length != ULLONG_MAX); +- +- /* See the explanation in s_body_identity for why the content +- * length and data pointers are managed this way. +- */ +- MARK(body); +- parser->content_length -= to_read; +- p += to_read - 1; +- +- if (parser->content_length == 0) { +- parser->state = s_chunk_data_almost_done; +- } +- +- break; +- } +- +- case s_chunk_data_almost_done: +- assert(parser->flags & F_CHUNKED); +- assert(parser->content_length == 0); +- STRICT_CHECK(ch != CR); +- parser->state = s_chunk_data_done; +- CALLBACK_DATA(body); +- break; +- +- case s_chunk_data_done: +- assert(parser->flags & F_CHUNKED); +- STRICT_CHECK(ch != LF); +- parser->nread = 0; +- parser->state = s_chunk_size_start; +- break; +- +- default: +- assert(0 && "unhandled state"); +- SET_ERRNO(HPE_INVALID_INTERNAL_STATE); +- goto error; +- } +- } +- +- /* Run callbacks for any marks that we have leftover after we ran our of +- * bytes. There should be at most one of these set, so it's OK to invoke +- * them in series (unset marks will not result in callbacks). +- * +- * We use the NOADVANCE() variety of callbacks here because 'p' has already +- * overflowed 'data' and this allows us to correct for the off-by-one that +- * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p' +- * value that's in-bounds). +- */ +- +- assert(((header_field_mark ? 1 : 0) + +- (header_value_mark ? 1 : 0) + +- (url_mark ? 1 : 0) + +- (body_mark ? 1 : 0)) <= 1); +- +- CALLBACK_DATA_NOADVANCE(header_field); +- CALLBACK_DATA_NOADVANCE(header_value); +- CALLBACK_DATA_NOADVANCE(url); +- CALLBACK_DATA_NOADVANCE(body); +- +- return len; +- +-error: +- if (HTTP_PARSER_ERRNO(parser) == HPE_OK) { +- SET_ERRNO(HPE_UNKNOWN); +- } +- +- return (p - data); +-} +- +- +-/* Does the parser need to see an EOF to find the end of the message? */ +-int +-http_message_needs_eof (const http_parser *parser) +-{ +- if (parser->type == HTTP_REQUEST) { +- return 0; +- } +- +- /* See RFC 2616 section 4.4 */ +- if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ +- parser->status_code == 204 || /* No Content */ +- parser->status_code == 304 || /* Not Modified */ +- parser->flags & F_SKIPBODY) { /* response to a HEAD request */ +- return 0; +- } +- +- if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) { +- return 0; +- } +- +- return 1; +-} +- +- +-int +-http_should_keep_alive (const http_parser *parser) +-{ +- if (parser->http_major > 0 && parser->http_minor > 0) { +- /* HTTP/1.1 */ +- if (parser->flags & F_CONNECTION_CLOSE) { +- return 0; +- } +- } else { +- /* HTTP/1.0 or earlier */ +- if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { +- return 0; +- } +- } +- +- return !http_message_needs_eof(parser); +-} +- +- +-const char * +-http_method_str (enum http_method m) +-{ +- return ELEM_AT(method_strings, m, ""); +-} +- +- +-void +-http_parser_init (http_parser *parser, enum http_parser_type t) +-{ +- void *data = parser->data; /* preserve application data */ +- memset(parser, 0, sizeof(*parser)); +- parser->data = data; +- parser->type = t; +- parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res)); +- parser->http_errno = HPE_OK; +-} +- +-const char * +-http_errno_name(enum http_errno err) { +- assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); +- return http_strerror_tab[err].name; +-} +- +-const char * +-http_errno_description(enum http_errno err) { +- assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); +- return http_strerror_tab[err].description; +-} +- +-static enum http_host_state +-http_parse_host_char(enum http_host_state s, const char ch) { +- switch(s) { +- case s_http_userinfo: +- case s_http_userinfo_start: +- if (ch == '@') { +- return s_http_host_start; +- } +- +- if (IS_USERINFO_CHAR(ch)) { +- return s_http_userinfo; +- } +- break; +- +- case s_http_host_start: +- if (ch == '[') { +- return s_http_host_v6_start; +- } +- +- if (IS_HOST_CHAR(ch)) { +- return s_http_host; +- } +- +- break; +- +- case s_http_host: +- if (IS_HOST_CHAR(ch)) { +- return s_http_host; +- } +- +- /* FALLTHROUGH */ +- case s_http_host_v6_end: +- if (ch == ':') { +- return s_http_host_port_start; +- } +- +- break; +- +- case s_http_host_v6: +- if (ch == ']') { +- return s_http_host_v6_end; +- } +- +- /* FALLTHROUGH */ +- case s_http_host_v6_start: +- if (IS_HEX(ch) || ch == ':') { +- return s_http_host_v6; +- } +- +- break; +- +- case s_http_host_port: +- case s_http_host_port_start: +- if (IS_NUM(ch)) { +- return s_http_host_port; +- } +- +- break; +- +- default: +- break; +- } +- return s_http_host_dead; +-} +- +-static int +-http_parse_host(const char * buf, struct http_parser_url *u, int found_at) { +- enum http_host_state s; +- +- const char *p; +- size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len; +- +- if (buflen > UINT16_MAX) +- return 1; +- +- u->field_data[UF_HOST].len = 0; +- +- s = found_at ? s_http_userinfo_start : s_http_host_start; +- +- for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) { +- enum http_host_state new_s = http_parse_host_char(s, *p); +- +- if (new_s == s_http_host_dead) { +- return 1; +- } +- +- switch(new_s) { +- case s_http_host: +- if (s != s_http_host) { +- u->field_data[UF_HOST].off = (uint16_t)(p - buf); +- } +- u->field_data[UF_HOST].len++; +- break; +- +- case s_http_host_v6: +- if (s != s_http_host_v6) { +- u->field_data[UF_HOST].off = (uint16_t)(p - buf); +- } +- u->field_data[UF_HOST].len++; +- break; +- +- case s_http_host_port: +- if (s != s_http_host_port) { +- u->field_data[UF_PORT].off = (uint16_t)(p - buf); +- u->field_data[UF_PORT].len = 0; +- u->field_set |= (1 << UF_PORT); +- } +- u->field_data[UF_PORT].len++; +- break; +- +- case s_http_userinfo: +- if (s != s_http_userinfo) { +- u->field_data[UF_USERINFO].off = (uint16_t)(p - buf); +- u->field_data[UF_USERINFO].len = 0; +- u->field_set |= (1 << UF_USERINFO); +- } +- u->field_data[UF_USERINFO].len++; +- break; +- +- default: +- break; +- } +- s = new_s; +- } +- +- /* Make sure we don't end somewhere unexpected */ +- switch (s) { +- case s_http_host_start: +- case s_http_host_v6_start: +- case s_http_host_v6: +- case s_http_userinfo: +- case s_http_userinfo_start: +- return 1; +- default: +- break; +- } +- +- return 0; +-} +- +-int +-http_parser_parse_url(const char *buf, size_t buflen, int is_connect, +- struct http_parser_url *u) +-{ +- enum state s; +- const char *p; +- enum http_parser_url_fields uf, old_uf; +- int found_at = 0; +- +- if (buflen > UINT16_MAX) +- return 1; +- +- u->port = u->field_set = 0; +- s = is_connect ? s_req_server_start : s_req_spaces_before_url; +- uf = old_uf = UF_MAX; +- +- for (p = buf; p < buf + buflen; p++) { +- s = parse_url_char(s, *p); +- +- /* Figure out the next field that we're operating on */ +- switch (s) { +- case s_dead: +- return 1; +- +- /* Skip delimeters */ +- case s_req_schema_slash: +- case s_req_schema_slash_slash: +- case s_req_server_start: +- case s_req_query_string_start: +- case s_req_fragment_start: +- continue; +- +- case s_req_schema: +- uf = UF_SCHEMA; +- break; +- +- case s_req_server_with_at: +- found_at = 1; +- +- /* FALLTROUGH */ +- case s_req_server: +- uf = UF_HOST; +- break; +- +- case s_req_path: +- uf = UF_PATH; +- break; +- +- case s_req_query_string: +- uf = UF_QUERY; +- break; +- +- case s_req_fragment: +- uf = UF_FRAGMENT; +- break; +- +- default: +- assert(!"Unexpected state"); +- return 1; +- } +- +- /* Nothing's changed; soldier on */ +- if (uf == old_uf) { +- u->field_data[uf].len++; +- continue; +- } +- +- u->field_data[uf].off = (uint16_t)(p - buf); +- u->field_data[uf].len = 1; +- +- u->field_set |= (1 << uf); +- old_uf = uf; +- } +- +- /* host must be present if there is a schema */ +- /* parsing http:///toto will fail */ +- if ((u->field_set & ((1 << UF_SCHEMA) | (1 << UF_HOST))) != 0) { +- if (http_parse_host(buf, u, found_at) != 0) { +- return 1; +- } +- } +- +- /* CONNECT requests can only contain "hostname:port" */ +- if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) { +- return 1; +- } +- +- if (u->field_set & (1 << UF_PORT)) { +- /* Don't bother with endp; we've already validated the string */ +- unsigned long v = strtoul(buf + u->field_data[UF_PORT].off, NULL, 10); +- +- /* Ports have a max value of 2^16 */ +- if (v > 0xffff) { +- return 1; +- } +- +- u->port = (uint16_t) v; +- } +- +- return 0; +-} +- +-void +-http_parser_pause(http_parser *parser, int paused) { +- /* Users should only be pausing/unpausing a parser that is not in an error +- * state. In non-debug builds, there's not much that we can do about this +- * other than ignore it. +- */ +- if (HTTP_PARSER_ERRNO(parser) == HPE_OK || +- HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) { +- SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK); +- } else { +- assert(0 && "Attempting to pause parser in error state"); +- } +-} +- +-int +-http_body_is_final(const struct http_parser *parser) { +- return parser->state == s_message_done; +-} +diff --git a/deps/http-parser/http_parser.h b/deps/http-parser/http_parser.h +deleted file mode 100644 +index 67e1d95dd6e3775480d2c88ebb27ba13eb405237..0000000000000000000000000000000000000000 +--- a/deps/http-parser/http_parser.h ++++ /dev/null +@@ -1,305 +0,0 @@ +-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. +- * +- * Permission is hereby granted, free of charge, to any person obtaining a copy +- * of this software and associated documentation files (the "Software"), to +- * deal in the Software without restriction, including without limitation the +- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +- * sell copies of the Software, and to permit persons to whom the Software is +- * furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +- * IN THE SOFTWARE. +- */ +-#ifndef http_parser_h +-#define http_parser_h +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-#define HTTP_PARSER_VERSION_MAJOR 2 +-#define HTTP_PARSER_VERSION_MINOR 0 +- +-#include +-#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600) +-#include +-typedef __int8 int8_t; +-typedef unsigned __int8 uint8_t; +-typedef __int16 int16_t; +-typedef unsigned __int16 uint16_t; +-typedef __int32 int32_t; +-typedef unsigned __int32 uint32_t; +-typedef __int64 int64_t; +-typedef unsigned __int64 uint64_t; +-typedef SIZE_T size_t; +-typedef SSIZE_T ssize_t; +-#elif defined(__sun) || defined(__sun__) +-#include +-#else +-#include +-#endif +- +-/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run +- * faster +- */ +-#ifndef HTTP_PARSER_STRICT +-# define HTTP_PARSER_STRICT 1 +-#endif +- +-/* Maximium header size allowed */ +-#define HTTP_MAX_HEADER_SIZE (80*1024) +- +- +-typedef struct http_parser http_parser; +-typedef struct http_parser_settings http_parser_settings; +- +- +-/* Callbacks should return non-zero to indicate an error. The parser will +- * then halt execution. +- * +- * The one exception is on_headers_complete. In a HTTP_RESPONSE parser +- * returning '1' from on_headers_complete will tell the parser that it +- * should not expect a body. This is used when receiving a response to a +- * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding: +- * chunked' headers that indicate the presence of a body. +- * +- * http_data_cb does not return data chunks. It will be call arbitrarally +- * many times for each string. E.G. you might get 10 callbacks for "on_url" +- * each providing just a few characters more data. +- */ +-typedef int (*http_data_cb) (http_parser*, const char *at, size_t length); +-typedef int (*http_cb) (http_parser*); +- +- +-/* Request Methods */ +-#define HTTP_METHOD_MAP(XX) \ +- XX(0, DELETE, DELETE) \ +- XX(1, GET, GET) \ +- XX(2, HEAD, HEAD) \ +- XX(3, POST, POST) \ +- XX(4, PUT, PUT) \ +- /* pathological */ \ +- XX(5, CONNECT, CONNECT) \ +- XX(6, OPTIONS, OPTIONS) \ +- XX(7, TRACE, TRACE) \ +- /* webdav */ \ +- XX(8, COPY, COPY) \ +- XX(9, LOCK, LOCK) \ +- XX(10, MKCOL, MKCOL) \ +- XX(11, MOVE, MOVE) \ +- XX(12, PROPFIND, PROPFIND) \ +- XX(13, PROPPATCH, PROPPATCH) \ +- XX(14, SEARCH, SEARCH) \ +- XX(15, UNLOCK, UNLOCK) \ +- /* subversion */ \ +- XX(16, REPORT, REPORT) \ +- XX(17, MKACTIVITY, MKACTIVITY) \ +- XX(18, CHECKOUT, CHECKOUT) \ +- XX(19, MERGE, MERGE) \ +- /* upnp */ \ +- XX(20, MSEARCH, M-SEARCH) \ +- XX(21, NOTIFY, NOTIFY) \ +- XX(22, SUBSCRIBE, SUBSCRIBE) \ +- XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \ +- /* RFC-5789 */ \ +- XX(24, PATCH, PATCH) \ +- XX(25, PURGE, PURGE) \ +- +-enum http_method +- { +-#define XX(num, name, string) HTTP_##name = num, +- HTTP_METHOD_MAP(XX) +-#undef XX +- }; +- +- +-enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH }; +- +- +-/* Flag values for http_parser.flags field */ +-enum flags +- { F_CHUNKED = 1 << 0 +- , F_CONNECTION_KEEP_ALIVE = 1 << 1 +- , F_CONNECTION_CLOSE = 1 << 2 +- , F_TRAILING = 1 << 3 +- , F_UPGRADE = 1 << 4 +- , F_SKIPBODY = 1 << 5 +- }; +- +- +-/* Map for errno-related constants +- * +- * The provided argument should be a macro that takes 2 arguments. +- */ +-#define HTTP_ERRNO_MAP(XX) \ +- /* No error */ \ +- XX(OK, "success") \ +- \ +- /* Callback-related errors */ \ +- XX(CB_message_begin, "the on_message_begin callback failed") \ +- XX(CB_url, "the on_url callback failed") \ +- XX(CB_header_field, "the on_header_field callback failed") \ +- XX(CB_header_value, "the on_header_value callback failed") \ +- XX(CB_headers_complete, "the on_headers_complete callback failed") \ +- XX(CB_body, "the on_body callback failed") \ +- XX(CB_message_complete, "the on_message_complete callback failed") \ +- \ +- /* Parsing-related errors */ \ +- XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \ +- XX(HEADER_OVERFLOW, \ +- "too many header bytes seen; overflow detected") \ +- XX(CLOSED_CONNECTION, \ +- "data received after completed connection: close message") \ +- XX(INVALID_VERSION, "invalid HTTP version") \ +- XX(INVALID_STATUS, "invalid HTTP status code") \ +- XX(INVALID_METHOD, "invalid HTTP method") \ +- XX(INVALID_URL, "invalid URL") \ +- XX(INVALID_HOST, "invalid host") \ +- XX(INVALID_PORT, "invalid port") \ +- XX(INVALID_PATH, "invalid path") \ +- XX(INVALID_QUERY_STRING, "invalid query string") \ +- XX(INVALID_FRAGMENT, "invalid fragment") \ +- XX(LF_EXPECTED, "LF character expected") \ +- XX(INVALID_HEADER_TOKEN, "invalid character in header") \ +- XX(INVALID_CONTENT_LENGTH, \ +- "invalid character in content-length header") \ +- XX(INVALID_CHUNK_SIZE, \ +- "invalid character in chunk size header") \ +- XX(INVALID_CONSTANT, "invalid constant string") \ +- XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\ +- XX(STRICT, "strict mode assertion failed") \ +- XX(PAUSED, "parser is paused") \ +- XX(UNKNOWN, "an unknown error occurred") +- +- +-/* Define HPE_* values for each errno value above */ +-#define HTTP_ERRNO_GEN(n, s) HPE_##n, +-enum http_errno { +- HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) +-}; +-#undef HTTP_ERRNO_GEN +- +- +-/* Get an http_errno value from an http_parser */ +-#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno) +- +- +-struct http_parser { +- /** PRIVATE **/ +- unsigned char type : 2; /* enum http_parser_type */ +- unsigned char flags : 6; /* F_* values from 'flags' enum; semi-public */ +- unsigned char state; /* enum state from http_parser.c */ +- unsigned char header_state; /* enum header_state from http_parser.c */ +- unsigned char index; /* index into current matcher */ +- +- uint32_t nread; /* # bytes read in various scenarios */ +- uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */ +- +- /** READ-ONLY **/ +- unsigned short http_major; +- unsigned short http_minor; +- unsigned short status_code; /* responses only */ +- unsigned char method; /* requests only */ +- unsigned char http_errno : 7; +- +- /* 1 = Upgrade header was present and the parser has exited because of that. +- * 0 = No upgrade header present. +- * Should be checked when http_parser_execute() returns in addition to +- * error checking. +- */ +- unsigned char upgrade : 1; +- +- /** PUBLIC **/ +- void *data; /* A pointer to get hook to the "connection" or "socket" object */ +-}; +- +- +-struct http_parser_settings { +- http_cb on_message_begin; +- http_data_cb on_url; +- http_data_cb on_header_field; +- http_data_cb on_header_value; +- http_cb on_headers_complete; +- http_data_cb on_body; +- http_cb on_message_complete; +-}; +- +- +-enum http_parser_url_fields +- { UF_SCHEMA = 0 +- , UF_HOST = 1 +- , UF_PORT = 2 +- , UF_PATH = 3 +- , UF_QUERY = 4 +- , UF_FRAGMENT = 5 +- , UF_USERINFO = 6 +- , UF_MAX = 7 +- }; +- +- +-/* Result structure for http_parser_parse_url(). +- * +- * Callers should index into field_data[] with UF_* values iff field_set +- * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and +- * because we probably have padding left over), we convert any port to +- * a uint16_t. +- */ +-struct http_parser_url { +- uint16_t field_set; /* Bitmask of (1 << UF_*) values */ +- uint16_t port; /* Converted UF_PORT string */ +- +- struct { +- uint16_t off; /* Offset into buffer in which field starts */ +- uint16_t len; /* Length of run in buffer */ +- } field_data[UF_MAX]; +-}; +- +- +-void http_parser_init(http_parser *parser, enum http_parser_type type); +- +- +-size_t http_parser_execute(http_parser *parser, +- const http_parser_settings *settings, +- const char *data, +- size_t len); +- +- +-/* If http_should_keep_alive() in the on_headers_complete or +- * on_message_complete callback returns 0, then this should be +- * the last message on the connection. +- * If you are the server, respond with the "Connection: close" header. +- * If you are the client, close the connection. +- */ +-int http_should_keep_alive(const http_parser *parser); +- +-/* Returns a string version of the HTTP method. */ +-const char *http_method_str(enum http_method m); +- +-/* Return a string name of the given error */ +-const char *http_errno_name(enum http_errno err); +- +-/* Return a string description of the given error */ +-const char *http_errno_description(enum http_errno err); +- +-/* Parse a URL; return nonzero on failure */ +-int http_parser_parse_url(const char *buf, size_t buflen, +- int is_connect, +- struct http_parser_url *u); +- +-/* Pause or un-pause the parser; a nonzero value pauses */ +-void http_parser_pause(http_parser *parser, int paused); +- +-/* Checks if this is the final chunk of the body. */ +-int http_body_is_final(const http_parser *parser); +- +-#ifdef __cplusplus +-} +-#endif +-#endif +diff --git a/deps/llhttp/CMakeLists.txt b/deps/llhttp/CMakeLists.txt +new file mode 100644 +index 0000000000000000000000000000000000000000..6965335ab276cae5f2d10decfabf1729c4a9ab23 +--- /dev/null ++++ b/deps/llhttp/CMakeLists.txt +@@ -0,0 +1,8 @@ ++file(GLOB SRC_LLHTTP "*.c" "*.h") ++list(SORT SRC_LLHTTP) ++ ++add_library(llhttp OBJECT ${SRC_LLHTTP}) ++ ++if(NOT MSVC) ++ set_source_files_properties(api.c http.c llhttp.c PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter -Wno-missing-declarations") ++endif() +diff --git a/deps/llhttp/LICENSE-MIT b/deps/llhttp/LICENSE-MIT +new file mode 100644 +index 0000000000000000000000000000000000000000..6c1512dd6bcd6de314673f8c2c7ff3fd6139f28e +--- /dev/null ++++ b/deps/llhttp/LICENSE-MIT +@@ -0,0 +1,22 @@ ++This software is licensed under the MIT License. ++ ++Copyright Fedor Indutny, 2018. ++ ++Permission is hereby granted, free of charge, to any person obtaining a ++copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to permit ++persons to whom the Software is furnished to do so, subject to the ++following conditions: ++ ++The above copyright notice and this permission notice shall be included ++in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN ++NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, ++DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR ++OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE ++USE OR OTHER DEALINGS IN THE SOFTWARE. +diff --git a/deps/llhttp/api.c b/deps/llhttp/api.c +new file mode 100644 +index 0000000000000000000000000000000000000000..8c2ce3dc5c455bef94b2b57f886fccf4cfcb9c86 +--- /dev/null ++++ b/deps/llhttp/api.c +@@ -0,0 +1,510 @@ ++#include ++#include ++#include ++ ++#include "llhttp.h" ++ ++#define CALLBACK_MAYBE(PARSER, NAME) \ ++ do { \ ++ const llhttp_settings_t* settings; \ ++ settings = (const llhttp_settings_t*) (PARSER)->settings; \ ++ if (settings == NULL || settings->NAME == NULL) { \ ++ err = 0; \ ++ break; \ ++ } \ ++ err = settings->NAME((PARSER)); \ ++ } while (0) ++ ++#define SPAN_CALLBACK_MAYBE(PARSER, NAME, START, LEN) \ ++ do { \ ++ const llhttp_settings_t* settings; \ ++ settings = (const llhttp_settings_t*) (PARSER)->settings; \ ++ if (settings == NULL || settings->NAME == NULL) { \ ++ err = 0; \ ++ break; \ ++ } \ ++ err = settings->NAME((PARSER), (START), (LEN)); \ ++ if (err == -1) { \ ++ err = HPE_USER; \ ++ llhttp_set_error_reason((PARSER), "Span callback error in " #NAME); \ ++ } \ ++ } while (0) ++ ++void llhttp_init(llhttp_t* parser, llhttp_type_t type, ++ const llhttp_settings_t* settings) { ++ llhttp__internal_init(parser); ++ ++ parser->type = type; ++ parser->settings = (void*) settings; ++} ++ ++ ++#if defined(__wasm__) ++ ++extern int wasm_on_message_begin(llhttp_t * p); ++extern int wasm_on_url(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_status(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_header_field(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_header_value(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_headers_complete(llhttp_t * p, int status_code, ++ uint8_t upgrade, int should_keep_alive); ++extern int wasm_on_body(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_message_complete(llhttp_t * p); ++ ++static int wasm_on_headers_complete_wrap(llhttp_t* p) { ++ return wasm_on_headers_complete(p, p->status_code, p->upgrade, ++ llhttp_should_keep_alive(p)); ++} ++ ++const llhttp_settings_t wasm_settings = { ++ wasm_on_message_begin, ++ wasm_on_url, ++ wasm_on_status, ++ NULL, ++ NULL, ++ wasm_on_header_field, ++ wasm_on_header_value, ++ NULL, ++ NULL, ++ wasm_on_headers_complete_wrap, ++ wasm_on_body, ++ wasm_on_message_complete, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++}; ++ ++ ++llhttp_t* llhttp_alloc(llhttp_type_t type) { ++ llhttp_t* parser = malloc(sizeof(llhttp_t)); ++ llhttp_init(parser, type, &wasm_settings); ++ return parser; ++} ++ ++void llhttp_free(llhttp_t* parser) { ++ free(parser); ++} ++ ++#endif // defined(__wasm__) ++ ++/* Some getters required to get stuff from the parser */ ++ ++uint8_t llhttp_get_type(llhttp_t* parser) { ++ return parser->type; ++} ++ ++uint8_t llhttp_get_http_major(llhttp_t* parser) { ++ return parser->http_major; ++} ++ ++uint8_t llhttp_get_http_minor(llhttp_t* parser) { ++ return parser->http_minor; ++} ++ ++uint8_t llhttp_get_method(llhttp_t* parser) { ++ return parser->method; ++} ++ ++int llhttp_get_status_code(llhttp_t* parser) { ++ return parser->status_code; ++} ++ ++uint8_t llhttp_get_upgrade(llhttp_t* parser) { ++ return parser->upgrade; ++} ++ ++ ++void llhttp_reset(llhttp_t* parser) { ++ llhttp_type_t type = parser->type; ++ const llhttp_settings_t* settings = parser->settings; ++ void* data = parser->data; ++ uint16_t lenient_flags = parser->lenient_flags; ++ ++ llhttp__internal_init(parser); ++ ++ parser->type = type; ++ parser->settings = (void*) settings; ++ parser->data = data; ++ parser->lenient_flags = lenient_flags; ++} ++ ++ ++llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len) { ++ return llhttp__internal_execute(parser, data, data + len); ++} ++ ++ ++void llhttp_settings_init(llhttp_settings_t* settings) { ++ memset(settings, 0, sizeof(*settings)); ++} ++ ++ ++llhttp_errno_t llhttp_finish(llhttp_t* parser) { ++ int err; ++ ++ /* We're in an error state. Don't bother doing anything. */ ++ if (parser->error != 0) { ++ return 0; ++ } ++ ++ switch (parser->finish) { ++ case HTTP_FINISH_SAFE_WITH_CB: ++ CALLBACK_MAYBE(parser, on_message_complete); ++ if (err != HPE_OK) return err; ++ ++ /* FALLTHROUGH */ ++ case HTTP_FINISH_SAFE: ++ return HPE_OK; ++ case HTTP_FINISH_UNSAFE: ++ parser->reason = "Invalid EOF state"; ++ return HPE_INVALID_EOF_STATE; ++ default: ++ abort(); ++ } ++} ++ ++ ++void llhttp_pause(llhttp_t* parser) { ++ if (parser->error != HPE_OK) { ++ return; ++ } ++ ++ parser->error = HPE_PAUSED; ++ parser->reason = "Paused"; ++} ++ ++ ++void llhttp_resume(llhttp_t* parser) { ++ if (parser->error != HPE_PAUSED) { ++ return; ++ } ++ ++ parser->error = 0; ++} ++ ++ ++void llhttp_resume_after_upgrade(llhttp_t* parser) { ++ if (parser->error != HPE_PAUSED_UPGRADE) { ++ return; ++ } ++ ++ parser->error = 0; ++} ++ ++ ++llhttp_errno_t llhttp_get_errno(const llhttp_t* parser) { ++ return parser->error; ++} ++ ++ ++const char* llhttp_get_error_reason(const llhttp_t* parser) { ++ return parser->reason; ++} ++ ++ ++void llhttp_set_error_reason(llhttp_t* parser, const char* reason) { ++ parser->reason = reason; ++} ++ ++ ++const char* llhttp_get_error_pos(const llhttp_t* parser) { ++ return parser->error_pos; ++} ++ ++ ++const char* llhttp_errno_name(llhttp_errno_t err) { ++#define HTTP_ERRNO_GEN(CODE, NAME, _) case HPE_##NAME: return "HPE_" #NAME; ++ switch (err) { ++ HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) ++ default: abort(); ++ } ++#undef HTTP_ERRNO_GEN ++} ++ ++ ++const char* llhttp_method_name(llhttp_method_t method) { ++#define HTTP_METHOD_GEN(NUM, NAME, STRING) case HTTP_##NAME: return #STRING; ++ switch (method) { ++ HTTP_ALL_METHOD_MAP(HTTP_METHOD_GEN) ++ default: abort(); ++ } ++#undef HTTP_METHOD_GEN ++} ++ ++const char* llhttp_status_name(llhttp_status_t status) { ++#define HTTP_STATUS_GEN(NUM, NAME, STRING) case HTTP_STATUS_##NAME: return #STRING; ++ switch (status) { ++ HTTP_STATUS_MAP(HTTP_STATUS_GEN) ++ default: abort(); ++ } ++#undef HTTP_STATUS_GEN ++} ++ ++ ++void llhttp_set_lenient_headers(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_HEADERS; ++ } else { ++ parser->lenient_flags &= ~LENIENT_HEADERS; ++ } ++} ++ ++ ++void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_CHUNKED_LENGTH; ++ } else { ++ parser->lenient_flags &= ~LENIENT_CHUNKED_LENGTH; ++ } ++} ++ ++ ++void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_KEEP_ALIVE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_KEEP_ALIVE; ++ } ++} ++ ++void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_TRANSFER_ENCODING; ++ } else { ++ parser->lenient_flags &= ~LENIENT_TRANSFER_ENCODING; ++ } ++} ++ ++void llhttp_set_lenient_version(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_VERSION; ++ } else { ++ parser->lenient_flags &= ~LENIENT_VERSION; ++ } ++} ++ ++void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_DATA_AFTER_CLOSE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_DATA_AFTER_CLOSE; ++ } ++} ++ ++void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_LF_AFTER_CR; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_LF_AFTER_CR; ++ } ++} ++ ++void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; ++ } ++} ++ ++void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_CR_BEFORE_LF; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_CR_BEFORE_LF; ++ } ++} ++ ++void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_SPACES_AFTER_CHUNK_SIZE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_SPACES_AFTER_CHUNK_SIZE; ++ } ++} ++ ++/* Callbacks */ ++ ++ ++int llhttp__on_message_begin(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_message_begin); ++ return err; ++} ++ ++ ++int llhttp__on_url(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_url, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_url_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_url_complete); ++ return err; ++} ++ ++ ++int llhttp__on_status(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_status, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_status_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_status_complete); ++ return err; ++} ++ ++ ++int llhttp__on_method(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_method, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_method_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_method_complete); ++ return err; ++} ++ ++ ++int llhttp__on_version(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_version, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_version_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_version_complete); ++ return err; ++} ++ ++ ++int llhttp__on_header_field(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_header_field, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_header_field_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_header_field_complete); ++ return err; ++} ++ ++ ++int llhttp__on_header_value(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_header_value, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_header_value_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_header_value_complete); ++ return err; ++} ++ ++ ++int llhttp__on_headers_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_headers_complete); ++ return err; ++} ++ ++ ++int llhttp__on_message_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_message_complete); ++ return err; ++} ++ ++ ++int llhttp__on_body(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_body, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_header(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_header); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_name(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_chunk_extension_name, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_name_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_extension_name_complete); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_value(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_chunk_extension_value, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_value_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_extension_value_complete); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_complete); ++ return err; ++} ++ ++ ++int llhttp__on_reset(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_reset); ++ return err; ++} ++ ++ ++/* Private */ ++ ++ ++void llhttp__debug(llhttp_t* s, const char* p, const char* endp, ++ const char* msg) { ++ if (p == endp) { ++ fprintf(stderr, "p=%p type=%d flags=%02x next=null debug=%s\n", s, s->type, ++ s->flags, msg); ++ } else { ++ fprintf(stderr, "p=%p type=%d flags=%02x next=%02x debug=%s\n", s, ++ s->type, s->flags, *p, msg); ++ } ++} +diff --git a/deps/llhttp/http.c b/deps/llhttp/http.c +new file mode 100644 +index 0000000000000000000000000000000000000000..1ab91a55796e01bc7bda2b96cdcda6419857c386 +--- /dev/null ++++ b/deps/llhttp/http.c +@@ -0,0 +1,170 @@ ++#include ++#ifndef LLHTTP__TEST ++# include "llhttp.h" ++#else ++# define llhttp_t llparse_t ++#endif /* */ ++ ++int llhttp_message_needs_eof(const llhttp_t* parser); ++int llhttp_should_keep_alive(const llhttp_t* parser); ++ ++int llhttp__before_headers_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ /* Set this here so that on_headers_complete() callbacks can see it */ ++ if ((parser->flags & F_UPGRADE) && ++ (parser->flags & F_CONNECTION_UPGRADE)) { ++ /* For responses, "Upgrade: foo" and "Connection: upgrade" are ++ * mandatory only when it is a 101 Switching Protocols response, ++ * otherwise it is purely informational, to announce support. ++ */ ++ parser->upgrade = ++ (parser->type == HTTP_REQUEST || parser->status_code == 101); ++ } else { ++ parser->upgrade = (parser->method == HTTP_CONNECT); ++ } ++ return 0; ++} ++ ++ ++/* Return values: ++ * 0 - No body, `restart`, message_complete ++ * 1 - CONNECT request, `restart`, message_complete, and pause ++ * 2 - chunk_size_start ++ * 3 - body_identity ++ * 4 - body_identity_eof ++ * 5 - invalid transfer-encoding for request ++ */ ++int llhttp__after_headers_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ int hasBody; ++ ++ hasBody = parser->flags & F_CHUNKED || parser->content_length > 0; ++ if ( ++ (parser->upgrade && (parser->method == HTTP_CONNECT || ++ (parser->flags & F_SKIPBODY) || !hasBody)) || ++ /* See RFC 2616 section 4.4 - 1xx e.g. Continue */ ++ (parser->type == HTTP_RESPONSE && parser->status_code == 101) ++ ) { ++ /* Exit, the rest of the message is in a different protocol. */ ++ return 1; ++ } ++ ++ if (parser->type == HTTP_RESPONSE && parser->status_code == 100) { ++ /* No body, restart as the message is complete */ ++ return 0; ++ } ++ ++ /* See RFC 2616 section 4.4 */ ++ if ( ++ parser->flags & F_SKIPBODY || /* response to a HEAD request */ ++ ( ++ parser->type == HTTP_RESPONSE && ( ++ parser->status_code == 102 || /* Processing */ ++ parser->status_code == 103 || /* Early Hints */ ++ parser->status_code == 204 || /* No Content */ ++ parser->status_code == 304 /* Not Modified */ ++ ) ++ ) ++ ) { ++ return 0; ++ } else if (parser->flags & F_CHUNKED) { ++ /* chunked encoding - ignore Content-Length header, prepare for a chunk */ ++ return 2; ++ } else if (parser->flags & F_TRANSFER_ENCODING) { ++ if (parser->type == HTTP_REQUEST && ++ (parser->lenient_flags & LENIENT_CHUNKED_LENGTH) == 0 && ++ (parser->lenient_flags & LENIENT_TRANSFER_ENCODING) == 0) { ++ /* RFC 7230 3.3.3 */ ++ ++ /* If a Transfer-Encoding header field ++ * is present in a request and the chunked transfer coding is not ++ * the final encoding, the message body length cannot be determined ++ * reliably; the server MUST respond with the 400 (Bad Request) ++ * status code and then close the connection. ++ */ ++ return 5; ++ } else { ++ /* RFC 7230 3.3.3 */ ++ ++ /* If a Transfer-Encoding header field is present in a response and ++ * the chunked transfer coding is not the final encoding, the ++ * message body length is determined by reading the connection until ++ * it is closed by the server. ++ */ ++ return 4; ++ } ++ } else { ++ if (!(parser->flags & F_CONTENT_LENGTH)) { ++ if (!llhttp_message_needs_eof(parser)) { ++ /* Assume content-length 0 - read the next */ ++ return 0; ++ } else { ++ /* Read body until EOF */ ++ return 4; ++ } ++ } else if (parser->content_length == 0) { ++ /* Content-Length header given but zero: Content-Length: 0\r\n */ ++ return 0; ++ } else { ++ /* Content-Length header given and non-zero */ ++ return 3; ++ } ++ } ++} ++ ++ ++int llhttp__after_message_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ int should_keep_alive; ++ ++ should_keep_alive = llhttp_should_keep_alive(parser); ++ parser->finish = HTTP_FINISH_SAFE; ++ parser->flags = 0; ++ ++ /* NOTE: this is ignored in loose parsing mode */ ++ return should_keep_alive; ++} ++ ++ ++int llhttp_message_needs_eof(const llhttp_t* parser) { ++ if (parser->type == HTTP_REQUEST) { ++ return 0; ++ } ++ ++ /* See RFC 2616 section 4.4 */ ++ if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ ++ parser->status_code == 204 || /* No Content */ ++ parser->status_code == 304 || /* Not Modified */ ++ (parser->flags & F_SKIPBODY)) { /* response to a HEAD request */ ++ return 0; ++ } ++ ++ /* RFC 7230 3.3.3, see `llhttp__after_headers_complete` */ ++ if ((parser->flags & F_TRANSFER_ENCODING) && ++ (parser->flags & F_CHUNKED) == 0) { ++ return 1; ++ } ++ ++ if (parser->flags & (F_CHUNKED | F_CONTENT_LENGTH)) { ++ return 0; ++ } ++ ++ return 1; ++} ++ ++ ++int llhttp_should_keep_alive(const llhttp_t* parser) { ++ if (parser->http_major > 0 && parser->http_minor > 0) { ++ /* HTTP/1.1 */ ++ if (parser->flags & F_CONNECTION_CLOSE) { ++ return 0; ++ } ++ } else { ++ /* HTTP/1.0 or earlier */ ++ if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { ++ return 0; ++ } ++ } ++ ++ return !llhttp_message_needs_eof(parser); ++} +diff --git a/deps/llhttp/llhttp.c b/deps/llhttp/llhttp.c +new file mode 100644 +index 0000000000000000000000000000000000000000..3ef3b817f3d9cee143a17e152d6170022ea53232 +--- /dev/null ++++ b/deps/llhttp/llhttp.c +@@ -0,0 +1,10168 @@ ++#include ++#include ++#include ++ ++#ifdef __SSE4_2__ ++ #ifdef _MSC_VER ++ #include ++ #else /* !_MSC_VER */ ++ #include ++ #endif /* _MSC_VER */ ++#endif /* __SSE4_2__ */ ++ ++#ifdef _MSC_VER ++ #define ALIGN(n) _declspec(align(n)) ++#else /* !_MSC_VER */ ++ #define ALIGN(n) __attribute__((aligned(n))) ++#endif /* _MSC_VER */ ++ ++#include "llhttp.h" ++ ++typedef int (*llhttp__internal__span_cb)( ++ llhttp__internal_t*, const char*, const char*); ++ ++static const unsigned char llparse_blob0[] = { ++ 'o', 'n' ++}; ++static const unsigned char llparse_blob1[] = { ++ 'e', 'c', 't', 'i', 'o', 'n' ++}; ++static const unsigned char llparse_blob2[] = { ++ 'l', 'o', 's', 'e' ++}; ++static const unsigned char llparse_blob3[] = { ++ 'e', 'e', 'p', '-', 'a', 'l', 'i', 'v', 'e' ++}; ++static const unsigned char llparse_blob4[] = { ++ 'p', 'g', 'r', 'a', 'd', 'e' ++}; ++static const unsigned char llparse_blob5[] = { ++ 'c', 'h', 'u', 'n', 'k', 'e', 'd' ++}; ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob6[] = { ++ 0x9, 0x9, ' ', '~', 0x80, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, ++ 0x0, 0x0, 0x0, 0x0, 0x0 ++}; ++#endif /* __SSE4_2__ */ ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob7[] = { ++ '!', '!', '#', '\'', '*', '+', '-', '.', '0', '9', 'A', ++ 'Z', '^', 'z', '|', '|' ++}; ++#endif /* __SSE4_2__ */ ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob8[] = { ++ '~', '~', 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ++ 0x0, 0x0, 0x0, 0x0, 0x0 ++}; ++#endif /* __SSE4_2__ */ ++static const unsigned char llparse_blob9[] = { ++ 'e', 'n', 't', '-', 'l', 'e', 'n', 'g', 't', 'h' ++}; ++static const unsigned char llparse_blob10[] = { ++ 'r', 'o', 'x', 'y', '-', 'c', 'o', 'n', 'n', 'e', 'c', ++ 't', 'i', 'o', 'n' ++}; ++static const unsigned char llparse_blob11[] = { ++ 'r', 'a', 'n', 's', 'f', 'e', 'r', '-', 'e', 'n', 'c', ++ 'o', 'd', 'i', 'n', 'g' ++}; ++static const unsigned char llparse_blob12[] = { ++ 'p', 'g', 'r', 'a', 'd', 'e' ++}; ++static const unsigned char llparse_blob13[] = { ++ 'T', 'T', 'P', '/' ++}; ++static const unsigned char llparse_blob14[] = { ++ 0xd, 0xa, 0xd, 0xa, 'S', 'M', 0xd, 0xa, 0xd, 0xa ++}; ++static const unsigned char llparse_blob15[] = { ++ 'C', 'E', '/' ++}; ++static const unsigned char llparse_blob16[] = { ++ 'T', 'S', 'P', '/' ++}; ++static const unsigned char llparse_blob17[] = { ++ 'N', 'O', 'U', 'N', 'C', 'E' ++}; ++static const unsigned char llparse_blob18[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob19[] = { ++ 'E', 'C', 'K', 'O', 'U', 'T' ++}; ++static const unsigned char llparse_blob20[] = { ++ 'N', 'E', 'C', 'T' ++}; ++static const unsigned char llparse_blob21[] = { ++ 'E', 'T', 'E' ++}; ++static const unsigned char llparse_blob22[] = { ++ 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob23[] = { ++ 'L', 'U', 'S', 'H' ++}; ++static const unsigned char llparse_blob24[] = { ++ 'E', 'T' ++}; ++static const unsigned char llparse_blob25[] = { ++ 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' ++}; ++static const unsigned char llparse_blob26[] = { ++ 'E', 'A', 'D' ++}; ++static const unsigned char llparse_blob27[] = { ++ 'N', 'K' ++}; ++static const unsigned char llparse_blob28[] = { ++ 'C', 'K' ++}; ++static const unsigned char llparse_blob29[] = { ++ 'S', 'E', 'A', 'R', 'C', 'H' ++}; ++static const unsigned char llparse_blob30[] = { ++ 'R', 'G', 'E' ++}; ++static const unsigned char llparse_blob31[] = { ++ 'C', 'T', 'I', 'V', 'I', 'T', 'Y' ++}; ++static const unsigned char llparse_blob32[] = { ++ 'L', 'E', 'N', 'D', 'A', 'R' ++}; ++static const unsigned char llparse_blob33[] = { ++ 'V', 'E' ++}; ++static const unsigned char llparse_blob34[] = { ++ 'O', 'T', 'I', 'F', 'Y' ++}; ++static const unsigned char llparse_blob35[] = { ++ 'P', 'T', 'I', 'O', 'N', 'S' ++}; ++static const unsigned char llparse_blob36[] = { ++ 'C', 'H' ++}; ++static const unsigned char llparse_blob37[] = { ++ 'S', 'E' ++}; ++static const unsigned char llparse_blob38[] = { ++ 'A', 'Y' ++}; ++static const unsigned char llparse_blob39[] = { ++ 'S', 'T' ++}; ++static const unsigned char llparse_blob40[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob41[] = { ++ 'A', 'T', 'C', 'H' ++}; ++static const unsigned char llparse_blob42[] = { ++ 'G', 'E' ++}; ++static const unsigned char llparse_blob43[] = { ++ 'U', 'E', 'R', 'Y' ++}; ++static const unsigned char llparse_blob44[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob45[] = { ++ 'O', 'R', 'D' ++}; ++static const unsigned char llparse_blob46[] = { ++ 'I', 'R', 'E', 'C', 'T' ++}; ++static const unsigned char llparse_blob47[] = { ++ 'O', 'R', 'T' ++}; ++static const unsigned char llparse_blob48[] = { ++ 'R', 'C', 'H' ++}; ++static const unsigned char llparse_blob49[] = { ++ 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' ++}; ++static const unsigned char llparse_blob50[] = { ++ 'U', 'R', 'C', 'E' ++}; ++static const unsigned char llparse_blob51[] = { ++ 'B', 'S', 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob52[] = { ++ 'A', 'R', 'D', 'O', 'W', 'N' ++}; ++static const unsigned char llparse_blob53[] = { ++ 'A', 'C', 'E' ++}; ++static const unsigned char llparse_blob54[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob55[] = { ++ 'N', 'K' ++}; ++static const unsigned char llparse_blob56[] = { ++ 'C', 'K' ++}; ++static const unsigned char llparse_blob57[] = { ++ 'U', 'B', 'S', 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob58[] = { ++ 'H', 'T', 'T', 'P', '/' ++}; ++static const unsigned char llparse_blob59[] = { ++ 'A', 'D' ++}; ++static const unsigned char llparse_blob60[] = { ++ 'T', 'P', '/' ++}; ++ ++enum llparse_match_status_e { ++ kMatchComplete, ++ kMatchPause, ++ kMatchMismatch ++}; ++typedef enum llparse_match_status_e llparse_match_status_t; ++ ++struct llparse_match_s { ++ llparse_match_status_t status; ++ const unsigned char* current; ++}; ++typedef struct llparse_match_s llparse_match_t; ++ ++static llparse_match_t llparse__match_sequence_to_lower( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = ((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p)); ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++static llparse_match_t llparse__match_sequence_to_lower_unsafe( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = ((*p) | 0x20); ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++static llparse_match_t llparse__match_sequence_id( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = *p; ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++enum llparse_state_e { ++ s_error, ++ s_n_llhttp__internal__n_closed, ++ s_n_llhttp__internal__n_invoke_llhttp__after_message_complete, ++ s_n_llhttp__internal__n_pause_1, ++ s_n_llhttp__internal__n_invoke_is_equal_upgrade, ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2, ++ s_n_llhttp__internal__n_chunk_data_almost_done_1, ++ s_n_llhttp__internal__n_chunk_data_almost_done, ++ s_n_llhttp__internal__n_consume_content_length, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body, ++ s_n_llhttp__internal__n_invoke_is_equal_content_length, ++ s_n_llhttp__internal__n_chunk_size_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_9, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_10, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_done, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2, ++ s_n_llhttp__internal__n_error_30, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair, ++ s_n_llhttp__internal__n_error_31, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3, ++ s_n_llhttp__internal__n_error_33, ++ s_n_llhttp__internal__n_chunk_extension_value, ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value, ++ s_n_llhttp__internal__n_error_34, ++ s_n_llhttp__internal__n_chunk_extension_name, ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name, ++ s_n_llhttp__internal__n_chunk_extensions, ++ s_n_llhttp__internal__n_chunk_size_otherwise, ++ s_n_llhttp__internal__n_chunk_size, ++ s_n_llhttp__internal__n_chunk_size_digit, ++ s_n_llhttp__internal__n_invoke_update_content_length_1, ++ s_n_llhttp__internal__n_consume_content_length_1, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_1, ++ s_n_llhttp__internal__n_eof, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_2, ++ s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete, ++ s_n_llhttp__internal__n_error_5, ++ s_n_llhttp__internal__n_headers_almost_done, ++ s_n_llhttp__internal__n_header_field_colon_discard_ws, ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value, ++ s_n_llhttp__internal__n_header_value_discard_lws, ++ s_n_llhttp__internal__n_header_value_discard_ws_almost_done, ++ s_n_llhttp__internal__n_header_value_lws, ++ s_n_llhttp__internal__n_header_value_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_17, ++ s_n_llhttp__internal__n_header_value_lenient, ++ s_n_llhttp__internal__n_error_54, ++ s_n_llhttp__internal__n_header_value_otherwise, ++ s_n_llhttp__internal__n_header_value_connection_token, ++ s_n_llhttp__internal__n_header_value_connection_ws, ++ s_n_llhttp__internal__n_header_value_connection_1, ++ s_n_llhttp__internal__n_header_value_connection_2, ++ s_n_llhttp__internal__n_header_value_connection_3, ++ s_n_llhttp__internal__n_header_value_connection, ++ s_n_llhttp__internal__n_error_56, ++ s_n_llhttp__internal__n_error_57, ++ s_n_llhttp__internal__n_header_value_content_length_ws, ++ s_n_llhttp__internal__n_header_value_content_length, ++ s_n_llhttp__internal__n_error_59, ++ s_n_llhttp__internal__n_error_58, ++ s_n_llhttp__internal__n_header_value_te_token_ows, ++ s_n_llhttp__internal__n_header_value, ++ s_n_llhttp__internal__n_header_value_te_token, ++ s_n_llhttp__internal__n_header_value_te_chunked_last, ++ s_n_llhttp__internal__n_header_value_te_chunked, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1, ++ s_n_llhttp__internal__n_header_value_discard_ws, ++ s_n_llhttp__internal__n_invoke_load_header_state, ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete, ++ s_n_llhttp__internal__n_header_field_general_otherwise, ++ s_n_llhttp__internal__n_header_field_general, ++ s_n_llhttp__internal__n_header_field_colon, ++ s_n_llhttp__internal__n_header_field_3, ++ s_n_llhttp__internal__n_header_field_4, ++ s_n_llhttp__internal__n_header_field_2, ++ s_n_llhttp__internal__n_header_field_1, ++ s_n_llhttp__internal__n_header_field_5, ++ s_n_llhttp__internal__n_header_field_6, ++ s_n_llhttp__internal__n_header_field_7, ++ s_n_llhttp__internal__n_header_field, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_field, ++ s_n_llhttp__internal__n_header_field_start, ++ s_n_llhttp__internal__n_headers_start, ++ s_n_llhttp__internal__n_url_to_http_09, ++ s_n_llhttp__internal__n_url_skip_to_http09, ++ s_n_llhttp__internal__n_url_skip_lf_to_http09_1, ++ s_n_llhttp__internal__n_url_skip_lf_to_http09, ++ s_n_llhttp__internal__n_req_pri_upgrade, ++ s_n_llhttp__internal__n_req_http_complete_crlf, ++ s_n_llhttp__internal__n_req_http_complete, ++ s_n_llhttp__internal__n_invoke_load_method_1, ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete, ++ s_n_llhttp__internal__n_error_66, ++ s_n_llhttp__internal__n_error_73, ++ s_n_llhttp__internal__n_req_http_minor, ++ s_n_llhttp__internal__n_error_74, ++ s_n_llhttp__internal__n_req_http_dot, ++ s_n_llhttp__internal__n_error_75, ++ s_n_llhttp__internal__n_req_http_major, ++ s_n_llhttp__internal__n_span_start_llhttp__on_version, ++ s_n_llhttp__internal__n_req_http_start_1, ++ s_n_llhttp__internal__n_req_http_start_2, ++ s_n_llhttp__internal__n_req_http_start_3, ++ s_n_llhttp__internal__n_req_http_start, ++ s_n_llhttp__internal__n_url_to_http, ++ s_n_llhttp__internal__n_url_skip_to_http, ++ s_n_llhttp__internal__n_url_fragment, ++ s_n_llhttp__internal__n_span_end_stub_query_3, ++ s_n_llhttp__internal__n_url_query, ++ s_n_llhttp__internal__n_url_query_or_fragment, ++ s_n_llhttp__internal__n_url_path, ++ s_n_llhttp__internal__n_span_start_stub_path_2, ++ s_n_llhttp__internal__n_span_start_stub_path, ++ s_n_llhttp__internal__n_span_start_stub_path_1, ++ s_n_llhttp__internal__n_url_server_with_at, ++ s_n_llhttp__internal__n_url_server, ++ s_n_llhttp__internal__n_url_schema_delim_1, ++ s_n_llhttp__internal__n_url_schema_delim, ++ s_n_llhttp__internal__n_span_end_stub_schema, ++ s_n_llhttp__internal__n_url_schema, ++ s_n_llhttp__internal__n_url_start, ++ s_n_llhttp__internal__n_span_start_llhttp__on_url_1, ++ s_n_llhttp__internal__n_url_entry_normal, ++ s_n_llhttp__internal__n_span_start_llhttp__on_url, ++ s_n_llhttp__internal__n_url_entry_connect, ++ s_n_llhttp__internal__n_req_spaces_before_url, ++ s_n_llhttp__internal__n_req_first_space_before_url, ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1, ++ s_n_llhttp__internal__n_after_start_req_2, ++ s_n_llhttp__internal__n_after_start_req_3, ++ s_n_llhttp__internal__n_after_start_req_1, ++ s_n_llhttp__internal__n_after_start_req_4, ++ s_n_llhttp__internal__n_after_start_req_6, ++ s_n_llhttp__internal__n_after_start_req_8, ++ s_n_llhttp__internal__n_after_start_req_9, ++ s_n_llhttp__internal__n_after_start_req_7, ++ s_n_llhttp__internal__n_after_start_req_5, ++ s_n_llhttp__internal__n_after_start_req_12, ++ s_n_llhttp__internal__n_after_start_req_13, ++ s_n_llhttp__internal__n_after_start_req_11, ++ s_n_llhttp__internal__n_after_start_req_10, ++ s_n_llhttp__internal__n_after_start_req_14, ++ s_n_llhttp__internal__n_after_start_req_17, ++ s_n_llhttp__internal__n_after_start_req_16, ++ s_n_llhttp__internal__n_after_start_req_15, ++ s_n_llhttp__internal__n_after_start_req_18, ++ s_n_llhttp__internal__n_after_start_req_20, ++ s_n_llhttp__internal__n_after_start_req_21, ++ s_n_llhttp__internal__n_after_start_req_19, ++ s_n_llhttp__internal__n_after_start_req_23, ++ s_n_llhttp__internal__n_after_start_req_24, ++ s_n_llhttp__internal__n_after_start_req_26, ++ s_n_llhttp__internal__n_after_start_req_28, ++ s_n_llhttp__internal__n_after_start_req_29, ++ s_n_llhttp__internal__n_after_start_req_27, ++ s_n_llhttp__internal__n_after_start_req_25, ++ s_n_llhttp__internal__n_after_start_req_30, ++ s_n_llhttp__internal__n_after_start_req_22, ++ s_n_llhttp__internal__n_after_start_req_31, ++ s_n_llhttp__internal__n_after_start_req_32, ++ s_n_llhttp__internal__n_after_start_req_35, ++ s_n_llhttp__internal__n_after_start_req_36, ++ s_n_llhttp__internal__n_after_start_req_34, ++ s_n_llhttp__internal__n_after_start_req_37, ++ s_n_llhttp__internal__n_after_start_req_38, ++ s_n_llhttp__internal__n_after_start_req_42, ++ s_n_llhttp__internal__n_after_start_req_43, ++ s_n_llhttp__internal__n_after_start_req_41, ++ s_n_llhttp__internal__n_after_start_req_40, ++ s_n_llhttp__internal__n_after_start_req_39, ++ s_n_llhttp__internal__n_after_start_req_45, ++ s_n_llhttp__internal__n_after_start_req_44, ++ s_n_llhttp__internal__n_after_start_req_33, ++ s_n_llhttp__internal__n_after_start_req_46, ++ s_n_llhttp__internal__n_after_start_req_49, ++ s_n_llhttp__internal__n_after_start_req_50, ++ s_n_llhttp__internal__n_after_start_req_51, ++ s_n_llhttp__internal__n_after_start_req_52, ++ s_n_llhttp__internal__n_after_start_req_48, ++ s_n_llhttp__internal__n_after_start_req_47, ++ s_n_llhttp__internal__n_after_start_req_55, ++ s_n_llhttp__internal__n_after_start_req_57, ++ s_n_llhttp__internal__n_after_start_req_58, ++ s_n_llhttp__internal__n_after_start_req_56, ++ s_n_llhttp__internal__n_after_start_req_54, ++ s_n_llhttp__internal__n_after_start_req_59, ++ s_n_llhttp__internal__n_after_start_req_60, ++ s_n_llhttp__internal__n_after_start_req_53, ++ s_n_llhttp__internal__n_after_start_req_62, ++ s_n_llhttp__internal__n_after_start_req_63, ++ s_n_llhttp__internal__n_after_start_req_61, ++ s_n_llhttp__internal__n_after_start_req_66, ++ s_n_llhttp__internal__n_after_start_req_68, ++ s_n_llhttp__internal__n_after_start_req_69, ++ s_n_llhttp__internal__n_after_start_req_67, ++ s_n_llhttp__internal__n_after_start_req_70, ++ s_n_llhttp__internal__n_after_start_req_65, ++ s_n_llhttp__internal__n_after_start_req_64, ++ s_n_llhttp__internal__n_after_start_req, ++ s_n_llhttp__internal__n_span_start_llhttp__on_method_1, ++ s_n_llhttp__internal__n_res_line_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_30, ++ s_n_llhttp__internal__n_res_status, ++ s_n_llhttp__internal__n_span_start_llhttp__on_status, ++ s_n_llhttp__internal__n_res_status_code_otherwise, ++ s_n_llhttp__internal__n_res_status_code_digit_3, ++ s_n_llhttp__internal__n_res_status_code_digit_2, ++ s_n_llhttp__internal__n_res_status_code_digit_1, ++ s_n_llhttp__internal__n_res_after_version, ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1, ++ s_n_llhttp__internal__n_error_89, ++ s_n_llhttp__internal__n_error_103, ++ s_n_llhttp__internal__n_res_http_minor, ++ s_n_llhttp__internal__n_error_104, ++ s_n_llhttp__internal__n_res_http_dot, ++ s_n_llhttp__internal__n_error_105, ++ s_n_llhttp__internal__n_res_http_major, ++ s_n_llhttp__internal__n_span_start_llhttp__on_version_1, ++ s_n_llhttp__internal__n_start_res, ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete, ++ s_n_llhttp__internal__n_req_or_res_method_2, ++ s_n_llhttp__internal__n_invoke_update_type_1, ++ s_n_llhttp__internal__n_req_or_res_method_3, ++ s_n_llhttp__internal__n_req_or_res_method_1, ++ s_n_llhttp__internal__n_req_or_res_method, ++ s_n_llhttp__internal__n_span_start_llhttp__on_method, ++ s_n_llhttp__internal__n_start_req_or_res, ++ s_n_llhttp__internal__n_invoke_load_type, ++ s_n_llhttp__internal__n_invoke_update_finish, ++ s_n_llhttp__internal__n_start, ++}; ++typedef enum llparse_state_e llparse_state_t; ++ ++int llhttp__on_method( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_url( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_version( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_header_field( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_header_value( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_body( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_name( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_value( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_status( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_initial_message_completed( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->initial_message_completed; ++} ++ ++int llhttp__on_reset( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_finish( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 2; ++ return 0; ++} ++ ++int llhttp__on_message_begin( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_type( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->type; ++} ++ ++int llhttp__internal__c_store_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->method = match; ++ return 0; ++} ++ ++int llhttp__on_method_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->method == 5; ++} ++ ++int llhttp__internal__c_update_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->http_major = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->http_minor = 9; ++ return 0; ++} ++ ++int llhttp__on_url_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_test_lenient_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 1) == 1; ++} ++ ++int llhttp__internal__c_test_lenient_flags_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 256) == 256; ++} ++ ++int llhttp__internal__c_test_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 128) == 128; ++} ++ ++int llhttp__on_chunk_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_message_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_upgrade( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->upgrade == 1; ++} ++ ++int llhttp__after_message_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->content_length = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_initial_message_completed( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->initial_message_completed = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_finish_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_2( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 4) == 4; ++} ++ ++int llhttp__internal__c_test_lenient_flags_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 32) == 32; ++} ++ ++int llhttp__before_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__after_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_mul_add_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->content_length > 0xffffffffffffffffULL / 16) { ++ return 1; ++ } ++ ++ state->content_length *= 16; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->content_length > 0xffffffffffffffffULL - match) { ++ return 1; ++ } ++ } else { ++ if (state->content_length < 0ULL - match) { ++ return 1; ++ } ++ } ++ state->content_length += match; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_4( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 512) == 512; ++} ++ ++int llhttp__on_chunk_header( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->content_length == 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 128) == 128; ++} ++ ++int llhttp__internal__c_or_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 128; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 64) == 64; ++} ++ ++int llhttp__on_chunk_extension_name_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_value_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_finish_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 64; ++ return 0; ++} ++ ++int llhttp__internal__c_update_upgrade( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->upgrade = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_store_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->header_state = match; ++ return 0; ++} ++ ++int llhttp__on_header_field_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->header_state; ++} ++ ++int llhttp__internal__c_test_flags_4( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 512) == 512; ++} ++ ++int llhttp__internal__c_test_lenient_flags_22( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 2) == 2; ++} ++ ++int llhttp__internal__c_or_flags_5( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 1; ++ return 0; ++} ++ ++int llhttp__on_header_value_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_or_flags_6( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 2; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 4; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 8; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 6; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_6( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 5; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 7; ++ return 0; ++} ++ ++int llhttp__internal__c_test_flags_2( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 32) == 32; ++} ++ ++int llhttp__internal__c_mul_add_content_length_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->content_length > 0xffffffffffffffffULL / 10) { ++ return 1; ++ } ++ ++ state->content_length *= 10; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->content_length > 0xffffffffffffffffULL - match) { ++ return 1; ++ } ++ } else { ++ if (state->content_length < 0ULL - match) { ++ return 1; ++ } ++ } ++ state->content_length += match; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_17( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 32; ++ return 0; ++} ++ ++int llhttp__internal__c_test_flags_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 8) == 8; ++} ++ ++int llhttp__internal__c_test_lenient_flags_20( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 8) == 8; ++} ++ ++int llhttp__internal__c_or_flags_18( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 512; ++ return 0; ++} ++ ++int llhttp__internal__c_and_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags &= -9; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 8; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_20( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 16; ++ return 0; ++} ++ ++int llhttp__internal__c_load_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->method; ++} ++ ++int llhttp__internal__c_store_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->http_major = match; ++ return 0; ++} ++ ++int llhttp__internal__c_store_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->http_minor = match; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_24( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 16) == 16; ++} ++ ++int llhttp__on_version_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->http_major; ++} ++ ++int llhttp__internal__c_load_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->http_minor; ++} ++ ++int llhttp__internal__c_update_status_code( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->status_code = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_mul_add_status_code( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->status_code > 0xffff / 10) { ++ return 1; ++ } ++ ++ state->status_code *= 10; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->status_code > 0xffff - match) { ++ return 1; ++ } ++ } else { ++ if (state->status_code < 0 - match) { ++ return 1; ++ } ++ } ++ state->status_code += match; ++ return 0; ++} ++ ++int llhttp__on_status_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_type( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->type = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_type_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->type = 2; ++ return 0; ++} ++ ++int llhttp__internal_init(llhttp__internal_t* state) { ++ memset(state, 0, sizeof(*state)); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_start; ++ return 0; ++} ++ ++static llparse_state_t llhttp__internal__run( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ int match; ++ switch ((llparse_state_t) (intptr_t) state->_current) { ++ case s_n_llhttp__internal__n_closed: ++ s_n_llhttp__internal__n_closed: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_closed; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_closed; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_closed; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: { ++ switch (llhttp__after_message_complete(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_update_content_length; ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_pause_1: ++ s_n_llhttp__internal__n_pause_1: { ++ state->error = 0x16; ++ state->reason = "Pause on CONNECT/Upgrade"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_is_equal_upgrade: ++ s_n_llhttp__internal__n_invoke_is_equal_upgrade: { ++ switch (llhttp__internal__c_is_equal_upgrade(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ default: ++ goto s_n_llhttp__internal__n_pause_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_is_equal_upgrade; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_13; ++ default: ++ goto s_n_llhttp__internal__n_error_38; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_data_almost_done_1: ++ s_n_llhttp__internal__n_chunk_data_almost_done_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_data_almost_done_1; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_data_almost_done: ++ s_n_llhttp__internal__n_chunk_data_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_data_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_6; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_data_almost_done_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_consume_content_length: ++ s_n_llhttp__internal__n_consume_content_length: { ++ size_t avail; ++ uint64_t need; ++ ++ avail = endp - p; ++ need = state->content_length; ++ if (avail >= need) { ++ p += need; ++ state->content_length = 0; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_body; ++ } ++ ++ state->content_length -= avail; ++ return s_n_llhttp__internal__n_consume_content_length; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_consume_content_length; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_is_equal_content_length: ++ s_n_llhttp__internal__n_invoke_is_equal_content_length: { ++ switch (llhttp__internal__c_is_equal_content_length(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_almost_done: ++ s_n_llhttp__internal__n_chunk_size_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_8; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_9: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_9: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_20; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_9; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_5; ++ default: ++ goto s_n_llhttp__internal__n_error_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_6; ++ default: ++ goto s_n_llhttp__internal__n_error_21; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_7; ++ default: ++ goto s_n_llhttp__internal__n_error_22; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_10: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_10: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_25; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_10; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_8; ++ default: ++ goto s_n_llhttp__internal__n_error_24; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_9; ++ default: ++ goto s_n_llhttp__internal__n_error_26; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value_done: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_11; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ case ';': { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_29; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_10; ++ default: ++ goto s_n_llhttp__internal__n_error_27; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_30: ++ s_n_llhttp__internal__n_error_30: { ++ state->error = 0x2; ++ state->reason = "Invalid quoted-pair in chunk extensions quoted value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_31: ++ s_n_llhttp__internal__n_error_31: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions quoted value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_11; ++ default: ++ goto s_n_llhttp__internal__n_error_32; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_33: ++ s_n_llhttp__internal__n_error_33: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_value: ++ s_n_llhttp__internal__n_chunk_extension_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 4, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 5, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_value; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_value; ++ } ++ case 4: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ case 5: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_chunk_extension_value; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_34: ++ s_n_llhttp__internal__n_error_34: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions name"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_name: ++ s_n_llhttp__internal__n_chunk_extension_name: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 0, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 0, 5, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_name; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_name; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2; ++ } ++ case 5: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_chunk_extension_name; ++ goto s_n_llhttp__internal__n_chunk_extension_name; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extensions: ++ s_n_llhttp__internal__n_chunk_extensions: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extensions; ++ } ++ switch (*p) { ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_error_17; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_error_18; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_otherwise: ++ s_n_llhttp__internal__n_chunk_size_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_otherwise; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_5; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; ++ } ++ case ';': { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_35; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size: ++ s_n_llhttp__internal__n_chunk_size: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'A': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'B': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'C': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'D': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'E': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'F': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'a': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'b': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'c': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'd': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'e': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'f': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_chunk_size_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_digit: ++ s_n_llhttp__internal__n_chunk_size_digit: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_digit; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'A': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'B': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'C': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'D': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'E': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'F': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'a': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'b': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'c': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'd': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'e': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'f': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_37; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_content_length_1: ++ s_n_llhttp__internal__n_invoke_update_content_length_1: { ++ switch (llhttp__internal__c_update_content_length(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_chunk_size_digit; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_consume_content_length_1: ++ s_n_llhttp__internal__n_consume_content_length_1: { ++ size_t avail; ++ uint64_t need; ++ ++ avail = endp - p; ++ need = state->content_length; ++ if (avail >= need) { ++ p += need; ++ state->content_length = 0; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_body_1; ++ } ++ ++ state->content_length -= avail; ++ return s_n_llhttp__internal__n_consume_content_length_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_consume_content_length_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_eof: ++ s_n_llhttp__internal__n_eof: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_eof; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_eof; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body_2: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body_2; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_eof; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: { ++ switch (llhttp__after_headers_complete(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_content_length_1; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body_1; ++ case 4: ++ goto s_n_llhttp__internal__n_invoke_update_finish_3; ++ case 5: ++ goto s_n_llhttp__internal__n_error_39; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_5: ++ s_n_llhttp__internal__n_error_5: { ++ state->error = 0xa; ++ state->reason = "Invalid header field char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_headers_almost_done: ++ s_n_llhttp__internal__n_headers_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_headers_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_flags_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_12; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_colon_discard_ws: ++ s_n_llhttp__internal__n_header_field_colon_discard_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_colon; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: { ++ switch (llhttp__on_header_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_header_field_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_18; ++ default: ++ goto s_n_llhttp__internal__n_error_48; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_value: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_value; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_lws: ++ s_n_llhttp__internal__n_header_value_discard_lws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_lws; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_header_state_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_ws_almost_done: ++ s_n_llhttp__internal__n_header_value_discard_ws_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_ws_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_16; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_lws: ++ s_n_llhttp__internal__n_header_value_lws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_lws; ++ } ++ switch (*p) { ++ case 9: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; ++ } ++ case ' ': { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_header_state_5; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_almost_done: ++ s_n_llhttp__internal__n_header_value_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_lws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_53; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_17: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_17: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_51; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_lenient: ++ s_n_llhttp__internal__n_header_value_lenient: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_lenient; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_lenient; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_54: ++ s_n_llhttp__internal__n_error_54: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_otherwise: ++ s_n_llhttp__internal__n_header_value_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_19; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_token: ++ s_n_llhttp__internal__n_header_value_connection_token: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_ws: ++ s_n_llhttp__internal__n_header_value_connection_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ case ',': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_header_state_6; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_5; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_1: ++ s_n_llhttp__internal__n_header_value_connection_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob2, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_3; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_2: ++ s_n_llhttp__internal__n_header_value_connection_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob3, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_6; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_3: ++ s_n_llhttp__internal__n_header_value_connection_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob4, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_7; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection: ++ s_n_llhttp__internal__n_header_value_connection: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ case 'c': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ case 'k': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ case 'u': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_56: ++ s_n_llhttp__internal__n_error_56: { ++ state->error = 0xb; ++ state->reason = "Content-Length overflow"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_57: ++ s_n_llhttp__internal__n_error_57: { ++ state->error = 0xb; ++ state->reason = "Invalid character in Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_content_length_ws: ++ s_n_llhttp__internal__n_header_value_content_length_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_or_flags_17; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_invoke_or_flags_17; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_content_length: ++ s_n_llhttp__internal__n_header_value_content_length: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_content_length; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_59: ++ s_n_llhttp__internal__n_error_59: { ++ state->error = 0xf; ++ state->reason = "Invalid `Transfer-Encoding` header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_58: ++ s_n_llhttp__internal__n_error_58: { ++ state->error = 0xf; ++ state->reason = "Invalid `Transfer-Encoding` header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_token_ows: ++ s_n_llhttp__internal__n_header_value_te_token_ows: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value: ++ s_n_llhttp__internal__n_header_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value; ++ } ++ #ifdef __SSE4_2__ ++ if (endp - p >= 16) { ++ __m128i ranges; ++ __m128i input; ++ int avail; ++ int match_len; ++ ++ /* Load input */ ++ input = _mm_loadu_si128((__m128i const*) p); ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob6); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 6, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ #endif /* __SSE4_2__ */ ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_token: ++ s_n_llhttp__internal__n_header_value_te_token: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_token; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_9; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_chunked_last: ++ s_n_llhttp__internal__n_header_value_te_chunked_last: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_8; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_8; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ case ',': { ++ goto s_n_llhttp__internal__n_invoke_load_type_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_chunked: ++ s_n_llhttp__internal__n_header_value_te_chunked: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ match_seq = llparse__match_sequence_to_lower_unsafe(state, p, endp, llparse_blob5, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_value; ++ goto s_n_llhttp__internal__n_invoke_load_header_state_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_ws: ++ s_n_llhttp__internal__n_header_value_discard_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_14; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_header_state: ++ s_n_llhttp__internal__n_invoke_load_header_state: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_test_flags_4; ++ case 3: ++ goto s_n_llhttp__internal__n_invoke_test_flags_5; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: { ++ switch (llhttp__on_header_field_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_header_state; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_19; ++ default: ++ goto s_n_llhttp__internal__n_error_45; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_general_otherwise: ++ s_n_llhttp__internal__n_header_field_general_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ switch (*p) { ++ case ':': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_62; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_general: ++ s_n_llhttp__internal__n_header_field_general: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, ++ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_general; ++ } ++ #ifdef __SSE4_2__ ++ if (endp - p >= 16) { ++ __m128i ranges; ++ __m128i input; ++ int avail; ++ int match_len; ++ ++ /* Load input */ ++ input = _mm_loadu_si128((__m128i const*) p); ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob7); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 16, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob8); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 2, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ goto s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ #endif /* __SSE4_2__ */ ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_colon: ++ s_n_llhttp__internal__n_header_field_colon: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_colon; ++ } ++ switch (*p) { ++ case ' ': { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_13; ++ } ++ case ':': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_10; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_3: ++ s_n_llhttp__internal__n_header_field_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_3; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob1, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_4: ++ s_n_llhttp__internal__n_header_field_4: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_4; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob9, 10); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_4; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_2: ++ s_n_llhttp__internal__n_header_field_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_2; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 'n': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_3; ++ } ++ case 't': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_4; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_1: ++ s_n_llhttp__internal__n_header_field_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_1; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob0, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_2; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_5: ++ s_n_llhttp__internal__n_header_field_5: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_5; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob10, 15); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_5; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_6: ++ s_n_llhttp__internal__n_header_field_6: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_6; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob11, 16); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_6; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_7: ++ s_n_llhttp__internal__n_header_field_7: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_7; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob12, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_7; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field: ++ s_n_llhttp__internal__n_header_field: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 'c': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_1; ++ } ++ case 'p': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_5; ++ } ++ case 't': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_6; ++ } ++ case 'u': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_7; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_field: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_field: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_field; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_field; ++ goto s_n_llhttp__internal__n_header_field; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_start: ++ s_n_llhttp__internal__n_header_field_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_start; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_1; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_headers_almost_done; ++ } ++ case ':': { ++ goto s_n_llhttp__internal__n_error_44; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_field; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_headers_start: ++ s_n_llhttp__internal__n_headers_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_headers_start; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_start; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_to_http_09: ++ s_n_llhttp__internal__n_url_to_http_09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_to_http_09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_http_major; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_to_http09: ++ s_n_llhttp__internal__n_url_skip_to_http09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_to_http09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http_09; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_lf_to_http09_1: ++ s_n_llhttp__internal__n_url_skip_lf_to_http09_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_lf_to_http09_1; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http_09; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_63; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_lf_to_http09: ++ s_n_llhttp__internal__n_url_skip_lf_to_http09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_63; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_pri_upgrade: ++ s_n_llhttp__internal__n_req_pri_upgrade: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_pri_upgrade; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob14, 10); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_error_71; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_pri_upgrade; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_72; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_complete_crlf: ++ s_n_llhttp__internal__n_req_http_complete_crlf: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_complete_crlf; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_headers_start; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_26; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_complete: ++ s_n_llhttp__internal__n_req_http_complete: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_complete; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_25; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_complete_crlf; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_70; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_method_1: ++ s_n_llhttp__internal__n_invoke_load_method_1: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 34: ++ goto s_n_llhttp__internal__n_req_pri_upgrade; ++ default: ++ goto s_n_llhttp__internal__n_req_http_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: { ++ switch (llhttp__on_version_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_method_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_21; ++ default: ++ goto s_n_llhttp__internal__n_error_67; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_66: ++ s_n_llhttp__internal__n_error_66: { ++ state->error = 0x9; ++ state->reason = "Invalid HTTP version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_73: ++ s_n_llhttp__internal__n_error_73: { ++ state->error = 0x9; ++ state->reason = "Invalid minor version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_minor: ++ s_n_llhttp__internal__n_req_http_minor: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_minor; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_2; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_74: ++ s_n_llhttp__internal__n_error_74: { ++ state->error = 0x9; ++ state->reason = "Expected dot"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_dot: ++ s_n_llhttp__internal__n_req_http_dot: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_dot; ++ } ++ switch (*p) { ++ case '.': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_75: ++ s_n_llhttp__internal__n_error_75: { ++ state->error = 0x9; ++ state->reason = "Invalid major version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_major: ++ s_n_llhttp__internal__n_req_http_major: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_major; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_version: ++ s_n_llhttp__internal__n_span_start_llhttp__on_version: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_version; ++ goto s_n_llhttp__internal__n_req_http_major; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_1: ++ s_n_llhttp__internal__n_req_http_start_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_1; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob13, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_2: ++ s_n_llhttp__internal__n_req_http_start_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_2; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob15, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method_2; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_3: ++ s_n_llhttp__internal__n_req_http_start_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob16, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method_3; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start: ++ s_n_llhttp__internal__n_req_http_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start; ++ } ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_1; ++ } ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_2; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_to_http: ++ s_n_llhttp__internal__n_url_to_http: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_to_http; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_to_http: ++ s_n_llhttp__internal__n_url_skip_to_http: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_to_http; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_fragment: ++ s_n_llhttp__internal__n_url_fragment: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_fragment; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_6; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_7; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_8; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_79; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_end_stub_query_3: ++ s_n_llhttp__internal__n_span_end_stub_query_3: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_end_stub_query_3; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_query: ++ s_n_llhttp__internal__n_url_query: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_query; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_9; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_10; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_11; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_end_stub_query_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_80; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_query_or_fragment: ++ s_n_llhttp__internal__n_url_query_or_fragment: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_query_or_fragment; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_3; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_4; ++ } ++ case ' ': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_5; ++ } ++ case '#': { ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ } ++ case '?': { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_81; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_path: ++ s_n_llhttp__internal__n_url_path: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_path; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_url_query_or_fragment; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path_2: ++ s_n_llhttp__internal__n_span_start_stub_path_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path_2; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path: ++ s_n_llhttp__internal__n_span_start_stub_path: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path_1: ++ s_n_llhttp__internal__n_span_start_stub_path_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path_1; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_server_with_at: ++ s_n_llhttp__internal__n_url_server_with_at: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, ++ 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, ++ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_server_with_at; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_12; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_13; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_14; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_start_stub_path_1; ++ } ++ case 7: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 8: { ++ p++; ++ goto s_n_llhttp__internal__n_error_82; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_83; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_server: ++ s_n_llhttp__internal__n_url_server: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, ++ 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, ++ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_server; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_1; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_2; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_start_stub_path; ++ } ++ case 7: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 8: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server_with_at; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_84; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema_delim_1: ++ s_n_llhttp__internal__n_url_schema_delim_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema_delim_1; ++ } ++ switch (*p) { ++ case '/': { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_85; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema_delim: ++ s_n_llhttp__internal__n_url_schema_delim: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema_delim; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case '/': { ++ p++; ++ goto s_n_llhttp__internal__n_url_schema_delim_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_85; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_end_stub_schema: ++ s_n_llhttp__internal__n_span_end_stub_schema: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_end_stub_schema; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_schema_delim; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema: ++ s_n_llhttp__internal__n_url_schema: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_stub_schema; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_url_schema; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_86; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_start: ++ s_n_llhttp__internal__n_url_start: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_start; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_start_stub_path_2; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_url_schema; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_87; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_url_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_url_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_url_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_url; ++ goto s_n_llhttp__internal__n_url_start; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_entry_normal: ++ s_n_llhttp__internal__n_url_entry_normal: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_entry_normal; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_url_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_url: ++ s_n_llhttp__internal__n_span_start_llhttp__on_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_url; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_url; ++ goto s_n_llhttp__internal__n_url_server; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_entry_connect: ++ s_n_llhttp__internal__n_url_entry_connect: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_entry_connect; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_url; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_spaces_before_url: ++ s_n_llhttp__internal__n_req_spaces_before_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_is_equal_method; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_first_space_before_url: ++ s_n_llhttp__internal__n_req_first_space_before_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_first_space_before_url; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_88; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: { ++ switch (llhttp__on_method_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_first_space_before_url; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_26; ++ default: ++ goto s_n_llhttp__internal__n_error_107; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_2: ++ s_n_llhttp__internal__n_after_start_req_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_2; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ match = 19; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_3: ++ s_n_llhttp__internal__n_after_start_req_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob17, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 36; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_1: ++ s_n_llhttp__internal__n_after_start_req_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_1; ++ } ++ switch (*p) { ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_2; ++ } ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_4: ++ s_n_llhttp__internal__n_after_start_req_4: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_4; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob18, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 16; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_4; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_6: ++ s_n_llhttp__internal__n_after_start_req_6: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_6; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob19, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 22; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_6; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_8: ++ s_n_llhttp__internal__n_after_start_req_8: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_8; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob20, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_8; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_9: ++ s_n_llhttp__internal__n_after_start_req_9: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_9; ++ } ++ switch (*p) { ++ case 'Y': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_7: ++ s_n_llhttp__internal__n_after_start_req_7: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_7; ++ } ++ switch (*p) { ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_8; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_9; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_5: ++ s_n_llhttp__internal__n_after_start_req_5: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_5; ++ } ++ switch (*p) { ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_6; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_7; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_12: ++ s_n_llhttp__internal__n_after_start_req_12: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_12; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob21, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_12; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_13: ++ s_n_llhttp__internal__n_after_start_req_13: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_13; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob22, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 35; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_13; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_11: ++ s_n_llhttp__internal__n_after_start_req_11: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_11; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_12; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_13; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_10: ++ s_n_llhttp__internal__n_after_start_req_10: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_10; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_11; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_14: ++ s_n_llhttp__internal__n_after_start_req_14: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_14; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob23, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 45; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_14; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_17: ++ s_n_llhttp__internal__n_after_start_req_17: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_17; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob25, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 41; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_17; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_16: ++ s_n_llhttp__internal__n_after_start_req_16: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_16; ++ } ++ switch (*p) { ++ case '_': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_17; ++ } ++ default: { ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_15: ++ s_n_llhttp__internal__n_after_start_req_15: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_15; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob24, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_16; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_15; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_18: ++ s_n_llhttp__internal__n_after_start_req_18: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_18; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob26, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_18; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_20: ++ s_n_llhttp__internal__n_after_start_req_20: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_20; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob27, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 31; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_20; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_21: ++ s_n_llhttp__internal__n_after_start_req_21: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_21; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob28, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_21; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_19: ++ s_n_llhttp__internal__n_after_start_req_19: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_19; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_20; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_21; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_23: ++ s_n_llhttp__internal__n_after_start_req_23: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_23; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob29, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 24; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_23; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_24: ++ s_n_llhttp__internal__n_after_start_req_24: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_24; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob30, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 23; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_24; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_26: ++ s_n_llhttp__internal__n_after_start_req_26: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_26; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob31, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 21; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_26; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_28: ++ s_n_llhttp__internal__n_after_start_req_28: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_28; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob32, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 30; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_28; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_29: ++ s_n_llhttp__internal__n_after_start_req_29: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_29; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_27: ++ s_n_llhttp__internal__n_after_start_req_27: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_27; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_28; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_29; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_25: ++ s_n_llhttp__internal__n_after_start_req_25: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_25; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_26; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_27; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_30: ++ s_n_llhttp__internal__n_after_start_req_30: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_30; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob33, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_30; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_22: ++ s_n_llhttp__internal__n_after_start_req_22: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_22; ++ } ++ switch (*p) { ++ case '-': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_23; ++ } ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_24; ++ } ++ case 'K': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_25; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_30; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_31: ++ s_n_llhttp__internal__n_after_start_req_31: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_31; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob34, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 25; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_31; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_32: ++ s_n_llhttp__internal__n_after_start_req_32: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_32; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob35, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_32; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_35: ++ s_n_llhttp__internal__n_after_start_req_35: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_35; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob36, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 28; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_35; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_36: ++ s_n_llhttp__internal__n_after_start_req_36: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_36; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob37, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 39; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_36; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_34: ++ s_n_llhttp__internal__n_after_start_req_34: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_34; ++ } ++ switch (*p) { ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_35; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_36; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_37: ++ s_n_llhttp__internal__n_after_start_req_37: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_37; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob38, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 38; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_37; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_38: ++ s_n_llhttp__internal__n_after_start_req_38: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_38; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob39, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_38; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_42: ++ s_n_llhttp__internal__n_after_start_req_42: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_42; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob40, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_42; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_43: ++ s_n_llhttp__internal__n_after_start_req_43: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_43; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob41, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_43; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_41: ++ s_n_llhttp__internal__n_after_start_req_41: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_41; ++ } ++ switch (*p) { ++ case 'F': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_42; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_43; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_40: ++ s_n_llhttp__internal__n_after_start_req_40: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_40; ++ } ++ switch (*p) { ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_41; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_39: ++ s_n_llhttp__internal__n_after_start_req_39: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_39; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ match = 34; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_40; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_45: ++ s_n_llhttp__internal__n_after_start_req_45: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_45; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob42, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 29; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_45; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_44: ++ s_n_llhttp__internal__n_after_start_req_44: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_44; ++ } ++ switch (*p) { ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_45; ++ } ++ case 'T': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_33: ++ s_n_llhttp__internal__n_after_start_req_33: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_33; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_34; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_37; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_38; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_39; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_44; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_46: ++ s_n_llhttp__internal__n_after_start_req_46: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_46; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob43, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 46; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_46; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_49: ++ s_n_llhttp__internal__n_after_start_req_49: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_49; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob44, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 17; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_49; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_50: ++ s_n_llhttp__internal__n_after_start_req_50: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_50; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob45, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 44; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_50; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_51: ++ s_n_llhttp__internal__n_after_start_req_51: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_51; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob46, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 43; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_51; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_52: ++ s_n_llhttp__internal__n_after_start_req_52: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_52; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob47, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 20; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_52; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_48: ++ s_n_llhttp__internal__n_after_start_req_48: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_48; ++ } ++ switch (*p) { ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_49; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_50; ++ } ++ case 'D': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_51; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_52; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_47: ++ s_n_llhttp__internal__n_after_start_req_47: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_47; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_48; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_55: ++ s_n_llhttp__internal__n_after_start_req_55: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_55; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob48, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_55; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_57: ++ s_n_llhttp__internal__n_after_start_req_57: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_57; ++ } ++ switch (*p) { ++ case 'P': { ++ p++; ++ match = 37; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_58: ++ s_n_llhttp__internal__n_after_start_req_58: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_58; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob49, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 42; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_58; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_56: ++ s_n_llhttp__internal__n_after_start_req_56: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_56; ++ } ++ switch (*p) { ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_57; ++ } ++ case '_': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_58; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_54: ++ s_n_llhttp__internal__n_after_start_req_54: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_54; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_55; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_56; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_59: ++ s_n_llhttp__internal__n_after_start_req_59: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_59; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob50, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 33; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_59; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_60: ++ s_n_llhttp__internal__n_after_start_req_60: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_60; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob51, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 26; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_60; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_53: ++ s_n_llhttp__internal__n_after_start_req_53: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_53; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_54; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_59; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_60; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_62: ++ s_n_llhttp__internal__n_after_start_req_62: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_62; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob52, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 40; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_62; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_63: ++ s_n_llhttp__internal__n_after_start_req_63: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_63; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob53, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_63; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_61: ++ s_n_llhttp__internal__n_after_start_req_61: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_61; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_62; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_63; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_66: ++ s_n_llhttp__internal__n_after_start_req_66: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_66; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob54, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 18; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_66; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_68: ++ s_n_llhttp__internal__n_after_start_req_68: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_68; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob55, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 32; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_68; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_69: ++ s_n_llhttp__internal__n_after_start_req_69: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_69; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob56, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_69; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_67: ++ s_n_llhttp__internal__n_after_start_req_67: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_67; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_68; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_69; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_70: ++ s_n_llhttp__internal__n_after_start_req_70: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_70; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob57, 8); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 27; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_70; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_65: ++ s_n_llhttp__internal__n_after_start_req_65: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_65; ++ } ++ switch (*p) { ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_66; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_67; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_70; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_64: ++ s_n_llhttp__internal__n_after_start_req_64: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_64; ++ } ++ switch (*p) { ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_65; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req: ++ s_n_llhttp__internal__n_after_start_req: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_1; ++ } ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_4; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_5; ++ } ++ case 'D': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_10; ++ } ++ case 'F': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_14; ++ } ++ case 'G': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_15; ++ } ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_18; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_19; ++ } ++ case 'M': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_22; ++ } ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_31; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_32; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_33; ++ } ++ case 'Q': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_46; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_47; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_53; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_61; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_64; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_method_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_method_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_method; ++ goto s_n_llhttp__internal__n_after_start_req; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_line_almost_done: ++ s_n_llhttp__internal__n_res_line_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_line_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_29; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_30: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_30: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_94; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status: ++ s_n_llhttp__internal__n_res_status: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_status; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_status_1; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_res_status; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_status: ++ s_n_llhttp__internal__n_span_start_llhttp__on_status: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_status; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_status; ++ goto s_n_llhttp__internal__n_res_status; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_otherwise: ++ s_n_llhttp__internal__n_res_status_code_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_otherwise; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_28; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_res_line_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_status; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_95; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_3: ++ s_n_llhttp__internal__n_res_status_code_digit_3: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_3; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_97; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_2: ++ s_n_llhttp__internal__n_res_status_code_digit_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_2; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_99; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_1: ++ s_n_llhttp__internal__n_res_status_code_digit_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_1; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_101; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_after_version: ++ s_n_llhttp__internal__n_res_after_version: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_after_version; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_status_code; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_102; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: { ++ switch (llhttp__on_version_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_res_after_version; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_25; ++ default: ++ goto s_n_llhttp__internal__n_error_90; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_89: ++ s_n_llhttp__internal__n_error_89: { ++ state->error = 0x9; ++ state->reason = "Invalid HTTP version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_103: ++ s_n_llhttp__internal__n_error_103: { ++ state->error = 0x9; ++ state->reason = "Invalid minor version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_minor: ++ s_n_llhttp__internal__n_res_http_minor: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_minor; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_104: ++ s_n_llhttp__internal__n_error_104: { ++ state->error = 0x9; ++ state->reason = "Expected dot"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_dot: ++ s_n_llhttp__internal__n_res_http_dot: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_dot; ++ } ++ switch (*p) { ++ case '.': { ++ p++; ++ goto s_n_llhttp__internal__n_res_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_8; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_105: ++ s_n_llhttp__internal__n_error_105: { ++ state->error = 0x9; ++ state->reason = "Invalid major version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_major: ++ s_n_llhttp__internal__n_res_http_major: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_major; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_9; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_version_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_version_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_version; ++ goto s_n_llhttp__internal__n_res_http_major; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start_res: ++ s_n_llhttp__internal__n_start_res: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start_res; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob58, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_start_res; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_109; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: { ++ switch (llhttp__on_method_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_first_space_before_url; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_23; ++ default: ++ goto s_n_llhttp__internal__n_error_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_2: ++ s_n_llhttp__internal__n_req_or_res_method_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob59, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_method; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_type_1: ++ s_n_llhttp__internal__n_invoke_update_type_1: { ++ switch (llhttp__internal__c_update_type_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_3: ++ s_n_llhttp__internal__n_req_or_res_method_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob60, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_1: ++ s_n_llhttp__internal__n_req_or_res_method_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_1; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method: ++ s_n_llhttp__internal__n_req_or_res_method: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method; ++ } ++ switch (*p) { ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_method: ++ s_n_llhttp__internal__n_span_start_llhttp__on_method: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_method; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_method; ++ goto s_n_llhttp__internal__n_req_or_res_method; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start_req_or_res: ++ s_n_llhttp__internal__n_start_req_or_res: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start_req_or_res; ++ } ++ switch (*p) { ++ case 'H': { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_type_2; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_type: ++ s_n_llhttp__internal__n_invoke_load_type: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ case 2: ++ goto s_n_llhttp__internal__n_start_res; ++ default: ++ goto s_n_llhttp__internal__n_start_req_or_res; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_finish: ++ s_n_llhttp__internal__n_invoke_update_finish: { ++ switch (llhttp__internal__c_update_finish(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_begin; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start: ++ s_n_llhttp__internal__n_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_start; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_start; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_initial_message_completed; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ default: ++ /* UNREACHABLE */ ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_2: { ++ state->error = 0x7; ++ state->reason = "Invalid characters in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_2: { ++ switch (llhttp__internal__c_update_finish_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_start; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_initial_message_completed: { ++ switch (llhttp__internal__c_update_initial_message_completed(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_content_length: { ++ switch (llhttp__internal__c_update_content_length(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_8: { ++ state->error = 0x5; ++ state->reason = "Data after `Connection: close`"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_3: { ++ switch (llhttp__internal__c_test_lenient_flags_3(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_closed; ++ default: ++ goto s_n_llhttp__internal__n_error_8; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_2: { ++ switch (llhttp__internal__c_test_lenient_flags_2(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; ++ default: ++ goto s_n_llhttp__internal__n_closed; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_1: { ++ switch (llhttp__internal__c_update_finish_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_13: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_upgrade; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_38: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_15: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_40: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_15; ++ default: ++ goto s_n_llhttp__internal__n_error_40; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_2: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_pause_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_9: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_pause_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_2; ++ default: ++ goto s_n_llhttp__internal__n_error_9; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_36: { ++ state->error = 0xc; ++ state->reason = "Chunk size overflow"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_10: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_4: { ++ switch (llhttp__internal__c_test_lenient_flags_4(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_otherwise; ++ default: ++ goto s_n_llhttp__internal__n_error_10; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_3: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_content_length_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_14: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_update_content_length_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_3; ++ default: ++ goto s_n_llhttp__internal__n_error_14; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_13: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk data"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_6: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_13; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_15: { ++ state->error = 0x2; ++ state->reason = "Expected LF after chunk data"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_7: { ++ switch (llhttp__internal__c_test_lenient_flags_7(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_15; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_body: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_body(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_data_almost_done; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_chunk_data_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags: { ++ switch (llhttp__internal__c_or_flags(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_start; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_4: { ++ state->error = 0x15; ++ state->reason = "on_chunk_header pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_content_length; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_12: { ++ state->error = 0x13; ++ state->reason = "`on_chunk_header` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header: { ++ switch (llhttp__on_chunk_header(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_is_equal_content_length; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_4; ++ default: ++ goto s_n_llhttp__internal__n_error_12; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_16: { ++ state->error = 0x2; ++ state->reason = "Expected LF after chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_8: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; ++ default: ++ goto s_n_llhttp__internal__n_error_16; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_11: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_5: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_11; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_17: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_18: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_20: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension name"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_5: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_9; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_19: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_6: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_21: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_7: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_22: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_25: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_8: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_10; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_24: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_9: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_26: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_28: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_11: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_28; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_29: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions quote value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_10: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_27: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_30; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_30; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_31; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_31; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_11: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_32: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_33; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_33; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_12: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_value; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_23: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extension_value; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_12; ++ default: ++ goto s_n_llhttp__internal__n_error_23; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_34; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_34; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_35: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_content_length: { ++ switch (llhttp__internal__c_mul_add_content_length(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_36; ++ default: ++ goto s_n_llhttp__internal__n_chunk_size; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_37: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_body_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_body(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_3: { ++ switch (llhttp__internal__c_update_finish_3(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_39: { ++ state->error = 0xf; ++ state->reason = "Request has invalid `Transfer-Encoding`"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_7: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ case 21: ++ goto s_n_llhttp__internal__n_pause; ++ default: ++ goto s_n_llhttp__internal__n_error_7; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_1: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_2: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_upgrade: { ++ switch (llhttp__internal__c_update_upgrade(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_14: { ++ state->error = 0x15; ++ state->reason = "Paused by on_headers_complete"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_6: { ++ state->error = 0x11; ++ state->reason = "User callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete: { ++ switch (llhttp__on_headers_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_or_flags_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_upgrade; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_14; ++ default: ++ goto s_n_llhttp__internal__n_error_6; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete: { ++ switch (llhttp__before_headers_complete(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags: { ++ switch (llhttp__internal__c_test_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_1: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_flags; ++ default: ++ goto s_n_llhttp__internal__n_error_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_17: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_42: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_17; ++ default: ++ goto s_n_llhttp__internal__n_error_42; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_3: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_4: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_upgrade_1: { ++ switch (llhttp__internal__c_update_upgrade(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_16: { ++ state->error = 0x15; ++ state->reason = "Paused by on_headers_complete"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_41: { ++ state->error = 0x11; ++ state->reason = "User callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1: { ++ switch (llhttp__on_headers_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_or_flags_3; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_upgrade_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_16; ++ default: ++ goto s_n_llhttp__internal__n_error_41; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1: { ++ switch (llhttp__before_headers_complete(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_1: { ++ switch (llhttp__internal__c_test_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_43: { ++ state->error = 0x2; ++ state->reason = "Expected LF after headers"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_12: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_flags_1; ++ default: ++ goto s_n_llhttp__internal__n_error_43; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_44: { ++ state->error = 0xa; ++ state->reason = "Invalid header token"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_5; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_5; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_13: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_60: { ++ state->error = 0xb; ++ state->reason = "Content-Length can't be present with Transfer-Encoding"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_47: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_15: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ default: ++ goto s_n_llhttp__internal__n_error_47; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_49: { ++ state->error = 0xb; ++ state->reason = "Empty Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_18: { ++ state->error = 0x15; ++ state->reason = "on_header_value_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_field_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_48: { ++ state->error = 0x1d; ++ state->reason = "`on_header_value_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_5: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_6: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_7: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_8: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_2: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_5; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_6; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_7; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_8; ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_1: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 2: ++ goto s_n_llhttp__internal__n_error_49; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_46: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_14: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ default: ++ goto s_n_llhttp__internal__n_error_46; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_50: { ++ state->error = 0x2; ++ state->reason = "Expected LF after CR"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_16: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ default: ++ goto s_n_llhttp__internal__n_error_50; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_1: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_4: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_1; ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_52: { ++ state->error = 0xa; ++ state->reason = "Unexpected whitespace after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_18: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_header_state_4; ++ default: ++ goto s_n_llhttp__internal__n_error_52; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_2: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_9: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_10: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_11: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_12: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_5: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_9; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_10; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_11; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_12; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_53: { ++ state->error = 0x3; ++ state->reason = "Missing expected LF after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_51: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_17; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_17; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_54; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_54; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_19: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_lenient; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_4: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_13: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_14: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_15: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_16: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_6: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_13; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_14; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_15; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_16; ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_5: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_3: { ++ switch (llhttp__internal__c_update_header_state_3(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_6: { ++ switch (llhttp__internal__c_update_header_state_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_7: { ++ switch (llhttp__internal__c_update_header_state_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_56; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_56; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_content_length_1: { ++ switch (llhttp__internal__c_mul_add_content_length_1(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6; ++ default: ++ goto s_n_llhttp__internal__n_header_value_content_length; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_17: { ++ switch (llhttp__internal__c_or_flags_17(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_57; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_57; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_55: { ++ state->error = 0x4; ++ state->reason = "Duplicate Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_2: { ++ switch (llhttp__internal__c_test_flags_2(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_header_value_content_length; ++ default: ++ goto s_n_llhttp__internal__n_error_55; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_59; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_59; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_8: { ++ switch (llhttp__internal__c_update_header_state_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_58; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_58; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_20: { ++ switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8; ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_type_1: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_20; ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_9: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_and_flags: { ++ switch (llhttp__internal__c_and_flags(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_19: { ++ switch (llhttp__internal__c_or_flags_18(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_and_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_21: { ++ switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_type_2: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_21; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_18: { ++ switch (llhttp__internal__c_or_flags_18(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_and_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_3: { ++ switch (llhttp__internal__c_test_flags_3(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_type_2; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_18; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_20: { ++ switch (llhttp__internal__c_or_flags_20(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_9; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_3: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_test_flags_2; ++ case 3: ++ goto s_n_llhttp__internal__n_invoke_test_flags_3; ++ case 4: ++ goto s_n_llhttp__internal__n_invoke_or_flags_20; ++ default: ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_22: { ++ switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_error_60; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_4: { ++ switch (llhttp__internal__c_test_flags_4(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_22; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_61: { ++ state->error = 0xf; ++ state->reason = "Transfer-Encoding can't be present with Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_23: { ++ switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_error_61; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_5: { ++ switch (llhttp__internal__c_test_flags_2(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_23; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_19: { ++ state->error = 0x15; ++ state->reason = "on_header_field_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_header_state; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_45: { ++ state->error = 0x1c; ++ state->reason = "`on_header_field_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_62: { ++ state->error = 0xa; ++ state->reason = "Invalid header token"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_10: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_header_state: { ++ switch (llhttp__internal__c_store_header_state(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_colon; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_11: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_4: { ++ state->error = 0x1e; ++ state->reason = "Unexpected space after start line"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_field_start; ++ default: ++ goto s_n_llhttp__internal__n_error_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_20: { ++ state->error = 0x15; ++ state->reason = "on_url_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_3: { ++ state->error = 0x1a; ++ state->reason = "`on_url_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_url_complete: { ++ switch (llhttp__on_url_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_headers_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_20; ++ default: ++ goto s_n_llhttp__internal__n_error_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_http_minor: { ++ switch (llhttp__internal__c_update_http_minor(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_http_major: { ++ switch (llhttp__internal__c_update_http_major(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_http_minor; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_63: { ++ state->error = 0x7; ++ state->reason = "Expected CRLF"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_71: { ++ state->error = 0x17; ++ state->reason = "Pause on PRI/Upgrade"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_72: { ++ state->error = 0x9; ++ state->reason = "Expected HTTP/2 Connection Preface"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_69: { ++ state->error = 0x2; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_26: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_headers_start; ++ default: ++ goto s_n_llhttp__internal__n_error_69; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_68: { ++ state->error = 0x9; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_25: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_req_http_complete_crlf; ++ default: ++ goto s_n_llhttp__internal__n_error_68; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_70: { ++ state->error = 0x9; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_21: { ++ state->error = 0x15; ++ state->reason = "on_version_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_method_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_67: { ++ state->error = 0x21; ++ state->reason = "`on_version_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_66; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_66; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 9: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_1: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_2: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_major: { ++ switch (llhttp__internal__c_load_http_major(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_2; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_24: { ++ switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_http_major; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_minor: { ++ switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_24; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_73; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_73; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_74; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_74; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_major: { ++ switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_req_http_dot; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_75; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_75; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_65: { ++ state->error = 0x8; ++ state->reason = "Invalid method for HTTP/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 2: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 4: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 5: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 6: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 7: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 8: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 9: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 10: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 11: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 12: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 13: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 14: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 15: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 16: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 17: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 18: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 19: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 20: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 21: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 22: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 23: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 24: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 25: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 26: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 27: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 28: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 29: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 30: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 31: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 32: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 33: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 34: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 46: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_65; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_78: { ++ state->error = 0x8; ++ state->reason = "Expected HTTP/"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_76: { ++ state->error = 0x8; ++ state->reason = "Expected SOURCE method for ICE/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method_2: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 33: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_76; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_77: { ++ state->error = 0x8; ++ state->reason = "Invalid method for RTSP/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method_3: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 6: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 35: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 36: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 37: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 38: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 39: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 40: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 41: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 42: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 43: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 44: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 45: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_77; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_22: { ++ state->error = 0x15; ++ state->reason = "on_url_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_http_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_64: { ++ state->error = 0x1a; ++ state->reason = "`on_url_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1: { ++ switch (llhttp__on_url_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_http_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_22; ++ default: ++ goto s_n_llhttp__internal__n_error_64; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_79: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url fragment start"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_10: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_11: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_80: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url query"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_81: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url path"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_12: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_13: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_14: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_82: { ++ state->error = 0x7; ++ state->reason = "Double @ in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_83: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url server"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_84: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url server"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_85: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url schema"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_86: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url schema"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_87: { ++ state->error = 0x7; ++ state->reason = "Unexpected start char in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_is_equal_method: { ++ switch (llhttp__internal__c_is_equal_method(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_url_entry_normal; ++ default: ++ goto s_n_llhttp__internal__n_url_entry_connect; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_88: { ++ state->error = 0x6; ++ state->reason = "Expected space after method"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_26: { ++ state->error = 0x15; ++ state->reason = "on_method_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_107: { ++ state->error = 0x20; ++ state->reason = "`on_method_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_method_1: { ++ switch (llhttp__internal__c_store_method(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_108: { ++ state->error = 0x6; ++ state->reason = "Invalid method encountered"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_100: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_98: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_96: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_24: { ++ state->error = 0x15; ++ state->reason = "on_status_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_92: { ++ state->error = 0x1b; ++ state->reason = "`on_status_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_status_complete: { ++ switch (llhttp__on_status_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_headers_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_24; ++ default: ++ goto s_n_llhttp__internal__n_error_92; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_91: { ++ state->error = 0xd; ++ state->reason = "Invalid response status"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_28: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_91; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_93: { ++ state->error = 0x2; ++ state->reason = "Expected LF after CR"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_29: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_93; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_94: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after response line"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_status: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_status(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_30; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_30; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_status_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_status(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_line_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_res_line_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_95: { ++ state->error = 0xd; ++ state->reason = "Invalid response status"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code_2: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_96; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_97: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code_1: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_98; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_99: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_100; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_101: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_status_code: { ++ switch (llhttp__internal__c_update_status_code(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_102: { ++ state->error = 0x9; ++ state->reason = "Expected space after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_25: { ++ state->error = 0x15; ++ state->reason = "on_version_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_after_version; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_90: { ++ state->error = 0x21; ++ state->reason = "`on_version_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_89; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_89; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_3: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 9: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_4: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_5: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_major_1: { ++ switch (llhttp__internal__c_load_http_major(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_3; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_4; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_5; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_27: { ++ switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_http_major_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_minor_1: { ++ switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_27; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_103; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_103; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_104; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_104; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_major_1: { ++ switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_res_http_dot; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_105; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_105; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_109: { ++ state->error = 0x8; ++ state->reason = "Expected HTTP/"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_23: { ++ state->error = 0x15; ++ state->reason = "on_method_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_1: { ++ state->error = 0x20; ++ state->reason = "`on_method_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_type: { ++ switch (llhttp__internal__c_update_type(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_method: { ++ switch (llhttp__internal__c_store_method(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_type; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_106: { ++ state->error = 0x8; ++ state->reason = "Invalid word encountered"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_type_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_update_type_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_type_2: { ++ switch (llhttp__internal__c_update_type(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_27: { ++ state->error = 0x15; ++ state->reason = "on_message_begin pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_type; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error: { ++ state->error = 0x10; ++ state->reason = "`on_message_begin` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_begin: { ++ switch (llhttp__on_message_begin(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_type; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_27; ++ default: ++ goto s_n_llhttp__internal__n_error; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_28: { ++ state->error = 0x15; ++ state->reason = "on_reset pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_finish; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_110: { ++ state->error = 0x1f; ++ state->reason = "`on_reset` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_reset: { ++ switch (llhttp__on_reset(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_update_finish; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_28; ++ default: ++ goto s_n_llhttp__internal__n_error_110; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_initial_message_completed: { ++ switch (llhttp__internal__c_load_initial_message_completed(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_reset; ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++} ++ ++int llhttp__internal_execute(llhttp__internal_t* state, const char* p, const char* endp) { ++ llparse_state_t next; ++ ++ /* check lingering errors */ ++ if (state->error != 0) { ++ return state->error; ++ } ++ ++ /* restart spans */ ++ if (state->_span_pos0 != NULL) { ++ state->_span_pos0 = (void*) p; ++ } ++ ++ next = llhttp__internal__run(state, (const unsigned char*) p, (const unsigned char*) endp); ++ if (next == s_error) { ++ return state->error; ++ } ++ state->_current = (void*) (intptr_t) next; ++ ++ /* execute spans */ ++ if (state->_span_pos0 != NULL) { ++ int error; ++ ++ error = ((llhttp__internal__span_cb) state->_span_cb0)(state, state->_span_pos0, (const char*) endp); ++ if (error != 0) { ++ state->error = error; ++ state->error_pos = endp; ++ return error; ++ } ++ } ++ ++ return 0; ++} +\ No newline at end of file +diff --git a/deps/llhttp/llhttp.h b/deps/llhttp/llhttp.h +new file mode 100644 +index 0000000000000000000000000000000000000000..26f01c32cc7f98e2901b2af71972e9d6efe7db5c +--- /dev/null ++++ b/deps/llhttp/llhttp.h +@@ -0,0 +1,897 @@ ++ ++#ifndef INCLUDE_LLHTTP_H_ ++#define INCLUDE_LLHTTP_H_ ++ ++#define LLHTTP_VERSION_MAJOR 9 ++#define LLHTTP_VERSION_MINOR 2 ++#define LLHTTP_VERSION_PATCH 1 ++ ++#ifndef INCLUDE_LLHTTP_ITSELF_H_ ++#define INCLUDE_LLHTTP_ITSELF_H_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++ ++typedef struct llhttp__internal_s llhttp__internal_t; ++struct llhttp__internal_s { ++ int32_t _index; ++ void* _span_pos0; ++ void* _span_cb0; ++ int32_t error; ++ const char* reason; ++ const char* error_pos; ++ void* data; ++ void* _current; ++ uint64_t content_length; ++ uint8_t type; ++ uint8_t method; ++ uint8_t http_major; ++ uint8_t http_minor; ++ uint8_t header_state; ++ uint16_t lenient_flags; ++ uint8_t upgrade; ++ uint8_t finish; ++ uint16_t flags; ++ uint16_t status_code; ++ uint8_t initial_message_completed; ++ void* settings; ++}; ++ ++int llhttp__internal_init(llhttp__internal_t* s); ++int llhttp__internal_execute(llhttp__internal_t* s, const char* p, const char* endp); ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* INCLUDE_LLHTTP_ITSELF_H_ */ ++ ++ ++#ifndef LLLLHTTP_C_HEADERS_ ++#define LLLLHTTP_C_HEADERS_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum llhttp_errno { ++ HPE_OK = 0, ++ HPE_INTERNAL = 1, ++ HPE_STRICT = 2, ++ HPE_CR_EXPECTED = 25, ++ HPE_LF_EXPECTED = 3, ++ HPE_UNEXPECTED_CONTENT_LENGTH = 4, ++ HPE_UNEXPECTED_SPACE = 30, ++ HPE_CLOSED_CONNECTION = 5, ++ HPE_INVALID_METHOD = 6, ++ HPE_INVALID_URL = 7, ++ HPE_INVALID_CONSTANT = 8, ++ HPE_INVALID_VERSION = 9, ++ HPE_INVALID_HEADER_TOKEN = 10, ++ HPE_INVALID_CONTENT_LENGTH = 11, ++ HPE_INVALID_CHUNK_SIZE = 12, ++ HPE_INVALID_STATUS = 13, ++ HPE_INVALID_EOF_STATE = 14, ++ HPE_INVALID_TRANSFER_ENCODING = 15, ++ HPE_CB_MESSAGE_BEGIN = 16, ++ HPE_CB_HEADERS_COMPLETE = 17, ++ HPE_CB_MESSAGE_COMPLETE = 18, ++ HPE_CB_CHUNK_HEADER = 19, ++ HPE_CB_CHUNK_COMPLETE = 20, ++ HPE_PAUSED = 21, ++ HPE_PAUSED_UPGRADE = 22, ++ HPE_PAUSED_H2_UPGRADE = 23, ++ HPE_USER = 24, ++ HPE_CB_URL_COMPLETE = 26, ++ HPE_CB_STATUS_COMPLETE = 27, ++ HPE_CB_METHOD_COMPLETE = 32, ++ HPE_CB_VERSION_COMPLETE = 33, ++ HPE_CB_HEADER_FIELD_COMPLETE = 28, ++ HPE_CB_HEADER_VALUE_COMPLETE = 29, ++ HPE_CB_CHUNK_EXTENSION_NAME_COMPLETE = 34, ++ HPE_CB_CHUNK_EXTENSION_VALUE_COMPLETE = 35, ++ HPE_CB_RESET = 31 ++}; ++typedef enum llhttp_errno llhttp_errno_t; ++ ++enum llhttp_flags { ++ F_CONNECTION_KEEP_ALIVE = 0x1, ++ F_CONNECTION_CLOSE = 0x2, ++ F_CONNECTION_UPGRADE = 0x4, ++ F_CHUNKED = 0x8, ++ F_UPGRADE = 0x10, ++ F_CONTENT_LENGTH = 0x20, ++ F_SKIPBODY = 0x40, ++ F_TRAILING = 0x80, ++ F_TRANSFER_ENCODING = 0x200 ++}; ++typedef enum llhttp_flags llhttp_flags_t; ++ ++enum llhttp_lenient_flags { ++ LENIENT_HEADERS = 0x1, ++ LENIENT_CHUNKED_LENGTH = 0x2, ++ LENIENT_KEEP_ALIVE = 0x4, ++ LENIENT_TRANSFER_ENCODING = 0x8, ++ LENIENT_VERSION = 0x10, ++ LENIENT_DATA_AFTER_CLOSE = 0x20, ++ LENIENT_OPTIONAL_LF_AFTER_CR = 0x40, ++ LENIENT_OPTIONAL_CRLF_AFTER_CHUNK = 0x80, ++ LENIENT_OPTIONAL_CR_BEFORE_LF = 0x100, ++ LENIENT_SPACES_AFTER_CHUNK_SIZE = 0x200 ++}; ++typedef enum llhttp_lenient_flags llhttp_lenient_flags_t; ++ ++enum llhttp_type { ++ HTTP_BOTH = 0, ++ HTTP_REQUEST = 1, ++ HTTP_RESPONSE = 2 ++}; ++typedef enum llhttp_type llhttp_type_t; ++ ++enum llhttp_finish { ++ HTTP_FINISH_SAFE = 0, ++ HTTP_FINISH_SAFE_WITH_CB = 1, ++ HTTP_FINISH_UNSAFE = 2 ++}; ++typedef enum llhttp_finish llhttp_finish_t; ++ ++enum llhttp_method { ++ HTTP_DELETE = 0, ++ HTTP_GET = 1, ++ HTTP_HEAD = 2, ++ HTTP_POST = 3, ++ HTTP_PUT = 4, ++ HTTP_CONNECT = 5, ++ HTTP_OPTIONS = 6, ++ HTTP_TRACE = 7, ++ HTTP_COPY = 8, ++ HTTP_LOCK = 9, ++ HTTP_MKCOL = 10, ++ HTTP_MOVE = 11, ++ HTTP_PROPFIND = 12, ++ HTTP_PROPPATCH = 13, ++ HTTP_SEARCH = 14, ++ HTTP_UNLOCK = 15, ++ HTTP_BIND = 16, ++ HTTP_REBIND = 17, ++ HTTP_UNBIND = 18, ++ HTTP_ACL = 19, ++ HTTP_REPORT = 20, ++ HTTP_MKACTIVITY = 21, ++ HTTP_CHECKOUT = 22, ++ HTTP_MERGE = 23, ++ HTTP_MSEARCH = 24, ++ HTTP_NOTIFY = 25, ++ HTTP_SUBSCRIBE = 26, ++ HTTP_UNSUBSCRIBE = 27, ++ HTTP_PATCH = 28, ++ HTTP_PURGE = 29, ++ HTTP_MKCALENDAR = 30, ++ HTTP_LINK = 31, ++ HTTP_UNLINK = 32, ++ HTTP_SOURCE = 33, ++ HTTP_PRI = 34, ++ HTTP_DESCRIBE = 35, ++ HTTP_ANNOUNCE = 36, ++ HTTP_SETUP = 37, ++ HTTP_PLAY = 38, ++ HTTP_PAUSE = 39, ++ HTTP_TEARDOWN = 40, ++ HTTP_GET_PARAMETER = 41, ++ HTTP_SET_PARAMETER = 42, ++ HTTP_REDIRECT = 43, ++ HTTP_RECORD = 44, ++ HTTP_FLUSH = 45, ++ HTTP_QUERY = 46 ++}; ++typedef enum llhttp_method llhttp_method_t; ++ ++enum llhttp_status { ++ HTTP_STATUS_CONTINUE = 100, ++ HTTP_STATUS_SWITCHING_PROTOCOLS = 101, ++ HTTP_STATUS_PROCESSING = 102, ++ HTTP_STATUS_EARLY_HINTS = 103, ++ HTTP_STATUS_RESPONSE_IS_STALE = 110, ++ HTTP_STATUS_REVALIDATION_FAILED = 111, ++ HTTP_STATUS_DISCONNECTED_OPERATION = 112, ++ HTTP_STATUS_HEURISTIC_EXPIRATION = 113, ++ HTTP_STATUS_MISCELLANEOUS_WARNING = 199, ++ HTTP_STATUS_OK = 200, ++ HTTP_STATUS_CREATED = 201, ++ HTTP_STATUS_ACCEPTED = 202, ++ HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203, ++ HTTP_STATUS_NO_CONTENT = 204, ++ HTTP_STATUS_RESET_CONTENT = 205, ++ HTTP_STATUS_PARTIAL_CONTENT = 206, ++ HTTP_STATUS_MULTI_STATUS = 207, ++ HTTP_STATUS_ALREADY_REPORTED = 208, ++ HTTP_STATUS_TRANSFORMATION_APPLIED = 214, ++ HTTP_STATUS_IM_USED = 226, ++ HTTP_STATUS_MISCELLANEOUS_PERSISTENT_WARNING = 299, ++ HTTP_STATUS_MULTIPLE_CHOICES = 300, ++ HTTP_STATUS_MOVED_PERMANENTLY = 301, ++ HTTP_STATUS_FOUND = 302, ++ HTTP_STATUS_SEE_OTHER = 303, ++ HTTP_STATUS_NOT_MODIFIED = 304, ++ HTTP_STATUS_USE_PROXY = 305, ++ HTTP_STATUS_SWITCH_PROXY = 306, ++ HTTP_STATUS_TEMPORARY_REDIRECT = 307, ++ HTTP_STATUS_PERMANENT_REDIRECT = 308, ++ HTTP_STATUS_BAD_REQUEST = 400, ++ HTTP_STATUS_UNAUTHORIZED = 401, ++ HTTP_STATUS_PAYMENT_REQUIRED = 402, ++ HTTP_STATUS_FORBIDDEN = 403, ++ HTTP_STATUS_NOT_FOUND = 404, ++ HTTP_STATUS_METHOD_NOT_ALLOWED = 405, ++ HTTP_STATUS_NOT_ACCEPTABLE = 406, ++ HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407, ++ HTTP_STATUS_REQUEST_TIMEOUT = 408, ++ HTTP_STATUS_CONFLICT = 409, ++ HTTP_STATUS_GONE = 410, ++ HTTP_STATUS_LENGTH_REQUIRED = 411, ++ HTTP_STATUS_PRECONDITION_FAILED = 412, ++ HTTP_STATUS_PAYLOAD_TOO_LARGE = 413, ++ HTTP_STATUS_URI_TOO_LONG = 414, ++ HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415, ++ HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416, ++ HTTP_STATUS_EXPECTATION_FAILED = 417, ++ HTTP_STATUS_IM_A_TEAPOT = 418, ++ HTTP_STATUS_PAGE_EXPIRED = 419, ++ HTTP_STATUS_ENHANCE_YOUR_CALM = 420, ++ HTTP_STATUS_MISDIRECTED_REQUEST = 421, ++ HTTP_STATUS_UNPROCESSABLE_ENTITY = 422, ++ HTTP_STATUS_LOCKED = 423, ++ HTTP_STATUS_FAILED_DEPENDENCY = 424, ++ HTTP_STATUS_TOO_EARLY = 425, ++ HTTP_STATUS_UPGRADE_REQUIRED = 426, ++ HTTP_STATUS_PRECONDITION_REQUIRED = 428, ++ HTTP_STATUS_TOO_MANY_REQUESTS = 429, ++ HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL = 430, ++ HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431, ++ HTTP_STATUS_LOGIN_TIMEOUT = 440, ++ HTTP_STATUS_NO_RESPONSE = 444, ++ HTTP_STATUS_RETRY_WITH = 449, ++ HTTP_STATUS_BLOCKED_BY_PARENTAL_CONTROL = 450, ++ HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS = 451, ++ HTTP_STATUS_CLIENT_CLOSED_LOAD_BALANCED_REQUEST = 460, ++ HTTP_STATUS_INVALID_X_FORWARDED_FOR = 463, ++ HTTP_STATUS_REQUEST_HEADER_TOO_LARGE = 494, ++ HTTP_STATUS_SSL_CERTIFICATE_ERROR = 495, ++ HTTP_STATUS_SSL_CERTIFICATE_REQUIRED = 496, ++ HTTP_STATUS_HTTP_REQUEST_SENT_TO_HTTPS_PORT = 497, ++ HTTP_STATUS_INVALID_TOKEN = 498, ++ HTTP_STATUS_CLIENT_CLOSED_REQUEST = 499, ++ HTTP_STATUS_INTERNAL_SERVER_ERROR = 500, ++ HTTP_STATUS_NOT_IMPLEMENTED = 501, ++ HTTP_STATUS_BAD_GATEWAY = 502, ++ HTTP_STATUS_SERVICE_UNAVAILABLE = 503, ++ HTTP_STATUS_GATEWAY_TIMEOUT = 504, ++ HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED = 505, ++ HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506, ++ HTTP_STATUS_INSUFFICIENT_STORAGE = 507, ++ HTTP_STATUS_LOOP_DETECTED = 508, ++ HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED = 509, ++ HTTP_STATUS_NOT_EXTENDED = 510, ++ HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511, ++ HTTP_STATUS_WEB_SERVER_UNKNOWN_ERROR = 520, ++ HTTP_STATUS_WEB_SERVER_IS_DOWN = 521, ++ HTTP_STATUS_CONNECTION_TIMEOUT = 522, ++ HTTP_STATUS_ORIGIN_IS_UNREACHABLE = 523, ++ HTTP_STATUS_TIMEOUT_OCCURED = 524, ++ HTTP_STATUS_SSL_HANDSHAKE_FAILED = 525, ++ HTTP_STATUS_INVALID_SSL_CERTIFICATE = 526, ++ HTTP_STATUS_RAILGUN_ERROR = 527, ++ HTTP_STATUS_SITE_IS_OVERLOADED = 529, ++ HTTP_STATUS_SITE_IS_FROZEN = 530, ++ HTTP_STATUS_IDENTITY_PROVIDER_AUTHENTICATION_ERROR = 561, ++ HTTP_STATUS_NETWORK_READ_TIMEOUT = 598, ++ HTTP_STATUS_NETWORK_CONNECT_TIMEOUT = 599 ++}; ++typedef enum llhttp_status llhttp_status_t; ++ ++#define HTTP_ERRNO_MAP(XX) \ ++ XX(0, OK, OK) \ ++ XX(1, INTERNAL, INTERNAL) \ ++ XX(2, STRICT, STRICT) \ ++ XX(25, CR_EXPECTED, CR_EXPECTED) \ ++ XX(3, LF_EXPECTED, LF_EXPECTED) \ ++ XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \ ++ XX(30, UNEXPECTED_SPACE, UNEXPECTED_SPACE) \ ++ XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \ ++ XX(6, INVALID_METHOD, INVALID_METHOD) \ ++ XX(7, INVALID_URL, INVALID_URL) \ ++ XX(8, INVALID_CONSTANT, INVALID_CONSTANT) \ ++ XX(9, INVALID_VERSION, INVALID_VERSION) \ ++ XX(10, INVALID_HEADER_TOKEN, INVALID_HEADER_TOKEN) \ ++ XX(11, INVALID_CONTENT_LENGTH, INVALID_CONTENT_LENGTH) \ ++ XX(12, INVALID_CHUNK_SIZE, INVALID_CHUNK_SIZE) \ ++ XX(13, INVALID_STATUS, INVALID_STATUS) \ ++ XX(14, INVALID_EOF_STATE, INVALID_EOF_STATE) \ ++ XX(15, INVALID_TRANSFER_ENCODING, INVALID_TRANSFER_ENCODING) \ ++ XX(16, CB_MESSAGE_BEGIN, CB_MESSAGE_BEGIN) \ ++ XX(17, CB_HEADERS_COMPLETE, CB_HEADERS_COMPLETE) \ ++ XX(18, CB_MESSAGE_COMPLETE, CB_MESSAGE_COMPLETE) \ ++ XX(19, CB_CHUNK_HEADER, CB_CHUNK_HEADER) \ ++ XX(20, CB_CHUNK_COMPLETE, CB_CHUNK_COMPLETE) \ ++ XX(21, PAUSED, PAUSED) \ ++ XX(22, PAUSED_UPGRADE, PAUSED_UPGRADE) \ ++ XX(23, PAUSED_H2_UPGRADE, PAUSED_H2_UPGRADE) \ ++ XX(24, USER, USER) \ ++ XX(26, CB_URL_COMPLETE, CB_URL_COMPLETE) \ ++ XX(27, CB_STATUS_COMPLETE, CB_STATUS_COMPLETE) \ ++ XX(32, CB_METHOD_COMPLETE, CB_METHOD_COMPLETE) \ ++ XX(33, CB_VERSION_COMPLETE, CB_VERSION_COMPLETE) \ ++ XX(28, CB_HEADER_FIELD_COMPLETE, CB_HEADER_FIELD_COMPLETE) \ ++ XX(29, CB_HEADER_VALUE_COMPLETE, CB_HEADER_VALUE_COMPLETE) \ ++ XX(34, CB_CHUNK_EXTENSION_NAME_COMPLETE, CB_CHUNK_EXTENSION_NAME_COMPLETE) \ ++ XX(35, CB_CHUNK_EXTENSION_VALUE_COMPLETE, CB_CHUNK_EXTENSION_VALUE_COMPLETE) \ ++ XX(31, CB_RESET, CB_RESET) \ ++ ++ ++#define HTTP_METHOD_MAP(XX) \ ++ XX(0, DELETE, DELETE) \ ++ XX(1, GET, GET) \ ++ XX(2, HEAD, HEAD) \ ++ XX(3, POST, POST) \ ++ XX(4, PUT, PUT) \ ++ XX(5, CONNECT, CONNECT) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(7, TRACE, TRACE) \ ++ XX(8, COPY, COPY) \ ++ XX(9, LOCK, LOCK) \ ++ XX(10, MKCOL, MKCOL) \ ++ XX(11, MOVE, MOVE) \ ++ XX(12, PROPFIND, PROPFIND) \ ++ XX(13, PROPPATCH, PROPPATCH) \ ++ XX(14, SEARCH, SEARCH) \ ++ XX(15, UNLOCK, UNLOCK) \ ++ XX(16, BIND, BIND) \ ++ XX(17, REBIND, REBIND) \ ++ XX(18, UNBIND, UNBIND) \ ++ XX(19, ACL, ACL) \ ++ XX(20, REPORT, REPORT) \ ++ XX(21, MKACTIVITY, MKACTIVITY) \ ++ XX(22, CHECKOUT, CHECKOUT) \ ++ XX(23, MERGE, MERGE) \ ++ XX(24, MSEARCH, M-SEARCH) \ ++ XX(25, NOTIFY, NOTIFY) \ ++ XX(26, SUBSCRIBE, SUBSCRIBE) \ ++ XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ ++ XX(28, PATCH, PATCH) \ ++ XX(29, PURGE, PURGE) \ ++ XX(30, MKCALENDAR, MKCALENDAR) \ ++ XX(31, LINK, LINK) \ ++ XX(32, UNLINK, UNLINK) \ ++ XX(33, SOURCE, SOURCE) \ ++ XX(46, QUERY, QUERY) \ ++ ++ ++#define RTSP_METHOD_MAP(XX) \ ++ XX(1, GET, GET) \ ++ XX(3, POST, POST) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(35, DESCRIBE, DESCRIBE) \ ++ XX(36, ANNOUNCE, ANNOUNCE) \ ++ XX(37, SETUP, SETUP) \ ++ XX(38, PLAY, PLAY) \ ++ XX(39, PAUSE, PAUSE) \ ++ XX(40, TEARDOWN, TEARDOWN) \ ++ XX(41, GET_PARAMETER, GET_PARAMETER) \ ++ XX(42, SET_PARAMETER, SET_PARAMETER) \ ++ XX(43, REDIRECT, REDIRECT) \ ++ XX(44, RECORD, RECORD) \ ++ XX(45, FLUSH, FLUSH) \ ++ ++ ++#define HTTP_ALL_METHOD_MAP(XX) \ ++ XX(0, DELETE, DELETE) \ ++ XX(1, GET, GET) \ ++ XX(2, HEAD, HEAD) \ ++ XX(3, POST, POST) \ ++ XX(4, PUT, PUT) \ ++ XX(5, CONNECT, CONNECT) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(7, TRACE, TRACE) \ ++ XX(8, COPY, COPY) \ ++ XX(9, LOCK, LOCK) \ ++ XX(10, MKCOL, MKCOL) \ ++ XX(11, MOVE, MOVE) \ ++ XX(12, PROPFIND, PROPFIND) \ ++ XX(13, PROPPATCH, PROPPATCH) \ ++ XX(14, SEARCH, SEARCH) \ ++ XX(15, UNLOCK, UNLOCK) \ ++ XX(16, BIND, BIND) \ ++ XX(17, REBIND, REBIND) \ ++ XX(18, UNBIND, UNBIND) \ ++ XX(19, ACL, ACL) \ ++ XX(20, REPORT, REPORT) \ ++ XX(21, MKACTIVITY, MKACTIVITY) \ ++ XX(22, CHECKOUT, CHECKOUT) \ ++ XX(23, MERGE, MERGE) \ ++ XX(24, MSEARCH, M-SEARCH) \ ++ XX(25, NOTIFY, NOTIFY) \ ++ XX(26, SUBSCRIBE, SUBSCRIBE) \ ++ XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ ++ XX(28, PATCH, PATCH) \ ++ XX(29, PURGE, PURGE) \ ++ XX(30, MKCALENDAR, MKCALENDAR) \ ++ XX(31, LINK, LINK) \ ++ XX(32, UNLINK, UNLINK) \ ++ XX(33, SOURCE, SOURCE) \ ++ XX(34, PRI, PRI) \ ++ XX(35, DESCRIBE, DESCRIBE) \ ++ XX(36, ANNOUNCE, ANNOUNCE) \ ++ XX(37, SETUP, SETUP) \ ++ XX(38, PLAY, PLAY) \ ++ XX(39, PAUSE, PAUSE) \ ++ XX(40, TEARDOWN, TEARDOWN) \ ++ XX(41, GET_PARAMETER, GET_PARAMETER) \ ++ XX(42, SET_PARAMETER, SET_PARAMETER) \ ++ XX(43, REDIRECT, REDIRECT) \ ++ XX(44, RECORD, RECORD) \ ++ XX(45, FLUSH, FLUSH) \ ++ XX(46, QUERY, QUERY) \ ++ ++ ++#define HTTP_STATUS_MAP(XX) \ ++ XX(100, CONTINUE, CONTINUE) \ ++ XX(101, SWITCHING_PROTOCOLS, SWITCHING_PROTOCOLS) \ ++ XX(102, PROCESSING, PROCESSING) \ ++ XX(103, EARLY_HINTS, EARLY_HINTS) \ ++ XX(110, RESPONSE_IS_STALE, RESPONSE_IS_STALE) \ ++ XX(111, REVALIDATION_FAILED, REVALIDATION_FAILED) \ ++ XX(112, DISCONNECTED_OPERATION, DISCONNECTED_OPERATION) \ ++ XX(113, HEURISTIC_EXPIRATION, HEURISTIC_EXPIRATION) \ ++ XX(199, MISCELLANEOUS_WARNING, MISCELLANEOUS_WARNING) \ ++ XX(200, OK, OK) \ ++ XX(201, CREATED, CREATED) \ ++ XX(202, ACCEPTED, ACCEPTED) \ ++ XX(203, NON_AUTHORITATIVE_INFORMATION, NON_AUTHORITATIVE_INFORMATION) \ ++ XX(204, NO_CONTENT, NO_CONTENT) \ ++ XX(205, RESET_CONTENT, RESET_CONTENT) \ ++ XX(206, PARTIAL_CONTENT, PARTIAL_CONTENT) \ ++ XX(207, MULTI_STATUS, MULTI_STATUS) \ ++ XX(208, ALREADY_REPORTED, ALREADY_REPORTED) \ ++ XX(214, TRANSFORMATION_APPLIED, TRANSFORMATION_APPLIED) \ ++ XX(226, IM_USED, IM_USED) \ ++ XX(299, MISCELLANEOUS_PERSISTENT_WARNING, MISCELLANEOUS_PERSISTENT_WARNING) \ ++ XX(300, MULTIPLE_CHOICES, MULTIPLE_CHOICES) \ ++ XX(301, MOVED_PERMANENTLY, MOVED_PERMANENTLY) \ ++ XX(302, FOUND, FOUND) \ ++ XX(303, SEE_OTHER, SEE_OTHER) \ ++ XX(304, NOT_MODIFIED, NOT_MODIFIED) \ ++ XX(305, USE_PROXY, USE_PROXY) \ ++ XX(306, SWITCH_PROXY, SWITCH_PROXY) \ ++ XX(307, TEMPORARY_REDIRECT, TEMPORARY_REDIRECT) \ ++ XX(308, PERMANENT_REDIRECT, PERMANENT_REDIRECT) \ ++ XX(400, BAD_REQUEST, BAD_REQUEST) \ ++ XX(401, UNAUTHORIZED, UNAUTHORIZED) \ ++ XX(402, PAYMENT_REQUIRED, PAYMENT_REQUIRED) \ ++ XX(403, FORBIDDEN, FORBIDDEN) \ ++ XX(404, NOT_FOUND, NOT_FOUND) \ ++ XX(405, METHOD_NOT_ALLOWED, METHOD_NOT_ALLOWED) \ ++ XX(406, NOT_ACCEPTABLE, NOT_ACCEPTABLE) \ ++ XX(407, PROXY_AUTHENTICATION_REQUIRED, PROXY_AUTHENTICATION_REQUIRED) \ ++ XX(408, REQUEST_TIMEOUT, REQUEST_TIMEOUT) \ ++ XX(409, CONFLICT, CONFLICT) \ ++ XX(410, GONE, GONE) \ ++ XX(411, LENGTH_REQUIRED, LENGTH_REQUIRED) \ ++ XX(412, PRECONDITION_FAILED, PRECONDITION_FAILED) \ ++ XX(413, PAYLOAD_TOO_LARGE, PAYLOAD_TOO_LARGE) \ ++ XX(414, URI_TOO_LONG, URI_TOO_LONG) \ ++ XX(415, UNSUPPORTED_MEDIA_TYPE, UNSUPPORTED_MEDIA_TYPE) \ ++ XX(416, RANGE_NOT_SATISFIABLE, RANGE_NOT_SATISFIABLE) \ ++ XX(417, EXPECTATION_FAILED, EXPECTATION_FAILED) \ ++ XX(418, IM_A_TEAPOT, IM_A_TEAPOT) \ ++ XX(419, PAGE_EXPIRED, PAGE_EXPIRED) \ ++ XX(420, ENHANCE_YOUR_CALM, ENHANCE_YOUR_CALM) \ ++ XX(421, MISDIRECTED_REQUEST, MISDIRECTED_REQUEST) \ ++ XX(422, UNPROCESSABLE_ENTITY, UNPROCESSABLE_ENTITY) \ ++ XX(423, LOCKED, LOCKED) \ ++ XX(424, FAILED_DEPENDENCY, FAILED_DEPENDENCY) \ ++ XX(425, TOO_EARLY, TOO_EARLY) \ ++ XX(426, UPGRADE_REQUIRED, UPGRADE_REQUIRED) \ ++ XX(428, PRECONDITION_REQUIRED, PRECONDITION_REQUIRED) \ ++ XX(429, TOO_MANY_REQUESTS, TOO_MANY_REQUESTS) \ ++ XX(430, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL) \ ++ XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, REQUEST_HEADER_FIELDS_TOO_LARGE) \ ++ XX(440, LOGIN_TIMEOUT, LOGIN_TIMEOUT) \ ++ XX(444, NO_RESPONSE, NO_RESPONSE) \ ++ XX(449, RETRY_WITH, RETRY_WITH) \ ++ XX(450, BLOCKED_BY_PARENTAL_CONTROL, BLOCKED_BY_PARENTAL_CONTROL) \ ++ XX(451, UNAVAILABLE_FOR_LEGAL_REASONS, UNAVAILABLE_FOR_LEGAL_REASONS) \ ++ XX(460, CLIENT_CLOSED_LOAD_BALANCED_REQUEST, CLIENT_CLOSED_LOAD_BALANCED_REQUEST) \ ++ XX(463, INVALID_X_FORWARDED_FOR, INVALID_X_FORWARDED_FOR) \ ++ XX(494, REQUEST_HEADER_TOO_LARGE, REQUEST_HEADER_TOO_LARGE) \ ++ XX(495, SSL_CERTIFICATE_ERROR, SSL_CERTIFICATE_ERROR) \ ++ XX(496, SSL_CERTIFICATE_REQUIRED, SSL_CERTIFICATE_REQUIRED) \ ++ XX(497, HTTP_REQUEST_SENT_TO_HTTPS_PORT, HTTP_REQUEST_SENT_TO_HTTPS_PORT) \ ++ XX(498, INVALID_TOKEN, INVALID_TOKEN) \ ++ XX(499, CLIENT_CLOSED_REQUEST, CLIENT_CLOSED_REQUEST) \ ++ XX(500, INTERNAL_SERVER_ERROR, INTERNAL_SERVER_ERROR) \ ++ XX(501, NOT_IMPLEMENTED, NOT_IMPLEMENTED) \ ++ XX(502, BAD_GATEWAY, BAD_GATEWAY) \ ++ XX(503, SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE) \ ++ XX(504, GATEWAY_TIMEOUT, GATEWAY_TIMEOUT) \ ++ XX(505, HTTP_VERSION_NOT_SUPPORTED, HTTP_VERSION_NOT_SUPPORTED) \ ++ XX(506, VARIANT_ALSO_NEGOTIATES, VARIANT_ALSO_NEGOTIATES) \ ++ XX(507, INSUFFICIENT_STORAGE, INSUFFICIENT_STORAGE) \ ++ XX(508, LOOP_DETECTED, LOOP_DETECTED) \ ++ XX(509, BANDWIDTH_LIMIT_EXCEEDED, BANDWIDTH_LIMIT_EXCEEDED) \ ++ XX(510, NOT_EXTENDED, NOT_EXTENDED) \ ++ XX(511, NETWORK_AUTHENTICATION_REQUIRED, NETWORK_AUTHENTICATION_REQUIRED) \ ++ XX(520, WEB_SERVER_UNKNOWN_ERROR, WEB_SERVER_UNKNOWN_ERROR) \ ++ XX(521, WEB_SERVER_IS_DOWN, WEB_SERVER_IS_DOWN) \ ++ XX(522, CONNECTION_TIMEOUT, CONNECTION_TIMEOUT) \ ++ XX(523, ORIGIN_IS_UNREACHABLE, ORIGIN_IS_UNREACHABLE) \ ++ XX(524, TIMEOUT_OCCURED, TIMEOUT_OCCURED) \ ++ XX(525, SSL_HANDSHAKE_FAILED, SSL_HANDSHAKE_FAILED) \ ++ XX(526, INVALID_SSL_CERTIFICATE, INVALID_SSL_CERTIFICATE) \ ++ XX(527, RAILGUN_ERROR, RAILGUN_ERROR) \ ++ XX(529, SITE_IS_OVERLOADED, SITE_IS_OVERLOADED) \ ++ XX(530, SITE_IS_FROZEN, SITE_IS_FROZEN) \ ++ XX(561, IDENTITY_PROVIDER_AUTHENTICATION_ERROR, IDENTITY_PROVIDER_AUTHENTICATION_ERROR) \ ++ XX(598, NETWORK_READ_TIMEOUT, NETWORK_READ_TIMEOUT) \ ++ XX(599, NETWORK_CONNECT_TIMEOUT, NETWORK_CONNECT_TIMEOUT) \ ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* LLLLHTTP_C_HEADERS_ */ ++ ++ ++#ifndef INCLUDE_LLHTTP_API_H_ ++#define INCLUDE_LLHTTP_API_H_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++#include ++ ++#define LLHTTP_EXPORT ++ ++typedef llhttp__internal_t llhttp_t; ++typedef struct llhttp_settings_s llhttp_settings_t; ++ ++typedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length); ++typedef int (*llhttp_cb)(llhttp_t*); ++ ++struct llhttp_settings_s { ++ /* Possible return values 0, -1, `HPE_PAUSED` */ ++ llhttp_cb on_message_begin; ++ ++ /* Possible return values 0, -1, HPE_USER */ ++ llhttp_data_cb on_url; ++ llhttp_data_cb on_status; ++ llhttp_data_cb on_method; ++ llhttp_data_cb on_version; ++ llhttp_data_cb on_header_field; ++ llhttp_data_cb on_header_value; ++ llhttp_data_cb on_chunk_extension_name; ++ llhttp_data_cb on_chunk_extension_value; ++ ++ /* Possible return values: ++ * 0 - Proceed normally ++ * 1 - Assume that request/response has no body, and proceed to parsing the ++ * next message ++ * 2 - Assume absence of body (as above) and make `llhttp_execute()` return ++ * `HPE_PAUSED_UPGRADE` ++ * -1 - Error ++ * `HPE_PAUSED` ++ */ ++ llhttp_cb on_headers_complete; ++ ++ /* Possible return values 0, -1, HPE_USER */ ++ llhttp_data_cb on_body; ++ ++ /* Possible return values 0, -1, `HPE_PAUSED` */ ++ llhttp_cb on_message_complete; ++ llhttp_cb on_url_complete; ++ llhttp_cb on_status_complete; ++ llhttp_cb on_method_complete; ++ llhttp_cb on_version_complete; ++ llhttp_cb on_header_field_complete; ++ llhttp_cb on_header_value_complete; ++ llhttp_cb on_chunk_extension_name_complete; ++ llhttp_cb on_chunk_extension_value_complete; ++ ++ /* When on_chunk_header is called, the current chunk length is stored ++ * in parser->content_length. ++ * Possible return values 0, -1, `HPE_PAUSED` ++ */ ++ llhttp_cb on_chunk_header; ++ llhttp_cb on_chunk_complete; ++ llhttp_cb on_reset; ++}; ++ ++/* Initialize the parser with specific type and user settings. ++ * ++ * NOTE: lifetime of `settings` has to be at least the same as the lifetime of ++ * the `parser` here. In practice, `settings` has to be either a static ++ * variable or be allocated with `malloc`, `new`, etc. ++ */ ++LLHTTP_EXPORT ++void llhttp_init(llhttp_t* parser, llhttp_type_t type, ++ const llhttp_settings_t* settings); ++ ++LLHTTP_EXPORT ++llhttp_t* llhttp_alloc(llhttp_type_t type); ++ ++LLHTTP_EXPORT ++void llhttp_free(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_type(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_http_major(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_http_minor(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_method(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++int llhttp_get_status_code(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_upgrade(llhttp_t* parser); ++ ++/* Reset an already initialized parser back to the start state, preserving the ++ * existing parser type, callback settings, user data, and lenient flags. ++ */ ++LLHTTP_EXPORT ++void llhttp_reset(llhttp_t* parser); ++ ++/* Initialize the settings object */ ++LLHTTP_EXPORT ++void llhttp_settings_init(llhttp_settings_t* settings); ++ ++/* Parse full or partial request/response, invoking user callbacks along the ++ * way. ++ * ++ * If any of `llhttp_data_cb` returns errno not equal to `HPE_OK` - the parsing ++ * interrupts, and such errno is returned from `llhttp_execute()`. If ++ * `HPE_PAUSED` was used as a errno, the execution can be resumed with ++ * `llhttp_resume()` call. ++ * ++ * In a special case of CONNECT/Upgrade request/response `HPE_PAUSED_UPGRADE` ++ * is returned after fully parsing the request/response. If the user wishes to ++ * continue parsing, they need to invoke `llhttp_resume_after_upgrade()`. ++ * ++ * NOTE: if this function ever returns a non-pause type error, it will continue ++ * to return the same error upon each successive call up until `llhttp_init()` ++ * is called. ++ */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len); ++ ++/* This method should be called when the other side has no further bytes to ++ * send (e.g. shutdown of readable side of the TCP connection.) ++ * ++ * Requests without `Content-Length` and other messages might require treating ++ * all incoming bytes as the part of the body, up to the last byte of the ++ * connection. This method will invoke `on_message_complete()` callback if the ++ * request was terminated safely. Otherwise a error code would be returned. ++ */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_finish(llhttp_t* parser); ++ ++/* Returns `1` if the incoming message is parsed until the last byte, and has ++ * to be completed by calling `llhttp_finish()` on EOF ++ */ ++LLHTTP_EXPORT ++int llhttp_message_needs_eof(const llhttp_t* parser); ++ ++/* Returns `1` if there might be any other messages following the last that was ++ * successfully parsed. ++ */ ++LLHTTP_EXPORT ++int llhttp_should_keep_alive(const llhttp_t* parser); ++ ++/* Make further calls of `llhttp_execute()` return `HPE_PAUSED` and set ++ * appropriate error reason. ++ * ++ * Important: do not call this from user callbacks! User callbacks must return ++ * `HPE_PAUSED` if pausing is required. ++ */ ++LLHTTP_EXPORT ++void llhttp_pause(llhttp_t* parser); ++ ++/* Might be called to resume the execution after the pause in user's callback. ++ * See `llhttp_execute()` above for details. ++ * ++ * Call this only if `llhttp_execute()` returns `HPE_PAUSED`. ++ */ ++LLHTTP_EXPORT ++void llhttp_resume(llhttp_t* parser); ++ ++/* Might be called to resume the execution after the pause in user's callback. ++ * See `llhttp_execute()` above for details. ++ * ++ * Call this only if `llhttp_execute()` returns `HPE_PAUSED_UPGRADE` ++ */ ++LLHTTP_EXPORT ++void llhttp_resume_after_upgrade(llhttp_t* parser); ++ ++/* Returns the latest return error */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_get_errno(const llhttp_t* parser); ++ ++/* Returns the verbal explanation of the latest returned error. ++ * ++ * Note: User callback should set error reason when returning the error. See ++ * `llhttp_set_error_reason()` for details. ++ */ ++LLHTTP_EXPORT ++const char* llhttp_get_error_reason(const llhttp_t* parser); ++ ++/* Assign verbal description to the returned error. Must be called in user ++ * callbacks right before returning the errno. ++ * ++ * Note: `HPE_USER` error code might be useful in user callbacks. ++ */ ++LLHTTP_EXPORT ++void llhttp_set_error_reason(llhttp_t* parser, const char* reason); ++ ++/* Returns the pointer to the last parsed byte before the returned error. The ++ * pointer is relative to the `data` argument of `llhttp_execute()`. ++ * ++ * Note: this method might be useful for counting the number of parsed bytes. ++ */ ++LLHTTP_EXPORT ++const char* llhttp_get_error_pos(const llhttp_t* parser); ++ ++/* Returns textual name of error code */ ++LLHTTP_EXPORT ++const char* llhttp_errno_name(llhttp_errno_t err); ++ ++/* Returns textual name of HTTP method */ ++LLHTTP_EXPORT ++const char* llhttp_method_name(llhttp_method_t method); ++ ++/* Returns textual name of HTTP status */ ++LLHTTP_EXPORT ++const char* llhttp_status_name(llhttp_status_t status); ++ ++/* Enables/disables lenient header value parsing (disabled by default). ++ * ++ * Lenient parsing disables header value token checks, extending llhttp's ++ * protocol support to highly non-compliant clients/server. No ++ * `HPE_INVALID_HEADER_TOKEN` will be raised for incorrect header values when ++ * lenient parsing is "on". ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_headers(llhttp_t* parser, int enabled); ++ ++ ++/* Enables/disables lenient handling of conflicting `Transfer-Encoding` and ++ * `Content-Length` headers (disabled by default). ++ * ++ * Normally `llhttp` would error when `Transfer-Encoding` is present in ++ * conjunction with `Content-Length`. This error is important to prevent HTTP ++ * request smuggling, but may be less desirable for small number of cases ++ * involving legacy servers. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled); ++ ++ ++/* Enables/disables lenient handling of `Connection: close` and HTTP/1.0 ++ * requests responses. ++ * ++ * Normally `llhttp` would error on (in strict mode) or discard (in loose mode) ++ * the HTTP request/response after the request/response with `Connection: close` ++ * and `Content-Length`. This is important to prevent cache poisoning attacks, ++ * but might interact badly with outdated and insecure clients. With this flag ++ * the extra request/response will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * poisoning attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of `Transfer-Encoding` header. ++ * ++ * Normally `llhttp` would error when a `Transfer-Encoding` has `chunked` value ++ * and another value after it (either in a single header or in multiple ++ * headers whose value are internally joined using `, `). ++ * This is mandated by the spec to reliably determine request body size and thus ++ * avoid request smuggling. ++ * With this flag the extra value will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of HTTP version. ++ * ++ * Normally `llhttp` would error when the HTTP version in the request or status line ++ * is not `0.9`, `1.0`, `1.1` or `2.0`. ++ * With this flag the invalid value will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will allow unsupported ++ * HTTP versions. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_version(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of additional data received after a message ends ++ * and keep-alive is disabled. ++ * ++ * Normally `llhttp` would error when additional unexpected data is received if the message ++ * contains the `Connection` header with `close` value. ++ * With this flag the extra data will discarded without throwing an error. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * poisoning attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of incomplete CRLF sequences. ++ * ++ * Normally `llhttp` would error when a CR is not followed by LF when terminating the ++ * request line, the status line, the headers or a chunk header. ++ * With this flag only a CR is required to terminate such sections. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled); ++ ++/* ++ * Enables/disables lenient handling of line separators. ++ * ++ * Normally `llhttp` would error when a LF is not preceded by CR when terminating the ++ * request line, the status line, the headers, a chunk header or a chunk data. ++ * With this flag only a LF is required to terminate such sections. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of chunks not separated via CRLF. ++ * ++ * Normally `llhttp` would error when after a chunk data a CRLF is missing before ++ * starting a new chunk. ++ * With this flag the new chunk can start immediately after the previous one. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of spaces after chunk size. ++ * ++ * Normally `llhttp` would error when after a chunk size is followed by one or more ++ * spaces are present instead of a CRLF or `;`. ++ * With this flag this check is disabled. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled); ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* INCLUDE_LLHTTP_API_H_ */ ++ ++ ++#endif /* INCLUDE_LLHTTP_H_ */ +diff --git a/script/valgrind.supp b/script/valgrind.supp +index 8c4549f62bed92429db16c7288f3ba440967cffe..b641386636f0ad2c2d7ce27adb2f6d5be09ef53d 100644 +--- a/script/valgrind.supp ++++ b/script/valgrind.supp +@@ -80,6 +80,13 @@ + fun:__check_pf + } + ++{ ++ ignore-glibc-getaddrinfo-fn ++ Memcheck:Leak ++ ... ++ fun:getaddrinfo ++} ++ + { + ignore-curl-global-init + Memcheck:Leak +diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c +index 8437674fcc9f1b6d8a88a10f4c84b6671bbcc1b6..fc2161b6076a7224f6a156dc910e5f16407e420c 100644 +--- a/src/libgit2/transports/http.c ++++ b/src/libgit2/transports/http.c +@@ -9,7 +9,6 @@ + + #ifndef GIT_WINHTTP + +-#include "http_parser.h" + #include "net.h" + #include "remote.h" + #include "smart.h" +diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c +index a20b594930dc23e8cba029bf6bc21f3d85cb758b..e68d3de753830d477a3d5a9a873d21b4d676189a 100644 +--- a/src/libgit2/transports/httpclient.c ++++ b/src/libgit2/transports/httpclient.c +@@ -7,7 +7,7 @@ + + #include "common.h" + #include "git2.h" +-#include "http_parser.h" ++ + #include "vector.h" + #include "trace.h" + #include "httpclient.h" +@@ -21,6 +21,7 @@ + #include "streams/socket.h" + #include "streams/tls.h" + #include "auth.h" ++#include "httpparser.h" + + static git_http_auth_scheme auth_schemes[] = { + { GIT_HTTP_AUTH_NEGOTIATE, "Negotiate", GIT_CREDENTIAL_DEFAULT, git_http_auth_negotiate }, +@@ -108,7 +109,7 @@ struct git_http_client { + git_http_server_t current_server; + http_client_state state; + +- http_parser parser; ++ git_http_parser parser; + + git_http_server server; + git_http_server proxy; +@@ -154,7 +155,7 @@ void git_http_response_dispose(git_http_response *response) + memset(response, 0, sizeof(git_http_response)); + } + +-static int on_header_complete(http_parser *parser) ++static int on_header_complete(git_http_parser *parser) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + git_http_client *client = ctx->client; +@@ -219,7 +220,7 @@ static int on_header_complete(http_parser *parser) + return 0; + } + +-static int on_header_field(http_parser *parser, const char *str, size_t len) ++static int on_header_field(git_http_parser *parser, const char *str, size_t len) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + +@@ -254,7 +255,7 @@ static int on_header_field(http_parser *parser, const char *str, size_t len) + return 0; + } + +-static int on_header_value(http_parser *parser, const char *str, size_t len) ++static int on_header_value(git_http_parser *parser, const char *str, size_t len) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + +@@ -342,7 +343,7 @@ static int resend_needed(git_http_client *client, git_http_response *response) + return 0; + } + +-static int on_headers_complete(http_parser *parser) ++static int on_headers_complete(git_http_parser *parser) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + +@@ -364,8 +365,8 @@ static int on_headers_complete(http_parser *parser) + return ctx->parse_status = PARSE_STATUS_ERROR; + } + +- ctx->response->status = parser->status_code; +- ctx->client->keepalive = http_should_keep_alive(parser); ++ ctx->response->status = git_http_parser_status_code(parser); ++ ctx->client->keepalive = git_http_parser_keep_alive(parser); + + /* Prepare for authentication */ + collect_authinfo(&ctx->response->server_auth_schemetypes, +@@ -378,18 +379,15 @@ static int on_headers_complete(http_parser *parser) + ctx->response->resend_credentials = resend_needed(ctx->client, + ctx->response); + +- /* Stop parsing. */ +- http_parser_pause(parser, 1); +- + if (ctx->response->content_type || ctx->response->chunked) + ctx->client->state = READING_BODY; + else + ctx->client->state = DONE; + +- return 0; ++ return git_http_parser_pause(parser); + } + +-static int on_body(http_parser *parser, const char *buf, size_t len) ++static int on_body(git_http_parser *parser, const char *buf, size_t len) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + size_t max_len; +@@ -411,7 +409,7 @@ static int on_body(http_parser *parser, const char *buf, size_t len) + return 0; + } + +-static int on_message_complete(http_parser *parser) ++static int on_message_complete(git_http_parser *parser) + { + http_parser_context *ctx = (http_parser_context *) parser->data; + +@@ -864,9 +862,29 @@ GIT_INLINE(int) server_setup_from_url( + return 0; + } + ++static bool parser_settings_initialized; ++static git_http_parser_settings parser_settings; ++ ++GIT_INLINE(git_http_parser_settings *) http_client_parser_settings(void) ++{ ++ if (!parser_settings_initialized) { ++ parser_settings.on_header_field = on_header_field; ++ parser_settings.on_header_value = on_header_value; ++ parser_settings.on_headers_complete = on_headers_complete; ++ parser_settings.on_body = on_body; ++ parser_settings.on_message_complete = on_message_complete; ++ ++ parser_settings_initialized = true; ++ } ++ ++ return &parser_settings; ++} ++ + static void reset_parser(git_http_client *client) + { +- http_parser_init(&client->parser, HTTP_RESPONSE); ++ git_http_parser_init(&client->parser, ++ GIT_HTTP_PARSER_RESPONSE, ++ http_client_parser_settings()); + } + + static int setup_hosts( +@@ -1109,27 +1127,9 @@ GIT_INLINE(int) client_read(git_http_client *client) + return (int)read_len; + } + +-static bool parser_settings_initialized; +-static http_parser_settings parser_settings; +- +-GIT_INLINE(http_parser_settings *) http_client_parser_settings(void) +-{ +- if (!parser_settings_initialized) { +- parser_settings.on_header_field = on_header_field; +- parser_settings.on_header_value = on_header_value; +- parser_settings.on_headers_complete = on_headers_complete; +- parser_settings.on_body = on_body; +- parser_settings.on_message_complete = on_message_complete; +- +- parser_settings_initialized = true; +- } +- +- return &parser_settings; +-} +- + GIT_INLINE(int) client_read_and_parse(git_http_client *client) + { +- http_parser *parser = &client->parser; ++ git_http_parser *parser = &client->parser; + http_parser_context *ctx = (http_parser_context *) parser->data; + unsigned char http_errno; + int read_len; +@@ -1143,11 +1143,10 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) + if (!client->read_buf.size && (read_len = client_read(client)) < 0) + return read_len; + +- parsed_len = http_parser_execute(parser, +- http_client_parser_settings(), ++ parsed_len = git_http_parser_execute(parser, + client->read_buf.ptr, + client->read_buf.size); +- http_errno = client->parser.http_errno; ++ http_errno = git_http_parser_errno(parser); + + if (parsed_len > INT_MAX) { + git_error_set(GIT_ERROR_HTTP, "unexpectedly large parse"); +@@ -1166,26 +1165,29 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) + * (This can happen in response to an expect/continue request, + * where the server gives you a 100 and 200 simultaneously.) + */ +- if (http_errno == HPE_PAUSED) { ++ if (http_errno == GIT_HTTP_PARSER_PAUSED) { ++ size_t additional_size; ++ ++ git_http_parser_resume(parser); ++ + /* +- * http-parser has a "feature" where it will not deliver the +- * final byte when paused in a callback. Consume that byte. +- * https://github.com/nodejs/http-parser/issues/97 ++ * http-parser has a "feature" where it will not deliver ++ * the final byte when paused in a callback. Consume ++ * that byte. + */ +- GIT_ASSERT(client->read_buf.size > parsed_len); ++ if ((additional_size = git_http_parser_remain_after_pause(parser)) > 0) { ++ GIT_ASSERT((client->read_buf.size - parsed_len) >= additional_size); + +- http_parser_pause(parser, 0); +- +- parsed_len += http_parser_execute(parser, +- http_client_parser_settings(), +- client->read_buf.ptr + parsed_len, +- 1); ++ parsed_len += git_http_parser_execute(parser, ++ client->read_buf.ptr + parsed_len, ++ additional_size); ++ } + } + + /* Most failures will be reported in http_errno */ +- else if (parser->http_errno != HPE_OK) { ++ else if (git_http_parser_errno(parser) != GIT_HTTP_PARSER_OK) { + git_error_set(GIT_ERROR_HTTP, "http parser error: %s", +- http_errno_description(http_errno)); ++ git_http_parser_errmsg(parser, http_errno)); + return -1; + } + +@@ -1193,7 +1195,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) + else if (parsed_len != client->read_buf.size) { + git_error_set(GIT_ERROR_HTTP, + "http parser did not consume entire buffer: %s", +- http_errno_description(http_errno)); ++ git_http_parser_errmsg(parser, http_errno)); + return -1; + } + +@@ -1232,7 +1234,7 @@ static void complete_response_body(git_http_client *client) + + /* If there was an error, just close the connection. */ + if (client_read_and_parse(client) < 0 || +- parser_context.error != HPE_OK || ++ parser_context.error != GIT_HTTP_PARSER_OK || + (parser_context.parse_status != PARSE_STATUS_OK && + parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) { + git_error_clear(); +@@ -1506,7 +1508,7 @@ int git_http_client_skip_body(git_http_client *client) + do { + error = client_read_and_parse(client); + +- if (parser_context.error != HPE_OK || ++ if (parser_context.error != GIT_HTTP_PARSER_OK || + (parser_context.parse_status != PARSE_STATUS_OK && + parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) { + git_error_set(GIT_ERROR_HTTP, +diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c +new file mode 100644 +index 0000000000000000000000000000000000000000..50ba6d2e0cd2b092bad2b9e7416be2b99ce40aff +--- /dev/null ++++ b/src/libgit2/transports/httpparser.c +@@ -0,0 +1,126 @@ ++/* ++ * Copyright (C) the libgit2 contributors. All rights reserved. ++ * ++ * This file is part of libgit2, distributed under the GNU GPL v2 with ++ * a Linking Exception. For full terms see the included COPYING file. ++ */ ++ ++#include "httpparser.h" ++ ++#include ++ ++#if defined(GIT_HTTPPARSER_HTTPPARSER) ++ ++#include "http_parser.h" ++ ++static int on_message_begin(http_parser *p) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_message_begin(parser); ++} ++ ++static int on_url(http_parser *p, const char *str, size_t len) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_url(parser, str, len); ++} ++ ++static int on_header_field(http_parser *p, const char *str, size_t len) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_header_field(parser, str, len); ++} ++ ++static int on_header_value(http_parser *p, const char *str, size_t len) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_header_value(parser, str, len); ++} ++ ++static int on_headers_complete(http_parser *p) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_headers_complete(parser); ++} ++ ++static int on_body(http_parser *p, const char *buf, size_t len) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_body(parser, buf, len); ++} ++ ++static int on_message_complete(http_parser *p) ++{ ++ git_http_parser *parser = (git_http_parser *)p; ++ return parser->settings.on_message_complete(parser); ++} ++ ++void git_http_parser_init( ++ git_http_parser *parser, ++ git_http_parser_t type, ++ git_http_parser_settings *settings) ++{ ++ http_parser_init(&parser->parser, (enum http_parser_type)type); ++ memcpy(&parser->settings, settings, sizeof(git_http_parser_settings)); ++} ++ ++size_t git_http_parser_execute( ++ git_http_parser *parser, ++ const char *data, ++ size_t len) ++{ ++ struct http_parser_settings settings_proxy; ++ ++ settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL; ++ settings_proxy.on_url = parser->settings.on_url ? on_url : NULL; ++ settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL; ++ settings_proxy.on_header_value = parser->settings.on_header_value ? on_header_value : NULL; ++ settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL; ++ settings_proxy.on_body = parser->settings.on_body ? on_body : NULL; ++ settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL; ++ ++ return http_parser_execute(&parser->parser, &settings_proxy, data, len); ++} ++ ++#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN) ++ ++# include ++ ++size_t git_http_parser_execute( ++ git_http_parser *parser, ++ const char* data, ++ size_t len) ++{ ++ llhttp_errno_t error; ++ size_t parsed_len; ++ ++ /* ++ * Unlike http_parser, which returns the number of parsed ++ * bytes in the _execute() call, llhttp returns an error ++ * code. ++ */ ++ ++ if (data == NULL || len == 0) ++ error = llhttp_finish(parser); ++ else ++ error = llhttp_execute(parser, data, len); ++ ++ parsed_len = len; ++ ++ /* ++ * Adjust number of parsed bytes in case of error. ++ */ ++ if (error != HPE_OK) { ++ parsed_len = llhttp_get_error_pos(parser) - data; ++ ++ /* This isn't a real pause, just a way to stop parsing early. */ ++ if (error == HPE_PAUSED_UPGRADE) ++ llhttp_resume_after_upgrade(parser); ++ } ++ ++ return parsed_len; ++} ++ ++#else ++# error unknown http-parser ++#endif +diff --git a/src/libgit2/transports/httpparser.h b/src/libgit2/transports/httpparser.h +new file mode 100644 +index 0000000000000000000000000000000000000000..1fe0dcf640692d4b47c47eeda4f50c093900970e +--- /dev/null ++++ b/src/libgit2/transports/httpparser.h +@@ -0,0 +1,99 @@ ++/* ++ * Copyright (C) the libgit2 contributors. All rights reserved. ++ * ++ * This file is part of libgit2, distributed under the GNU GPL v2 with ++ * a Linking Exception. For full terms see the included COPYING file. ++ */ ++ ++#ifndef INCLUDE_transports_httpparser_h__ ++#define INCLUDE_transports_httpparser_h__ ++ ++#include "git2_util.h" ++ ++#if defined(GIT_HTTPPARSER_HTTPPARSER) ++ ++# include ++ ++typedef enum { ++ GIT_HTTP_PARSER_OK = HPE_OK, ++ GIT_HTTP_PARSER_PAUSED = HPE_PAUSED, ++} git_http_parser_error_t; ++ ++typedef enum { ++ GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST, ++ GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE, ++} git_http_parser_t; ++ ++typedef struct git_http_parser git_http_parser; ++ ++typedef struct { ++ int (*on_message_begin)(git_http_parser *); ++ int (*on_url)(git_http_parser *, const char *, size_t); ++ int (*on_header_field)(git_http_parser *, const char *, size_t); ++ int (*on_header_value)(git_http_parser *, const char *, size_t); ++ int (*on_headers_complete)(git_http_parser *); ++ int (*on_body)(git_http_parser *, const char *, size_t); ++ int (*on_message_complete)(git_http_parser *); ++} git_http_parser_settings; ++ ++struct git_http_parser { ++ http_parser parser; ++ git_http_parser_settings settings; ++ void *data; ++}; ++ ++void git_http_parser_init( ++ git_http_parser *parser, ++ git_http_parser_t type, ++ git_http_parser_settings *settings); ++ ++size_t git_http_parser_execute( ++ git_http_parser *parser, ++ const char *data, ++ size_t len); ++ ++# define git_http_parser_status_code(parser) parser->parser.status_code ++# define git_http_parser_keep_alive(parser) http_should_keep_alive(&parser->parser) ++# define git_http_parser_pause(parser) (http_parser_pause(&parser->parser, 1), 0) ++# define git_http_parser_resume(parser) http_parser_pause(&parser->parser, 0) ++# define git_http_parser_remain_after_pause(parser) 1 ++# define git_http_parser_errno(parser) parser->parser.http_errno ++# define git_http_parser_errmsg(parser, errno) http_errno_description(errno) ++ ++#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN) ++ ++# include ++ ++typedef enum { ++ GIT_HTTP_PARSER_OK = HPE_OK, ++ GIT_HTTP_PARSER_PAUSED = HPE_PAUSED, ++} git_http_parser_error_t; ++ ++typedef enum { ++ GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST, ++ GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE, ++} git_http_parser_t; ++ ++typedef llhttp_t git_http_parser; ++typedef llhttp_settings_t git_http_parser_settings; ++ ++# define git_http_parser_init(parser, direction, settings) llhttp_init(parser, (llhttp_type_t)direction, settings) ++ ++size_t git_http_parser_execute( ++ git_http_parser *parser, ++ const char *data, ++ size_t len); ++ ++# define git_http_parser_status_code(parser) parser->status_code ++# define git_http_parser_keep_alive(parser) llhttp_should_keep_alive(parser) ++# define git_http_parser_pause(parser) (llhttp_pause(parser), GIT_HTTP_PARSER_PAUSED) ++# define git_http_parser_resume(parser) llhttp_resume(parser) ++# define git_http_parser_remain_after_pause(parser) 0 ++# define git_http_parser_errno(parser) parser->error ++# define git_http_parser_errmsg(parser, errno) llhttp_get_error_reason(parser) ++ ++#else ++# error unknown http-parser ++#endif ++ ++#endif +diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in +index a84ea89563515d9fa7d21a8d593ad1325a298038..f00c36b03cd4fb1ea98942fee111457b38d9facb 100644 +--- a/src/util/git2_features.h.in ++++ b/src/util/git2_features.h.in +@@ -44,6 +44,10 @@ + #cmakedefine GIT_MBEDTLS 1 + #cmakedefine GIT_SCHANNEL 1 + ++#cmakedefine GIT_HTTPPARSER_HTTPPARSER 1 ++#cmakedefine GIT_HTTPPARSER_LLHTTP 1 ++#cmakedefine GIT_HTTPPARSER_BUILTIN 1 ++ + #cmakedefine GIT_SHA1_COLLISIONDETECT 1 + #cmakedefine GIT_SHA1_WIN32 1 + #cmakedefine GIT_SHA1_COMMON_CRYPTO 1 +diff --git a/src/util/net.c b/src/util/net.c +index afd52ce0830dfe4e4768485d2884dfaf7b3ea4a6..1d0c4bebdcb819bc720eb2dc5a9d0894a6549946 100644 +--- a/src/util/net.c ++++ b/src/util/net.c +@@ -11,7 +11,6 @@ + + #include "posix.h" + #include "str.h" +-#include "http_parser.h" + #include "runtime.h" + + #define DEFAULT_PORT_HTTP "80" +-- +2.44.0 + diff --git a/0001-checkout-Fix-removing-untracked-files-by-path-in-sub.patch b/0001-checkout-Fix-removing-untracked-files-by-path-in-sub.patch deleted file mode 100644 index 652da3d..0000000 --- a/0001-checkout-Fix-removing-untracked-files-by-path-in-sub.patch +++ /dev/null @@ -1,76 +0,0 @@ -From d62e44cb8218840a0291fb5fbb7c5106e1e35a12 Mon Sep 17 00:00:00 2001 -From: Segev Finer -Date: Mon, 3 Jun 2019 18:35:08 +0300 -Subject: [PATCH] checkout: Fix removing untracked files by path in - subdirectories - -The checkout code didn't iterate into a subdir if it didn't match the -pathspec, but since the pathspec might match files in the subdir we -should recurse into it (In contrast to gitignore handling). - -Fixes #5089 ---- - src/checkout.c | 9 +++++++-- - tests/checkout/head.c | 26 ++++++++++++++++++++++++++ - 2 files changed, 33 insertions(+), 2 deletions(-) - -diff --git a/src/checkout.c b/src/checkout.c -index f0dd736dc..59ff873dd 100644 ---- a/src/checkout.c -+++ b/src/checkout.c -@@ -371,8 +371,13 @@ static int checkout_action_wd_only( - if (!git_pathspec__match( - pathspec, wd->path, - (data->strategy & GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH) != 0, -- git_iterator_ignore_case(workdir), NULL, NULL)) -- return git_iterator_advance(wditem, workdir); -+ git_iterator_ignore_case(workdir), NULL, NULL)) { -+ -+ if (wd->mode == GIT_FILEMODE_TREE) -+ return git_iterator_advance_into(wditem, workdir); -+ else -+ return git_iterator_advance(wditem, workdir); -+ } - - /* check if item is tracked in the index but not in the checkout diff */ - if (data->index != NULL) { -diff --git a/tests/checkout/head.c b/tests/checkout/head.c -index 799123086..5b3a034e7 100644 ---- a/tests/checkout/head.c -+++ b/tests/checkout/head.c -@@ -109,6 +109,32 @@ void test_checkout_head__do_not_remove_untracked_file_in_subdir(void) - cl_assert(git_path_isfile("testrepo/tracked/subdir/untracked")); - } - -+void test_checkout_head__do_remove_untracked_paths(void) -+{ -+ git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; -+ git_index *index; -+ char *paths[] = {"tracked/untracked"}; -+ -+ cl_git_pass(p_mkdir("testrepo/tracked", 0755)); -+ cl_git_pass(p_mkdir("testrepo/tracked/subdir", 0755)); -+ cl_git_mkfile("testrepo/tracked/tracked", "tracked\n"); -+ cl_git_mkfile("testrepo/tracked/untracked", "untracked\n"); -+ -+ cl_git_pass(git_repository_index(&index, g_repo)); -+ cl_git_pass(git_index_add_bypath(index, "tracked/tracked")); -+ cl_git_pass(git_index_write(index)); -+ -+ git_index_free(index); -+ -+ opts.checkout_strategy = GIT_CHECKOUT_FORCE | GIT_CHECKOUT_REMOVE_UNTRACKED; -+ opts.paths.strings = paths; -+ opts.paths.count = 1; -+ cl_git_pass(git_checkout_head(g_repo, &opts)); -+ -+ cl_assert(git_path_isfile("testrepo/tracked/tracked")); -+ cl_assert(!git_path_isfile("testrepo/tracked/untracked")); -+} -+ - void test_checkout_head__do_remove_tracked_subdir(void) - { - git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; --- -2.27.0 - diff --git a/libgit2.spec b/libgit2.spec index c588570..a0c3ba5 100644 --- a/libgit2.spec +++ b/libgit2.spec @@ -1,22 +1,40 @@ +# libssh2 is not available on RHEL +%if 0%{?rhel} +%bcond_with libssh2 +%else +%bcond_without libssh2 +%endif + Name: libgit2 -Version: 1.1.0 -Release: 3%{?dist} +Version: 1.7.2 +Release: %autorelease Summary: C implementation of the Git core methods as a library with a solid API License: GPLv2 with exceptions URL: https://libgit2.org/ -Source0: https://github.com/libgit2/libgit2/archive/v%{version}/%{name}-%{version}.tar.gz +Source0: https://github.com/libgit2/libgit2/archive/refs/tags/v%{version}.tar.gz#/libgit2-%{version}.tar.gz + +# Patches +# Backported patch from https://github.com/libgit2/libgit2/pull/6713 +Patch: 0001-Replace-http-parser-with-llhttp.patch BuildRequires: gcc BuildRequires: cmake >= 3.5.1 BuildRequires: ninja-build -BuildRequires: http-parser-devel +BuildRequires: llhttp-devel +BuildRequires: krb5-devel BuildRequires: libcurl-devel +%if %{with libssh2} BuildRequires: libssh2-devel +%endif BuildRequires: openssl-devel BuildRequires: pcre2-devel BuildRequires: python3 BuildRequires: zlib-devel Provides: bundled(libxdiff) +%if 0%{?fedora} >= 38 +Obsoletes: libgit2_1.3 < 1.3.2-3 +Obsoletes: libgit2_1.4 < 1.4.6-3 +%endif %description libgit2 is a portable, pure C implementation of the Git core methods @@ -27,44 +45,65 @@ with bindings. %package devel Summary: Development files for %{name} Requires: %{name}%{?_isa} = %{?epoch:%{epoch}:}%{version}-%{release} +%if 0%{?fedora} >= 38 +Obsoletes: libgit2_1.3-devel < 1.3.2-3 +Obsoletes: libgit2_1.4-devel < 1.4.6-3 +%endif %description devel This package contains libraries and header files for developing applications that use %{name}. %prep -%autosetup -p1 +%autosetup -p1 -n libgit2-%{version} # Remove VCS files from examples find examples -name ".gitignore" -delete -print # Don't run "online" tests -sed -i '/-sonline/s/^/#/' tests/CMakeLists.txt +sed -i '/-sonline/s/^/#/' tests/libgit2/CMakeLists.txt -# Remove bundled libraries -rm -vr deps +%if 0%{?fedora} >= 40 || 0%{?rhel} >= 10 +# On Fedora 40+ and RHEL 10+, we're using zlib-ng rather than +# zlib for compression. As a result, all of the pack tests fail +# due to checking the hashes of the packed data against static +# values that were created with zlib. +# https://github.com/libgit2/libgit2/issues/6728 +sed -i 's/-xonline/-xonline -xpack/' tests/libgit2/CMakeLists.txt +%endif + +# Remove bundled libraries (except libxdiff) +pushd deps +find . -maxdepth 1 -not -name xdiff -exec rm -rf {} ';' +popd %build -%cmake . -B%{_target_platform} \ +%cmake \ -GNinja \ -DCMAKE_BUILD_TYPE=RelWithDebInfo \ -DREGEX_BACKEND=pcre2 \ - -DUSE_HTTP_PARSER=system \ + -DBUILD_CLI=OFF \ + -DUSE_HTTP_PARSER=llhttp \ -DUSE_SHA1=HTTPS \ -DUSE_HTTPS=OpenSSL \ -DUSE_NTLMCLIENT=OFF \ +%if %{with libssh2} + -DUSE_SSH=ON \ +%else + -DUSE_SSH=OFF \ +%endif %{nil} -%ninja_build -C %{_target_platform} +%cmake_build %install -%ninja_install -C %{_target_platform} +%cmake_install %check -%ninja_test -C %{_target_platform} +%ctest %files %license COPYING -%{_libdir}/libgit2.so.* +%{_libdir}/libgit2.so.1.7* %files devel %doc AUTHORS docs examples README.md @@ -74,223 +113,4 @@ rm -vr deps %{_includedir}/git2/ %changelog -* Tue Jan 26 2021 Fedora Release Engineering - 1.1.0-3 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild - -* Mon Dec 28 2020 Igor Raits - 1.1.0-2 -- Rebuild - -* Mon Dec 28 2020 Igor Raits - 1.1.0-1 -- Update to 1.1.0 - -* Tue Jul 28 2020 Fedora Release Engineering - 1.0.1-3 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild - -* Mon Jun 15 2020 Igor Raits - 1.0.1-2 -- Fix removing untracked files by path in subdirectories - -* Thu Jun 04 2020 Pete Walter - 1.0.1-1 -- Update to 1.0.1 - -* Wed Apr 15 2020 Igor Raits - 1.0.0-2 -- Rebuild for http-parser 2.9.4 - -* Wed Apr 15 2020 Igor Raits - 1.0.0-1 -- Update to 1.0.0 - -* Tue Mar 03 2020 Igor Raits - 0.99.0-2 -- Fix broken deps for pcre2 - -* Mon Mar 02 2020 Igor Raits - 0.99.0-1 -- Update to 0.99.0 - -* Wed Jan 29 2020 Fedora Release Engineering - 0.28.4-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild - -* Wed Dec 11 09:00:52 CET 2019 Igor Gnatenko - 0.28.4-1 -- Update to 0.28.4 - -* Fri Sep 13 2019 Pete Walter - 0.28.3-1 -- Update to 0.28.3 - -* Thu Jul 25 2019 Fedora Release Engineering - 0.28.2-3 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild - -* Sun Jul 14 13:34:04 CEST 2019 Igor Gnatenko - 0.28.2-2 -- Obsolete libgit2_0.28 - -* Thu Jun 06 14:22:16 CEST 2019 Igor Gnatenko - 0.28.2-1 -- Update to 0.28.2 - -* Fri Feb 01 2019 Fedora Release Engineering - 0.27.8-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild - -* Mon Jan 28 2019 Pete Walter - 0.27.8-1 -- Update to 0.27.8 - -* Fri Oct 26 2018 Pete Walter - 0.27.7-1 -- Update to 0.27.7 - -* Mon Oct 08 2018 Pete Walter - 0.27.5-1 -- Update to 0.27.5 - -* Fri Aug 10 2018 Igor Gnatenko - 0.27.4-1 -- Update to 0.27.4 -- Update upstream URL - -* Tue Aug 07 2018 Pete Walter - 0.26.6-1 -- Update to 0.26.6 - -* Fri Jul 13 2018 Fedora Release Engineering - 0.26.5-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild - -* Tue Jul 10 2018 Pete Walter - 0.26.5-1 -- Update to 0.26.5 (CVE-2018-10887, CVE-2018-10888) - -* Mon Jun 25 2018 Pete Walter - 0.26.4-1 -- Update to 0.26.4 (CVE-2018-11235) - -* Mon Mar 12 2018 Igor Gnatenko - 0.26.3-1 -- Update to 0.26.3 - -* Wed Feb 07 2018 Fedora Release Engineering - 0.26.0-5 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild - -* Fri Feb 02 2018 Igor Gnatenko - 0.26.0-4 -- Switch to %%ldconfig_scriptlets - -* Thu Aug 03 2017 Fedora Release Engineering - 0.26.0-3 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild - -* Wed Jul 26 2017 Fedora Release Engineering - 0.26.0-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild - -* Sat Jul 08 2017 Igor Gnatenko - 0.26.0-1 -- Update to 0.26.0 - -* Tue Feb 07 2017 Igor Gnatenko - 0.25.1-3 -- Backport patch to fix pkgconfig file under g-ir-scanner - -* Tue Feb 07 2017 Igor Gnatenko - 0.25.1-2 -- Bump release for rebuild - -* Tue Feb 07 2017 Igor Gnatenko - 0.25.1-1 -- Update to 0.25.1 (RHBZ #1395926) - -* Tue Jan 10 2017 Igor Gnatenko - 0.24.6-1 -- Update to 0.24.6 (RHBZ #1411857) - -* Thu Nov 03 2016 Igor Gnatenko - 0.24.3-1 -- Update to 0.24.3 (RHBZ #1391480) -- Add support for OpenSSL 1.1.0 (RHBZ #1383753) - -* Mon Oct 10 2016 Igor Gnatenko - 0.24.2-2 -- Backport patch for CVE-2016-8568, CVE-2016-8569 - -* Tue Oct 04 2016 Igor Gnatenko - 0.24.2-1 -- Update to 0.24.2 (RHBZ #1381398) - -* Wed Apr 13 2016 Igor Gnatenko - 0.24.1-1 -- Update to 0.24.1 - -* Sun Mar 20 2016 Igor Gnatenko - 0.24.0-1 -- Update to 0.24.0 (RHBZ #1310638) - -* Thu Feb 04 2016 Fedora Release Engineering - 0.23.4-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild - -* Sun Nov 22 2015 Igor Gnatenko - 0.23.4-1 -- Update to 0.23.4 (RHBZ #1281633) - -* Tue Oct 06 2015 Igor Gnatenko - 0.23.3-1 -- Update to 0.23.3 (RHBZ #1260324) - -* Tue Sep 08 2015 Igor Gnatenko - 0.23.2-1 -- Update to 0.23.2 - -* Wed Sep 02 2015 Veeti Paananen - 0.23.1-1 -- Update to 0.23.1 -- Add curl support - -* Thu Jul 30 2015 Igor Gnatenko - 0.23.0-1 -- Update to 0.23.0 - -* Fri Jul 03 2015 Veeti Paananen - 0.22.3-1 -- Update to 0.22.3 - -* Wed Jun 17 2015 Fedora Release Engineering - 0.22.2-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild - -* Tue Mar 24 2015 Veeti Paananen - 0.22.2-1 -- Update to 0.22.2 - -* Sat Feb 14 2015 Veeti Paananen - 0.22.1-1 -- Update to 0.22.1 - -* Mon Jan 19 2015 Ignacio Casal Quinteiro - 0.22.0-1 -- Update to 0.22.0 - -* Fri Dec 26 2014 Veeti Paananen - 0.21.3-1 -- Update to 0.21.3 - -* Sun Aug 17 2014 Fedora Release Engineering - 0.21.1-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild - -* Wed Aug 06 2014 Christopher Meng - 0.21.1-1 -- Update to 0.21.1 - -* Fri Jul 18 2014 Yaakov Selkowitz - 0.21.0-2 -- Fix memory alignment issues on arm, aarch64, ppc64le (#1115905) - -* Sat Jun 21 2014 Christopher Meng - 0.21.0-1 -- Update to 0.21.0 - -* Fri Jun 06 2014 Karsten Hopp 0.20.0-4 -- temporarily disable checks on ppc64 and s390x (Bugzilla 1105552) - -* Thu Mar 27 2014 Mathieu Bridon - 0.20.0-3 -- Fix build requirement on libssh2-devel. (RHBZ#1039433) - -* Tue Mar 25 2014 Mathieu Bridon - 0.20.0-2 -- Build with the bundled xdiff. -- Disable a failing test. (libgit2#2199) -- Add missing build requirement on libssh2. (RHBZ#1039433) -- Build a thread-safe libgit2. - -* Sun Nov 24 2013 Ignacio Casal Quinteiro - 0.20.0-1 -- 0.20.0 - -* Sat Aug 03 2013 Fedora Release Engineering - 0.19.0-2 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild - -* Tue Jun 25 2013 Veeti Paananen - 0.19.0-1 -- 0.19.0 - -* Wed Jun 19 2013 Dan Horák - 0.18.0-5 -- Add htonl() and friends declarations on non-x86 arches -- Rebuilt with fixed libxdiff for big endian arches - -* Thu May 30 2013 Veeti Paananen - 0.18.0-4 -- Update the http-parser patch -- Skip tests that require network connectivity - -* Thu May 30 2013 Tom Callaway - 0.18.0-3 -- use system libxdiff instead of bundled copy - -* Fri May 24 2013 Veeti Paananen - 0.18.0-2 -- Remove unnecessary CMake build flags -- Fix the pkgconfig file - -* Thu May 02 2013 Veeti Paananen - 0.18.0-1 -- Update to version 0.18.0 -- Unbundle the http-parser library - -* Fri Oct 19 2012 Veeti Paananen - 0.17.0-2 -- Use make for building and installation -- Specify minimum CMake version -- Remove useless OpenSSL build dependency -- Move development documentation to the -devel package -- Add code examples to the -devel package - -* Thu Oct 18 2012 Veeti Paananen - 0.17.0-1 -- Initial package. +%autochangelog diff --git a/sources b/sources index 4534625..9f980ae 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (libgit2-1.1.0.tar.gz) = 347bb68900181b44fa58a0417506c91383adb965607fce049a5b4c57ac9cc286e0a140d164c339b50fb6cd6951f47757c2917a2df44ba004bfaa4fb643946bb8 +SHA512 (libgit2-1.7.2.tar.gz) = 825737e4a1991fba50ea535f15b0e560ebe76ead752e04aeba36925b944d0da77fe9826a70980a1aa3d0bf9afbedfab79dd92e799c9252931384c89ebec9b012