Crow  1.1
A C++ microframework for the web
http_parser_merged.h
1 /* merged revision: 5b951d74bd66ec9d38448e0a85b1cf8b85d97db3 */
2 /* updated to : e13b274770da9b82a1085dec29182acfea72e7a7 (beyond v2.9.5) */
3 /* commits not included:
4  * 091ebb87783a58b249062540bbea07de2a11e9cf
5  * 6132d1fefa03f769a3979355d1f5da0b8889cad2
6  * 7ba312397c2a6c851a4b5efe6c1603b1e1bda6ff
7  * d7675453a6c03180572f084e95eea0d02df39164
8  * dff604db203986e532e5a679bafd0e7382c6bdd9 (Might be useful to actually add [upgrade requests with a body])
9  * e01811e7f4894d7f0f7f4bd8492cccec6f6b4038 (related to above)
10  * 05525c5fde1fc562481f6ae08fa7056185325daf (also related to above)
11  * 350258965909f249f9c59823aac240313e0d0120 (cannot be implemented due to upgrade)
12  */
13 
14 // clang-format off
15 #pragma once
16 extern "C" {
17 #include <stddef.h>
18 #if defined(_WIN32) && !defined(__MINGW32__) && \
19  (!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__)
20 #include <BaseTsd.h>
21 typedef __int8 int8_t;
22 typedef unsigned __int8 uint8_t;
23 typedef __int16 int16_t;
24 typedef unsigned __int16 uint16_t;
25 typedef __int32 int32_t;
26 typedef unsigned __int32 uint32_t;
27 typedef __int64 int64_t;
28 typedef unsigned __int64 uint64_t;
29 #elif (defined(__sun) || defined(__sun__)) && defined(__SunOS_5_9)
30 #include <sys/inttypes.h>
31 #else
32 #include <stdint.h>
33 #endif
34 #include <assert.h>
35 #include <ctype.h>
36 #include <string.h>
37 #include <limits.h>
38 }
39 
40 #include "crow/common.h"
41 namespace crow
42 {
43 /* Maximium header size allowed. If the macro is not defined
44  * before including this header then the default is used. To
45  * change the maximum header size, define the macro in the build
46  * environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
47  * the effective limit on the size of the header, define the macro
48  * to a very large number (e.g. -DCROW_HTTP_MAX_HEADER_SIZE=0x7fffffff)
49  */
50 #ifndef CROW_HTTP_MAX_HEADER_SIZE
51 # define CROW_HTTP_MAX_HEADER_SIZE (80*1024)
52 #endif
53 
54 typedef struct http_parser http_parser;
55 typedef struct http_parser_settings http_parser_settings;
56 
57 /* Callbacks should return non-zero to indicate an error. The parser will
58  * then halt execution.
59  *
60  * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
61  * returning '1' from on_headers_complete will tell the parser that it
62  * should not expect a body. This is used when receiving a response to a
63  * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
64  * chunked' headers that indicate the presence of a body.
65  *
66  * Returning `2` from on_headers_complete will tell parser that it should not
67  * expect neither a body nor any futher responses on this connection. This is
68  * useful for handling responses to a CONNECT request which may not contain
69  * `Upgrade` or `Connection: upgrade` headers.
70  *
71  * http_data_cb does not return data chunks. It will be called arbitrarally
72  * many times for each string. E.G. you might get 10 callbacks for "on_url"
73  * each providing just a few characters more data.
74  */
75 typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
76 typedef int (*http_cb) (http_parser*);
77 
78 
79 /* Flag values for http_parser.flags field */
80 enum http_connection_flags // This is basically 7 booleans placed into 1 integer. Uses 4 bytes instead of n bytes (7 currently).
81  { F_CHUNKED = 1 << 0 // 00000000 00000000 00000000 00000001
82  , F_CONNECTION_KEEP_ALIVE = 1 << 1 // 00000000 00000000 00000000 00000010
83  , F_CONNECTION_CLOSE = 1 << 2 // 00000000 00000000 00000000 00000100
84  , F_TRAILING = 1 << 3 // 00000000 00000000 00000000 00001000
85  , F_UPGRADE = 1 << 4 // 00000000 00000000 00000000 00010000
86  , F_SKIPBODY = 1 << 5 // 00000000 00000000 00000000 00100000
87  , F_CONTENTLENGTH = 1 << 6 // 00000000 00000000 00000000 01000000
88  };
89 
90 
91 /* Map for errno-related constants
92  *
93  * The provided argument should be a macro that takes 2 arguments.
94  */
95 #define CROW_HTTP_ERRNO_MAP(CROW_XX) \
96  /* No error */ \
97  CROW_XX(OK, "success") \
98  \
99  /* Callback-related errors */ \
100  CROW_XX(CB_message_begin, "the on_message_begin callback failed") \
101  CROW_XX(CB_method, "the on_method callback failed") \
102  CROW_XX(CB_url, "the \"on_url\" callback failed") \
103  CROW_XX(CB_header_field, "the \"on_header_field\" callback failed") \
104  CROW_XX(CB_header_value, "the \"on_header_value\" callback failed") \
105  CROW_XX(CB_headers_complete, "the \"on_headers_complete\" callback failed") \
106  CROW_XX(CB_body, "the \"on_body\" callback failed") \
107  CROW_XX(CB_message_complete, "the \"on_message_complete\" callback failed") \
108  CROW_XX(CB_status, "the \"on_status\" callback failed") \
109  \
110  /* Parsing-related errors */ \
111  CROW_XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
112  CROW_XX(HEADER_OVERFLOW, "too many header bytes seen; overflow detected") \
113  CROW_XX(CLOSED_CONNECTION, "data received after completed connection: close message") \
114  CROW_XX(INVALID_VERSION, "invalid HTTP version") \
115  CROW_XX(INVALID_STATUS, "invalid HTTP status code") \
116  CROW_XX(INVALID_METHOD, "invalid HTTP method") \
117  CROW_XX(INVALID_URL, "invalid URL") \
118  CROW_XX(INVALID_HOST, "invalid host") \
119  CROW_XX(INVALID_PORT, "invalid port") \
120  CROW_XX(INVALID_PATH, "invalid path") \
121  CROW_XX(INVALID_QUERY_STRING, "invalid query string") \
122  CROW_XX(INVALID_FRAGMENT, "invalid fragment") \
123  CROW_XX(LF_EXPECTED, "LF character expected") \
124  CROW_XX(INVALID_HEADER_TOKEN, "invalid character in header") \
125  CROW_XX(INVALID_CONTENT_LENGTH, "invalid character in content-length header") \
126  CROW_XX(UNEXPECTED_CONTENT_LENGTH, "unexpected content-length header") \
127  CROW_XX(INVALID_CHUNK_SIZE, "invalid character in chunk size header") \
128  CROW_XX(INVALID_CONSTANT, "invalid constant string") \
129  CROW_XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state") \
130  CROW_XX(STRICT, "strict mode assertion failed") \
131  CROW_XX(UNKNOWN, "an unknown error occurred") \
132  CROW_XX(INVALID_TRANSFER_ENCODING, "request has invalid transfer-encoding") \
133 
134 
135 /* Define CHPE_* values for each errno value above */
136 #define CROW_HTTP_ERRNO_GEN(n, s) CHPE_##n,
137 enum http_errno {
138  CROW_HTTP_ERRNO_MAP(CROW_HTTP_ERRNO_GEN)
139 };
140 #undef CROW_HTTP_ERRNO_GEN
141 
142 
143 /* Get an http_errno value from an http_parser */
144 #define CROW_HTTP_PARSER_ERRNO(p) ((enum http_errno)(p)->http_errno)
145 
146 
147  struct http_parser
148  {
149  /** PRIVATE **/
150  unsigned int flags : 7; /* F_* values from 'flags' enum; semi-public */
151  unsigned int state : 8; /* enum state from http_parser.c */
152  unsigned int header_state : 7; /* enum header_state from http_parser.c */
153  unsigned int index : 5; /* index into current matcher */
154  unsigned int uses_transfer_encoding : 1; /* Transfer-Encoding header is present */
155  unsigned int allow_chunked_length : 1; /* Allow headers with both `Content-Length` and `Transfer-Encoding: chunked` set */
156  unsigned int lenient_http_headers : 1;
157 
158  uint32_t nread; /* # bytes read in various scenarios */
159  uint64_t content_length; /* # bytes in body. `(uint64_t) -1` (all bits one) if no Content-Length header. */
160  unsigned long qs_point;
161 
162  /** READ-ONLY **/
163  unsigned char http_major;
164  unsigned char http_minor;
165  unsigned int method : 8; /* requests only */
166  unsigned int http_errno : 7;
167 
168  /* 1 = Upgrade header was present and the parser has exited because of that.
169  * 0 = No upgrade header present.
170  * Should be checked when http_parser_execute() returns in addition to
171  * error checking.
172  */
173  unsigned int upgrade : 1;
174 
175  /** PUBLIC **/
176  void* data; /* A pointer to get hook to the "connection" or "socket" object */
177  };
178 
179 
180  struct http_parser_settings
181  {
182  http_cb on_message_begin;
183  http_cb on_method;
184  http_data_cb on_url;
185  http_data_cb on_header_field;
186  http_data_cb on_header_value;
187  http_cb on_headers_complete;
188  http_data_cb on_body;
189  http_cb on_message_complete;
190  };
191 
192 
193 
194 // SOURCE (.c) CODE
195 static uint32_t max_header_size = CROW_HTTP_MAX_HEADER_SIZE;
196 
197 #ifndef CROW_ULLONG_MAX
198 # define CROW_ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */
199 #endif
200 
201 #ifndef CROW_MIN
202 # define CROW_MIN(a,b) ((a) < (b) ? (a) : (b))
203 #endif
204 
205 #ifndef CROW_ARRAY_SIZE
206 # define CROW_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
207 #endif
208 
209 #ifndef CROW_BIT_AT
210 # define CROW_BIT_AT(a, i) \
211  (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \
212  (1 << ((unsigned int) (i) & 7))))
213 #endif
214 
215 #define CROW_SET_ERRNO(e) \
216 do { \
217  parser->nread = nread; \
218  parser->http_errno = (e); \
219 } while(0)
220 
221 /* Run the notify callback FOR, returning ER if it fails */
222 #define CROW_CALLBACK_NOTIFY_(FOR, ER) \
223 do { \
224  assert(CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK); \
225  \
226  if (CROW_LIKELY(settings->on_##FOR)) { \
227  if (CROW_UNLIKELY(0 != settings->on_##FOR(parser))) { \
228  CROW_SET_ERRNO(CHPE_CB_##FOR); \
229  } \
230  \
231  /* We either errored above or got paused; get out */ \
232  if (CROW_UNLIKELY(CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK)) { \
233  return (ER); \
234  } \
235  } \
236 } while (0)
237 
238 /* Run the notify callback FOR and consume the current byte */
239 #define CROW_CALLBACK_NOTIFY(FOR) CROW_CALLBACK_NOTIFY_(FOR, p - data + 1)
240 
241 /* Run the notify callback FOR and don't consume the current byte */
242 #define CROW_CALLBACK_NOTIFY_NOADVANCE(FOR) CROW_CALLBACK_NOTIFY_(FOR, p - data)
243 
244 /* Run data callback FOR with LEN bytes, returning ER if it fails */
245 #define CROW_CALLBACK_DATA_(FOR, LEN, ER) \
246 do { \
247  assert(CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK); \
248  \
249  if (FOR##_mark) { \
250  if (CROW_LIKELY(settings->on_##FOR)) { \
251  if (CROW_UNLIKELY(0 != \
252  settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \
253  CROW_SET_ERRNO(CHPE_CB_##FOR); \
254  } \
255  \
256  /* We either errored above or got paused; get out */ \
257  if (CROW_UNLIKELY(CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK)) {\
258  return (ER); \
259  } \
260  } \
261  FOR##_mark = NULL; \
262  } \
263 } while (0)
264 
265 /* Run the data callback FOR and consume the current byte */
266 #define CROW_CALLBACK_DATA(FOR) \
267  CROW_CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)
268 
269 /* Run the data callback FOR and don't consume the current byte */
270 #define CROW_CALLBACK_DATA_NOADVANCE(FOR) \
271  CROW_CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)
272 
273 /* Set the mark FOR; non-destructive if mark is already set */
274 #define CROW_MARK(FOR) \
275 do { \
276  if (!FOR##_mark) { \
277  FOR##_mark = p; \
278  } \
279 } while (0)
280 
281 /* Don't allow the total size of the HTTP headers (including the status
282  * line) to exceed max_header_size. This check is here to protect
283  * embedders against denial-of-service attacks where the attacker feeds
284  * us a never-ending header that the embedder keeps buffering.
285  *
286  * This check is arguably the responsibility of embedders but we're doing
287  * it on the embedder's behalf because most won't bother and this way we
288  * make the web a little safer. max_header_size is still far bigger
289  * than any reasonable request or response so this should never affect
290  * day-to-day operation.
291  */
292 #define CROW_COUNT_HEADER_SIZE(V) \
293 do { \
294  nread += (uint32_t)(V); \
295  if (CROW_UNLIKELY(nread > max_header_size)) { \
296  CROW_SET_ERRNO(CHPE_HEADER_OVERFLOW); \
297  goto error; \
298  } \
299 } while (0)
300 #define CROW_REEXECUTE() \
301  goto reexecute; \
302 
303 #define CROW_PROXY_CONNECTION "proxy-connection"
304 #define CROW_CONNECTION "connection"
305 #define CROW_CONTENT_LENGTH "content-length"
306 #define CROW_TRANSFER_ENCODING "transfer-encoding"
307 #define CROW_UPGRADE "upgrade"
308 #define CROW_CHUNKED "chunked"
309 #define CROW_KEEP_ALIVE "keep-alive"
310 #define CROW_CLOSE "close"
311 
312 
313 
314  enum state
315  {
316  s_dead = 1 /* important that this is > 0 */
317 
318  ,
319  s_start_req
320 
321  ,
322  s_req_method,
323  s_req_spaces_before_url,
324  s_req_schema,
325  s_req_schema_slash,
326  s_req_schema_slash_slash,
327  s_req_server_start,
328  s_req_server, // }
329  s_req_server_with_at, // |
330  s_req_path, // | The parser recognizes how to switch between these states,
331  s_req_query_string_start, // | however it doesn't process them any differently.
332  s_req_query_string, // }
333  s_req_http_start,
334  s_req_http_H,
335  s_req_http_HT,
336  s_req_http_HTT,
337  s_req_http_HTTP,
338  s_req_http_I,
339  s_req_http_IC,
340  s_req_http_major,
341  s_req_http_dot,
342  s_req_http_minor,
343  s_req_http_end,
344  s_req_line_almost_done
345 
346  ,
347  s_header_field_start,
348  s_header_field,
349  s_header_value_discard_ws,
350  s_header_value_discard_ws_almost_done,
351  s_header_value_discard_lws,
352  s_header_value_start,
353  s_header_value,
354  s_header_value_lws
355 
356  ,
357  s_header_almost_done
358 
359  ,
360  s_chunk_size_start,
361  s_chunk_size,
362  s_chunk_parameters,
363  s_chunk_size_almost_done
364 
365  ,
366  s_headers_almost_done,
367  s_headers_done
368 
369  /* Important: 's_headers_done' must be the last 'header' state. All
370  * states beyond this must be 'body' states. It is used for overflow
371  * checking. See the CROW_PARSING_HEADER() macro.
372  */
373 
374  ,
375  s_chunk_data,
376  s_chunk_data_almost_done,
377  s_chunk_data_done
378 
379  ,
380  s_body_identity,
381  s_body_identity_eof
382 
383  ,
384  s_message_done
385  };
386 
387 
388 #define CROW_PARSING_HEADER(state) (state <= s_headers_done)
389 
390 
391 enum header_states
392  { h_general = 0
393  , h_C
394  , h_CO
395  , h_CON
396 
397  , h_matching_connection
398  , h_matching_proxy_connection
399  , h_matching_content_length
400  , h_matching_transfer_encoding
401  , h_matching_upgrade
402 
403  , h_connection
404  , h_content_length
405  , h_content_length_num
406  , h_content_length_ws
407  , h_transfer_encoding
408  , h_upgrade
409 
410  , h_matching_transfer_encoding_token_start
411  , h_matching_transfer_encoding_chunked
412  , h_matching_transfer_encoding_token
413 
414  , h_matching_connection_keep_alive
415  , h_matching_connection_close
416 
417  , h_transfer_encoding_chunked
418  , h_connection_keep_alive
419  , h_connection_close
420  };
421 
422 enum http_host_state
423  {
424  s_http_host_dead = 1
425  , s_http_userinfo_start
426  , s_http_userinfo
427  , s_http_host_start
428  , s_http_host_v6_start
429  , s_http_host
430  , s_http_host_v6
431  , s_http_host_v6_end
432  , s_http_host_v6_zone_start
433  , s_http_host_v6_zone
434  , s_http_host_port_start
435  , s_http_host_port
436 };
437 
438 /* Macros for character classes; depends on strict-mode */
439 #define CROW_LOWER(c) (unsigned char)(c | 0x20)
440 #define CROW_IS_ALPHA(c) (CROW_LOWER(c) >= 'a' && CROW_LOWER(c) <= 'z')
441 #define CROW_IS_NUM(c) ((c) >= '0' && (c) <= '9')
442 #define CROW_IS_ALPHANUM(c) (CROW_IS_ALPHA(c) || CROW_IS_NUM(c))
443 //#define CROW_IS_HEX(c) (CROW_IS_NUM(c) || (CROW_LOWER(c) >= 'a' && CROW_LOWER(c) <= 'f'))
444 #define CROW_IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \
445  (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \
446  (c) == ')')
447 #define CROW_IS_USERINFO_CHAR(c) (CROW_IS_ALPHANUM(c) || CROW_IS_MARK(c) || (c) == '%' || \
448  (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \
449  (c) == '$' || (c) == ',')
450 
451 #define CROW_TOKEN(c) (tokens[(unsigned char)c])
452 #define CROW_IS_URL_CHAR(c) (CROW_BIT_AT(normal_url_char, (unsigned char)c))
453 //#define CROW_IS_HOST_CHAR(c) (CROW_IS_ALPHANUM(c) || (c) == '.' || (c) == '-')
454 
455  /**
456  * Verify that a char is a valid visible (printable) US-ASCII
457  * character or %x80-FF
458  **/
459 #define CROW_IS_HEADER_CHAR(ch) \
460  (ch == cr || ch == lf || ch == 9 || ((unsigned char)ch > 31 && ch != 127))
461 
462 #define CROW_start_state s_start_req
463 
464 # define CROW_STRICT_CHECK(cond) \
465 do { \
466  if (cond) { \
467  CROW_SET_ERRNO(CHPE_STRICT); \
468  goto error; \
469  } \
470 } while (0)
471 #define CROW_NEW_MESSAGE() (CROW_start_state)
472 
473 /* Our URL parser.
474  *
475  * This is designed to be shared by http_parser_execute() for URL validation,
476  * hence it has a state transition + byte-for-byte interface. In addition, it
477  * is meant to be embedded in http_parser_parse_url(), which does the dirty
478  * work of turning state transitions URL components for its API.
479  *
480  * This function should only be invoked with non-space characters. It is
481  * assumed that the caller cares about (and can detect) the transition between
482  * URL and non-URL states by looking for these.
483  */
484 inline enum state
485 parse_url_char(enum state s, const char ch, http_parser *parser, const char* url_mark, const char* p)
486 {
487 # define CROW_T(v) 0
488 
489 
490 static const uint8_t normal_url_char[32] = {
491 /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
492  0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
493 /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
494  0 |CROW_T(2)| 0 | 0 |CROW_T(16)| 0 | 0 | 0,
495 /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
496  0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
497 /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
498  0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
499 /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
500  0 | 2 | 4 | 0 | 16 | 32 | 64 | 128,
501 /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
502  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
503 /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
504  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
505 /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
506  1 | 2 | 4 | 8 | 16 | 32 | 64 | 0,
507 /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
508  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
509 /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
510  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
511 /* 80 P 81 Q 82 R 83 S 84 CROW_T 85 U 86 V 87 W */
512  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
513 /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
514  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
515 /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
516  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
517 /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
518  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
519 /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
520  1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
521 /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
522  1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, };
523 
524 #undef CROW_T
525 
526  if (ch == ' ' || ch == '\r' || ch == '\n') {
527  return s_dead;
528  }
529  if (ch == '\t' || ch == '\f') {
530  return s_dead;
531  }
532 
533  switch (s) {
534  case s_req_spaces_before_url:
535  /* Proxied requests are followed by scheme of an absolute URI (alpha).
536  * All methods except CONNECT are followed by '/' or '*'.
537  */
538 
539  if (ch == '/' || ch == '*') {
540  return s_req_path;
541  }
542 
543  if (CROW_IS_ALPHA(ch)) {
544  return s_req_schema;
545  }
546 
547  break;
548 
549  case s_req_schema:
550  if (CROW_IS_ALPHA(ch)) {
551  return s;
552  }
553 
554  if (ch == ':') {
555  return s_req_schema_slash;
556  }
557 
558  break;
559 
560  case s_req_schema_slash:
561  if (ch == '/') {
562  return s_req_schema_slash_slash;
563  }
564 
565  break;
566 
567  case s_req_schema_slash_slash:
568  if (ch == '/') {
569  return s_req_server_start;
570  }
571 
572  break;
573 
574  case s_req_server_with_at:
575  if (ch == '@') {
576  return s_dead;
577  }
578 
579  /* fall through */
580  case s_req_server_start:
581  case s_req_server:
582  if (ch == '/') {
583  return s_req_path;
584  }
585 
586  if (ch == '?') {
587  parser->qs_point = p - url_mark;
588  return s_req_query_string_start;
589  }
590 
591  if (ch == '@') {
592  return s_req_server_with_at;
593  }
594 
595  if (CROW_IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') {
596  return s_req_server;
597  }
598 
599  break;
600 
601  case s_req_path:
602  if (CROW_IS_URL_CHAR(ch)) {
603  return s;
604  }
605  else if (ch == '?')
606  {
607  parser->qs_point = p - url_mark;
608  return s_req_query_string_start;
609  }
610 
611  break;
612 
613  case s_req_query_string_start:
614  case s_req_query_string:
615  if (CROW_IS_URL_CHAR(ch)) {
616  return s_req_query_string;
617  }
618  else if (ch == '?')
619  {
620  return s_req_query_string;
621  }
622 
623  break;
624 
625  default:
626  break;
627  }
628 
629  /* We should never fall out of the switch above unless there's an error */
630  return s_dead;
631 }
632 
633 inline size_t http_parser_execute (http_parser *parser,
634  const http_parser_settings *settings,
635  const char *data,
636  size_t len)
637 {
638 
639 /* Tokens as defined by rfc 2616. Also lowercases them.
640  * token = 1*<any CHAR except CTLs or separators>
641  * separators = "(" | ")" | "<" | ">" | "@"
642  * | "," | ";" | ":" | "\" | <">
643  * | "/" | "[" | "]" | "?" | "="
644  * | "{" | "}" | SP | HT
645  */
646 static const char tokens[256] = {
647 /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
648  0, 0, 0, 0, 0, 0, 0, 0,
649 /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
650  0, 0, 0, 0, 0, 0, 0, 0,
651 /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
652  0, 0, 0, 0, 0, 0, 0, 0,
653 /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
654  0, 0, 0, 0, 0, 0, 0, 0,
655 /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
656  0, '!', 0, '#', '$', '%', '&', '\'',
657 /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
658  0, 0, '*', '+', 0, '-', '.', 0,
659 /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
660  '0', '1', '2', '3', '4', '5', '6', '7',
661 /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
662  '8', '9', 0, 0, 0, 0, 0, 0,
663 /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
664  0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
665 /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
666  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
667 /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
668  'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
669 /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
670  'x', 'y', 'z', 0, 0, 0, '^', '_',
671 /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
672  '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
673 /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
674  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
675 /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
676  'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
677 /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
678  'x', 'y', 'z', 0, '|', 0, '~', 0 };
679 
680 
681 static const int8_t unhex[256] =
682  {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
683  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
684  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
685  , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
686  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
687  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
688  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
689  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
690  };
691 
692 
693 
694  char c, ch;
695  int8_t unhex_val;
696  const char *p = data;
697  const char *header_field_mark = 0;
698  const char *header_value_mark = 0;
699  const char *url_mark = 0;
700  const char *url_start_mark = 0;
701  const char *body_mark = 0;
702  const unsigned int lenient = parser->lenient_http_headers;
703  const unsigned int allow_chunked_length = parser->allow_chunked_length;
704 
705  uint32_t nread = parser->nread;
706 
707  /* We're in an error state. Don't bother doing anything. */
708  if (CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK) {
709  return 0;
710  }
711 
712  if (len == 0) {
713  switch (parser->state) {
714  case s_body_identity_eof:
715  /* Use of CROW_CALLBACK_NOTIFY() here would erroneously return 1 byte read if we got paused. */
716  CROW_CALLBACK_NOTIFY_NOADVANCE(message_complete);
717  return 0;
718 
719  case s_dead:
720  case s_start_req:
721  return 0;
722 
723  default:
724  CROW_SET_ERRNO(CHPE_INVALID_EOF_STATE);
725  return 1;
726  }
727  }
728 
729 
730  if (parser->state == s_header_field)
731  header_field_mark = data;
732  if (parser->state == s_header_value)
733  header_value_mark = data;
734  switch (parser->state) {
735  case s_req_path:
736  case s_req_schema:
737  case s_req_schema_slash:
738  case s_req_schema_slash_slash:
739  case s_req_server_start:
740  case s_req_server:
741  case s_req_server_with_at:
742  case s_req_query_string_start:
743  case s_req_query_string:
744  url_mark = data;
745  break;
746  default:
747  break;
748  }
749 
750  for (p=data; p != data + len; p++) {
751  ch = *p;
752 
753  if (CROW_PARSING_HEADER(parser->state))
754  CROW_COUNT_HEADER_SIZE(1);
755 
756 reexecute:
757  switch (parser->state) {
758 
759  case s_dead:
760  /* this state is used after a 'Connection: close' message
761  * the parser will error out if it reads another message
762  */
763  if (CROW_LIKELY(ch == cr || ch == lf))
764  break;
765 
766  CROW_SET_ERRNO(CHPE_CLOSED_CONNECTION);
767  goto error;
768 
769  case s_start_req:
770  {
771  if (ch == cr || ch == lf)
772  break;
773  parser->flags = 0;
774  parser->uses_transfer_encoding = 0;
775  parser->content_length = CROW_ULLONG_MAX;
776 
777  if (CROW_UNLIKELY(!CROW_IS_ALPHA(ch))) {
778  CROW_SET_ERRNO(CHPE_INVALID_METHOD);
779  goto error;
780  }
781 
782  parser->method = 0;
783  parser->index = 1;
784  switch (ch) {
785  case 'A': parser->method = (unsigned)HTTPMethod::Acl; break;
786  case 'B': parser->method = (unsigned)HTTPMethod::Bind; break;
787  case 'C': parser->method = (unsigned)HTTPMethod::Connect; /* or COPY, CHECKOUT */ break;
788  case 'D': parser->method = (unsigned)HTTPMethod::Delete; break;
789  case 'G': parser->method = (unsigned)HTTPMethod::Get; break;
790  case 'H': parser->method = (unsigned)HTTPMethod::Head; break;
791  case 'L': parser->method = (unsigned)HTTPMethod::Lock; /* or LINK */ break;
792  case 'M': parser->method = (unsigned)HTTPMethod::MkCol; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break;
793  case 'N': parser->method = (unsigned)HTTPMethod::Notify; break;
794  case 'O': parser->method = (unsigned)HTTPMethod::Options; break;
795  case 'P': parser->method = (unsigned)HTTPMethod::Post; /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ break;
796  case 'R': parser->method = (unsigned)HTTPMethod::Report; /* or REBIND */ break;
797  case 'S': parser->method = (unsigned)HTTPMethod::Subscribe; /* or SEARCH, SOURCE */ break;
798  case 'T': parser->method = (unsigned)HTTPMethod::Trace; break;
799  case 'U': parser->method = (unsigned)HTTPMethod::Unlock; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break;
800  default:
801  CROW_SET_ERRNO(CHPE_INVALID_METHOD);
802  goto error;
803  }
804  parser->state = s_req_method;
805 
806  CROW_CALLBACK_NOTIFY(message_begin);
807 
808  break;
809  }
810 
811  case s_req_method:
812  {
813  const char *matcher;
814  if (CROW_UNLIKELY(ch == '\0')) {
815  CROW_SET_ERRNO(CHPE_INVALID_METHOD);
816  goto error;
817  }
818 
819  matcher = method_strings[parser->method];
820  if (ch == ' ' && matcher[parser->index] == '\0') {
821  parser->state = s_req_spaces_before_url;
822  } else if (ch == matcher[parser->index]) {
823  ; /* nada */
824  } else if ((ch >= 'A' && ch <= 'Z') || ch == '-') {
825 
826  switch (parser->method << 16 | parser->index << 8 | ch) {
827 #define CROW_XX(meth, pos, ch, new_meth) \
828  case ((unsigned)HTTPMethod::meth << 16 | pos << 8 | ch): \
829  parser->method = (unsigned)HTTPMethod::new_meth; break;
830 
831  CROW_XX(Post, 1, 'U', Put)
832  CROW_XX(Post, 1, 'A', Patch)
833  CROW_XX(Post, 1, 'R', Propfind)
834  CROW_XX(Put, 2, 'R', Purge)
835  CROW_XX(Connect, 1, 'H', Checkout)
836  CROW_XX(Connect, 2, 'P', Copy)
837  CROW_XX(MkCol, 1, 'O', Move)
838  CROW_XX(MkCol, 1, 'E', Merge)
839  CROW_XX(MkCol, 1, '-', MSearch)
840  CROW_XX(MkCol, 2, 'A', MkActivity)
841  CROW_XX(MkCol, 3, 'A', MkCalendar)
842  CROW_XX(Subscribe, 1, 'E', Search)
843  CROW_XX(Subscribe, 1, 'O', Source)
844  CROW_XX(Report, 2, 'B', Rebind)
845  CROW_XX(Propfind, 4, 'P', Proppatch)
846  CROW_XX(Lock, 1, 'I', Link)
847  CROW_XX(Unlock, 2, 'S', Unsubscribe)
848  CROW_XX(Unlock, 2, 'B', Unbind)
849  CROW_XX(Unlock, 3, 'I', Unlink)
850 #undef CROW_XX
851  default:
852  CROW_SET_ERRNO(CHPE_INVALID_METHOD);
853  goto error;
854  }
855  } else {
856  CROW_SET_ERRNO(CHPE_INVALID_METHOD);
857  goto error;
858  }
859 
860  CROW_CALLBACK_NOTIFY_NOADVANCE(method);
861 
862  ++parser->index;
863  break;
864  }
865 
866  case s_req_spaces_before_url:
867  {
868  if (ch == ' ') break;
869 
870  CROW_MARK(url);
871  CROW_MARK(url_start);
872  if (parser->method == (unsigned)HTTPMethod::Connect) {
873  parser->state = s_req_server_start;
874  }
875 
876  parser->state = parse_url_char(static_cast<state>(parser->state), ch, parser, url_start_mark, p);
877  if (CROW_UNLIKELY(parser->state == s_dead)) {
878  CROW_SET_ERRNO(CHPE_INVALID_URL);
879  goto error;
880  }
881 
882  break;
883  }
884 
885  case s_req_schema:
886  case s_req_schema_slash:
887  case s_req_schema_slash_slash:
888  case s_req_server_start:
889  {
890  switch (ch) {
891  /* No whitespace allowed here */
892  case ' ':
893  case cr:
894  case lf:
895  CROW_SET_ERRNO(CHPE_INVALID_URL);
896  goto error;
897  default:
898  parser->state = parse_url_char(static_cast<state>(parser->state), ch, parser, url_start_mark, p);
899  if (CROW_UNLIKELY(parser->state == s_dead)) {
900  CROW_SET_ERRNO(CHPE_INVALID_URL);
901  goto error;
902  }
903  }
904 
905  break;
906  }
907 
908  case s_req_server:
909  case s_req_server_with_at:
910  case s_req_path:
911  case s_req_query_string_start:
912  case s_req_query_string:
913  {
914  switch (ch) {
915  case ' ':
916  parser->state = s_req_http_start;
917  CROW_CALLBACK_DATA(url);
918  break;
919  case cr: // No space after URL means no HTTP version. Which means the request is using HTTP/0.9
920  case lf:
921  if (CROW_UNLIKELY(parser->method != (unsigned)HTTPMethod::Get)) // HTTP/0.9 doesn't define any method other than GET
922  {
923  parser->state = s_dead;
924  CROW_SET_ERRNO(CHPE_INVALID_VERSION);
925  goto error;
926  }
927  parser->http_major = 0;
928  parser->http_minor = 9;
929  parser->state = (ch == cr) ?
930  s_req_line_almost_done :
931  s_header_field_start;
932  CROW_CALLBACK_DATA(url);
933  break;
934  default:
935  parser->state = parse_url_char(static_cast<state>(parser->state), ch, parser, url_start_mark, p);
936  if (CROW_UNLIKELY(parser->state == s_dead)) {
937  CROW_SET_ERRNO(CHPE_INVALID_URL);
938  goto error;
939  }
940  }
941  break;
942  }
943 
944  case s_req_http_start:
945  switch (ch) {
946  case ' ':
947  break;
948  case 'H':
949  parser->state = s_req_http_H;
950  break;
951  case 'I':
952  if (parser->method == (unsigned)HTTPMethod::Source) {
953  parser->state = s_req_http_I;
954  break;
955  }
956  /* fall through */
957  default:
958  CROW_SET_ERRNO(CHPE_INVALID_CONSTANT);
959  goto error;
960  }
961  break;
962 
963  case s_req_http_H:
964  CROW_STRICT_CHECK(ch != 'T');
965  parser->state = s_req_http_HT;
966  break;
967 
968  case s_req_http_HT:
969  CROW_STRICT_CHECK(ch != 'T');
970  parser->state = s_req_http_HTT;
971  break;
972 
973  case s_req_http_HTT:
974  CROW_STRICT_CHECK(ch != 'P');
975  parser->state = s_req_http_HTTP;
976  break;
977 
978  case s_req_http_I:
979  CROW_STRICT_CHECK(ch != 'C');
980  parser->state = s_req_http_IC;
981  break;
982 
983  case s_req_http_IC:
984  CROW_STRICT_CHECK(ch != 'E');
985  parser->state = s_req_http_HTTP; /* Treat "ICE" as "HTTP". */
986  break;
987 
988  case s_req_http_HTTP:
989  CROW_STRICT_CHECK(ch != '/');
990  parser->state = s_req_http_major;
991  break;
992 
993  /* dot */
994  case s_req_http_major:
995  if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) {
996  CROW_SET_ERRNO(CHPE_INVALID_VERSION);
997  goto error;
998  }
999 
1000  parser->http_major = ch - '0';
1001  parser->state = s_req_http_dot;
1002  break;
1003 
1004  case s_req_http_dot:
1005  {
1006  if (CROW_UNLIKELY(ch != '.')) {
1007  CROW_SET_ERRNO(CHPE_INVALID_VERSION);
1008  goto error;
1009  }
1010 
1011  parser->state = s_req_http_minor;
1012  break;
1013  }
1014 
1015  /* minor HTTP version */
1016  case s_req_http_minor:
1017  if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) {
1018  CROW_SET_ERRNO(CHPE_INVALID_VERSION);
1019  goto error;
1020  }
1021 
1022  parser->http_minor = ch - '0';
1023  parser->state = s_req_http_end;
1024  break;
1025 
1026  /* end of request line */
1027  case s_req_http_end:
1028  {
1029  if (ch == cr) {
1030  parser->state = s_req_line_almost_done;
1031  break;
1032  }
1033 
1034  if (ch == lf) {
1035  parser->state = s_header_field_start;
1036  break;
1037  }
1038 
1039  CROW_SET_ERRNO(CHPE_INVALID_VERSION);
1040  goto error;
1041  break;
1042  }
1043 
1044  /* end of request line */
1045  case s_req_line_almost_done:
1046  {
1047  if (CROW_UNLIKELY(ch != lf)) {
1048  CROW_SET_ERRNO(CHPE_LF_EXPECTED);
1049  goto error;
1050  }
1051 
1052  parser->state = s_header_field_start;
1053  break;
1054  }
1055 
1056  case s_header_field_start:
1057  {
1058  if (ch == cr) {
1059  parser->state = s_headers_almost_done;
1060  break;
1061  }
1062 
1063  if (ch == lf) {
1064  /* they might be just sending \n instead of \r\n so this would be
1065  * the second \n to denote the end of headers*/
1066  parser->state = s_headers_almost_done;
1067  CROW_REEXECUTE();
1068  }
1069 
1070  c = CROW_TOKEN(ch);
1071 
1072  if (CROW_UNLIKELY(!c)) {
1073  CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN);
1074  goto error;
1075  }
1076 
1077  CROW_MARK(header_field);
1078 
1079  parser->index = 0;
1080  parser->state = s_header_field;
1081 
1082  switch (c) {
1083  case 'c':
1084  parser->header_state = h_C;
1085  break;
1086 
1087  case 'p':
1088  parser->header_state = h_matching_proxy_connection;
1089  break;
1090 
1091  case 't':
1092  parser->header_state = h_matching_transfer_encoding;
1093  break;
1094 
1095  case 'u':
1096  parser->header_state = h_matching_upgrade;
1097  break;
1098 
1099  default:
1100  parser->header_state = h_general;
1101  break;
1102  }
1103  break;
1104  }
1105 
1106  case s_header_field:
1107  {
1108  const char* start = p;
1109  for (; p != data + len; p++) {
1110  ch = *p;
1111  c = CROW_TOKEN(ch);
1112 
1113  if (!c)
1114  break;
1115 
1116  switch (parser->header_state) {
1117  case h_general: {
1118  size_t left = data + len - p;
1119  const char* pe = p + CROW_MIN(left, max_header_size);
1120  while (p+1 < pe && CROW_TOKEN(p[1])) {
1121  p++;
1122  }
1123  break;
1124  }
1125 
1126  case h_C:
1127  parser->index++;
1128  parser->header_state = (c == 'o' ? h_CO : h_general);
1129  break;
1130 
1131  case h_CO:
1132  parser->index++;
1133  parser->header_state = (c == 'n' ? h_CON : h_general);
1134  break;
1135 
1136  case h_CON:
1137  parser->index++;
1138  switch (c) {
1139  case 'n':
1140  parser->header_state = h_matching_connection;
1141  break;
1142  case 't':
1143  parser->header_state = h_matching_content_length;
1144  break;
1145  default:
1146  parser->header_state = h_general;
1147  break;
1148  }
1149  break;
1150 
1151  /* connection */
1152 
1153  case h_matching_connection:
1154  parser->index++;
1155  if (parser->index > sizeof(CROW_CONNECTION)-1 || c != CROW_CONNECTION[parser->index]) {
1156  parser->header_state = h_general;
1157  } else if (parser->index == sizeof(CROW_CONNECTION)-2) {
1158  parser->header_state = h_connection;
1159  }
1160  break;
1161 
1162  /* proxy-connection */
1163 
1164  case h_matching_proxy_connection:
1165  parser->index++;
1166  if (parser->index > sizeof(CROW_PROXY_CONNECTION)-1 || c != CROW_PROXY_CONNECTION[parser->index]) {
1167  parser->header_state = h_general;
1168  } else if (parser->index == sizeof(CROW_PROXY_CONNECTION)-2) {
1169  parser->header_state = h_connection;
1170  }
1171  break;
1172 
1173  /* content-length */
1174 
1175  case h_matching_content_length:
1176  parser->index++;
1177  if (parser->index > sizeof(CROW_CONTENT_LENGTH)-1 || c != CROW_CONTENT_LENGTH[parser->index]) {
1178  parser->header_state = h_general;
1179  } else if (parser->index == sizeof(CROW_CONTENT_LENGTH)-2) {
1180  parser->header_state = h_content_length;
1181  }
1182  break;
1183 
1184  /* transfer-encoding */
1185 
1186  case h_matching_transfer_encoding:
1187  parser->index++;
1188  if (parser->index > sizeof(CROW_TRANSFER_ENCODING)-1 || c != CROW_TRANSFER_ENCODING[parser->index]) {
1189  parser->header_state = h_general;
1190  } else if (parser->index == sizeof(CROW_TRANSFER_ENCODING)-2) {
1191  parser->header_state = h_transfer_encoding;
1192  parser->uses_transfer_encoding = 1;
1193  }
1194  break;
1195 
1196  /* upgrade */
1197 
1198  case h_matching_upgrade:
1199  parser->index++;
1200  if (parser->index > sizeof(CROW_UPGRADE)-1 || c != CROW_UPGRADE[parser->index]) {
1201  parser->header_state = h_general;
1202  } else if (parser->index == sizeof(CROW_UPGRADE)-2) {
1203  parser->header_state = h_upgrade;
1204  }
1205  break;
1206 
1207  case h_connection:
1208  case h_content_length:
1209  case h_transfer_encoding:
1210  case h_upgrade:
1211  if (ch != ' ') parser->header_state = h_general;
1212  break;
1213 
1214  default:
1215  assert(0 && "Unknown header_state");
1216  break;
1217  }
1218  }
1219 
1220  if (p == data + len) {
1221  --p;
1222  CROW_COUNT_HEADER_SIZE(p - start);
1223  break;
1224  }
1225 
1226  CROW_COUNT_HEADER_SIZE(p - start);
1227 
1228  if (ch == ':') {
1229  parser->state = s_header_value_discard_ws;
1230  CROW_CALLBACK_DATA(header_field);
1231  break;
1232  }
1233 /* RFC-7230 Sec 3.2.4 expressly forbids line-folding in header field-names.
1234  if (ch == cr) {
1235  parser->state = s_header_almost_done;
1236  CROW_CALLBACK_DATA(header_field);
1237  break;
1238  }
1239 
1240  if (ch == lf) {
1241  parser->state = s_header_field_start;
1242  CROW_CALLBACK_DATA(header_field);
1243  break;
1244  }
1245 */
1246  CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN);
1247  goto error;
1248  }
1249 
1250  case s_header_value_discard_ws:
1251  if (ch == ' ' || ch == '\t') break;
1252 
1253  if (ch == cr) {
1254  parser->state = s_header_value_discard_ws_almost_done;
1255  break;
1256  }
1257 
1258  if (ch == lf) {
1259  parser->state = s_header_value_discard_lws;
1260  break;
1261  }
1262 
1263  /* fall through */
1264 
1265  case s_header_value_start:
1266  {
1267  CROW_MARK(header_value);
1268 
1269  parser->state = s_header_value;
1270  parser->index = 0;
1271 
1272  c = CROW_LOWER(ch);
1273 
1274  switch (parser->header_state) {
1275  case h_upgrade:
1276  // Crow does not support HTTP/2 at the moment.
1277  // According to the RFC https://datatracker.ietf.org/doc/html/rfc7540#section-3.2
1278  // "A server that does not support HTTP/2 can respond to the request as though the Upgrade header field were absent"
1279  // => `F_UPGRADE` is not set if the header starts by "h2".
1280  // This prevents the parser from skipping the request body.
1281  if (ch != 'h' || p+1 == (data + len) || *(p+1) != '2') {
1282  parser->flags |= F_UPGRADE;
1283  }
1284  parser->header_state = h_general;
1285  break;
1286 
1287  case h_transfer_encoding:
1288  /* looking for 'Transfer-Encoding: chunked' */
1289  if ('c' == c) {
1290  parser->header_state = h_matching_transfer_encoding_chunked;
1291  } else {
1292  parser->header_state = h_matching_transfer_encoding_token;
1293  }
1294  break;
1295 
1296  /* Multi-value `Transfer-Encoding` header */
1297  case h_matching_transfer_encoding_token_start:
1298  break;
1299 
1300  case h_content_length:
1301  if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) {
1302  CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH);
1303  goto error;
1304  }
1305 
1306  if (parser->flags & F_CONTENTLENGTH) {
1307  CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH);
1308  goto error;
1309  }
1310  parser->flags |= F_CONTENTLENGTH;
1311  parser->content_length = ch - '0';
1312  parser->header_state = h_content_length_num;
1313  break;
1314 
1315  /* when obsolete line folding is encountered for content length
1316  * continue to the s_header_value state */
1317  case h_content_length_ws:
1318  break;
1319 
1320  case h_connection:
1321  /* looking for 'Connection: keep-alive' */
1322  if (c == 'k') {
1323  parser->header_state = h_matching_connection_keep_alive;
1324  /* looking for 'Connection: close' */
1325  } else if (c == 'c') {
1326  parser->header_state = h_matching_connection_close;
1327  } else if (c == ' ' || c == '\t') {
1328  /* Skip lws */
1329  } else {
1330  parser->header_state = h_general;
1331  }
1332  break;
1333 
1334  default:
1335  parser->header_state = h_general;
1336  break;
1337  }
1338  break;
1339  }
1340 
1341  case s_header_value:
1342  {
1343  const char* start = p;
1344  enum header_states h_state = static_cast<header_states>(parser->header_state);
1345  for (; p != data + len; p++) {
1346  ch = *p;
1347 
1348  if (ch == cr) {
1349  parser->state = s_header_almost_done;
1350  parser->header_state = h_state;
1351  CROW_CALLBACK_DATA(header_value);
1352  break;
1353  }
1354 
1355  if (ch == lf) {
1356  parser->state = s_header_almost_done;
1357  CROW_COUNT_HEADER_SIZE(p - start);
1358  parser->header_state = h_state;
1359  CROW_CALLBACK_DATA_NOADVANCE(header_value);
1360  CROW_REEXECUTE();
1361  }
1362 
1363  if (!lenient && !CROW_IS_HEADER_CHAR(ch)) {
1364  CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN);
1365  goto error;
1366  }
1367 
1368  c = CROW_LOWER(ch);
1369 
1370  switch (h_state) {
1371  case h_general:
1372  {
1373  size_t left = data + len - p;
1374  const char* pe = p + CROW_MIN(left, max_header_size);
1375 
1376  for (; p != pe; p++) {
1377  ch = *p;
1378  if (ch == cr || ch == lf) {
1379  --p;
1380  break;
1381  }
1382  if (!lenient && !CROW_IS_HEADER_CHAR(ch)) {
1383  CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN);
1384  goto error;
1385  }
1386  }
1387  if (p == data + len)
1388  --p;
1389  break;
1390  }
1391 
1392  case h_connection:
1393  case h_transfer_encoding:
1394  assert(0 && "Shouldn't get here.");
1395  break;
1396 
1397  case h_content_length:
1398  if (ch == ' ') break;
1399  h_state = h_content_length_num;
1400  /* fall through */
1401 
1402  case h_content_length_num:
1403  {
1404  uint64_t t;
1405 
1406  if (ch == ' ') {
1407  h_state = h_content_length_ws;
1408  break;
1409  }
1410 
1411  if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) {
1412  CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH);
1413  parser->header_state = h_state;
1414  goto error;
1415  }
1416 
1417  t = parser->content_length;
1418  t *= 10;
1419  t += ch - '0';
1420 
1421  /* Overflow? Test against a conservative limit for simplicity. */
1422  if (CROW_UNLIKELY((CROW_ULLONG_MAX - 10) / 10 < parser->content_length)) {
1423  CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH);
1424  parser->header_state = h_state;
1425  goto error;
1426  }
1427 
1428  parser->content_length = t;
1429  break;
1430  }
1431 
1432  case h_content_length_ws:
1433  if (ch == ' ') break;
1434  CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH);
1435  parser->header_state = h_state;
1436  goto error;
1437 
1438  /* Transfer-Encoding: chunked */
1439  case h_matching_transfer_encoding_token_start:
1440  /* looking for 'Transfer-Encoding: chunked' */
1441  if ('c' == c) {
1442  h_state = h_matching_transfer_encoding_chunked;
1443  } else if (CROW_TOKEN(c)) {
1444  /* TODO(indutny): similar code below does this, but why?
1445  * At the very least it seems to be inconsistent given that
1446  * h_matching_transfer_encoding_token does not check for
1447  * `STRICT_TOKEN`
1448  */
1449  h_state = h_matching_transfer_encoding_token;
1450  } else if (c == ' ' || c == '\t') {
1451  /* Skip lws */
1452  } else {
1453  h_state = h_general;
1454  }
1455  break;
1456 
1457  case h_matching_transfer_encoding_chunked:
1458  parser->index++;
1459  if (parser->index > sizeof(CROW_CHUNKED)-1 || c != CROW_CHUNKED[parser->index]) {
1460  h_state = h_matching_transfer_encoding_token;
1461  } else if (parser->index == sizeof(CROW_CHUNKED)-2) {
1462  h_state = h_transfer_encoding_chunked;
1463  }
1464  break;
1465 
1466  case h_matching_transfer_encoding_token:
1467  if (ch == ',') {
1468  h_state = h_matching_transfer_encoding_token_start;
1469  parser->index = 0;
1470  }
1471  break;
1472 
1473  /* looking for 'Connection: keep-alive' */
1474  case h_matching_connection_keep_alive:
1475  parser->index++;
1476  if (parser->index > sizeof(CROW_KEEP_ALIVE)-1 || c != CROW_KEEP_ALIVE[parser->index]) {
1477  h_state = h_general;
1478  } else if (parser->index == sizeof(CROW_KEEP_ALIVE)-2) {
1479  h_state = h_connection_keep_alive;
1480  }
1481  break;
1482 
1483  /* looking for 'Connection: close' */
1484  case h_matching_connection_close:
1485  parser->index++;
1486  if (parser->index > sizeof(CROW_CLOSE)-1 || c != CROW_CLOSE[parser->index]) {
1487  h_state = h_general;
1488  } else if (parser->index == sizeof(CROW_CLOSE)-2) {
1489  h_state = h_connection_close;
1490  }
1491  break;
1492 
1493  // Edited from original (because of commits that werent included)
1494  case h_transfer_encoding_chunked:
1495  if (ch != ' ') h_state = h_matching_transfer_encoding_token;
1496  break;
1497  case h_connection_keep_alive:
1498  case h_connection_close:
1499  if (ch != ' ') h_state = h_general;
1500  break;
1501 
1502  default:
1503  parser->state = s_header_value;
1504  h_state = h_general;
1505  break;
1506  }
1507  }
1508  parser->header_state = h_state;
1509 
1510 
1511  if (p == data + len)
1512  --p;
1513 
1514  CROW_COUNT_HEADER_SIZE(p - start);
1515  break;
1516  }
1517 
1518  case s_header_almost_done:
1519  {
1520  if (CROW_UNLIKELY(ch != lf)) {
1521  CROW_SET_ERRNO(CHPE_LF_EXPECTED);
1522  goto error;
1523  }
1524 
1525  parser->state = s_header_value_lws;
1526  break;
1527  }
1528 
1529  case s_header_value_lws:
1530  {
1531  if (ch == ' ' || ch == '\t') {
1532  if (parser->header_state == h_content_length_num) {
1533  /* treat obsolete line folding as space */
1534  parser->header_state = h_content_length_ws;
1535  }
1536  parser->state = s_header_value_start;
1537  CROW_REEXECUTE();
1538  }
1539 
1540  /* finished the header */
1541  switch (parser->header_state) {
1542  case h_connection_keep_alive:
1543  parser->flags |= F_CONNECTION_KEEP_ALIVE;
1544  break;
1545  case h_connection_close:
1546  parser->flags |= F_CONNECTION_CLOSE;
1547  break;
1548  case h_transfer_encoding_chunked:
1549  parser->flags |= F_CHUNKED;
1550  break;
1551  default:
1552  break;
1553  }
1554 
1555  parser->state = s_header_field_start;
1556  CROW_REEXECUTE();
1557  }
1558 
1559  case s_header_value_discard_ws_almost_done:
1560  {
1561  CROW_STRICT_CHECK(ch != lf);
1562  parser->state = s_header_value_discard_lws;
1563  break;
1564  }
1565 
1566  case s_header_value_discard_lws:
1567  {
1568  if (ch == ' ' || ch == '\t') {
1569  parser->state = s_header_value_discard_ws;
1570  break;
1571  } else {
1572  /* header value was empty */
1573  CROW_MARK(header_value);
1574  parser->state = s_header_field_start;
1575  CROW_CALLBACK_DATA_NOADVANCE(header_value);
1576  CROW_REEXECUTE();
1577  }
1578  }
1579 
1580  case s_headers_almost_done:
1581  {
1582  CROW_STRICT_CHECK(ch != lf);
1583 
1584  if (parser->flags & F_TRAILING) {
1585  /* End of a chunked request */
1586  CROW_CALLBACK_NOTIFY(message_complete);
1587  break;
1588  }
1589 
1590  /* Cannot use transfer-encoding and a content-length header together
1591  per the HTTP specification. (RFC 7230 Section 3.3.3) */
1592  if ((parser->uses_transfer_encoding == 1) &&
1593  (parser->flags & F_CONTENTLENGTH)) {
1594  /* Allow it for lenient parsing as long as `Transfer-Encoding` is
1595  * not `chunked` or allow_length_with_encoding is set
1596  */
1597  if (parser->flags & F_CHUNKED) {
1598  if (!allow_chunked_length) {
1599  CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH);
1600  goto error;
1601  }
1602  } else if (!lenient) {
1603  CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH);
1604  goto error;
1605  }
1606  }
1607 
1608  parser->state = s_headers_done;
1609 
1610  /* Set this here so that on_headers_complete() callbacks can see it */
1611  parser->upgrade =
1612  (parser->flags & F_UPGRADE || parser->method == (unsigned)HTTPMethod::Connect);
1613 
1614  /* Here we call the headers_complete callback. This is somewhat
1615  * different than other callbacks because if the user returns 1, we
1616  * will interpret that as saying that this message has no body. This
1617  * is needed for the annoying case of recieving a response to a HEAD
1618  * request.
1619  *
1620  * We'd like to use CROW_CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so
1621  * we have to simulate it by handling a change in errno below.
1622  */
1623  if (settings->on_headers_complete) {
1624  switch (settings->on_headers_complete(parser)) {
1625  case 0:
1626  break;
1627 
1628  case 2:
1629  parser->upgrade = 1;
1630  //break;
1631 
1632  /* fall through */
1633  case 1:
1634  parser->flags |= F_SKIPBODY;
1635  break;
1636 
1637  default:
1638  CROW_SET_ERRNO(CHPE_CB_headers_complete);
1639  parser->nread = nread;
1640  return p - data; /* Error */
1641  }
1642  }
1643 
1644  if (CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK) {
1645  parser->nread = nread;
1646  return p - data;
1647  }
1648 
1649  CROW_REEXECUTE();
1650  }
1651 
1652  case s_headers_done:
1653  {
1654  CROW_STRICT_CHECK(ch != lf);
1655 
1656  parser->nread = 0;
1657  nread = 0;
1658 
1659  /* Exit, the rest of the connect is in a different protocol. */
1660  if (parser->upgrade) {
1661  CROW_CALLBACK_NOTIFY(message_complete);
1662  parser->nread = nread;
1663  return (p - data) + 1;
1664  }
1665 
1666  if (parser->flags & F_SKIPBODY) {
1667  CROW_CALLBACK_NOTIFY(message_complete);
1668  } else if (parser->flags & F_CHUNKED) {
1669  /* chunked encoding - ignore Content-Length header,
1670  * prepare for a chunk */
1671  parser->state = s_chunk_size_start;
1672  }
1673  else if (parser->uses_transfer_encoding == 1)
1674  {
1675  if (!lenient)
1676  {
1677  /* RFC 7230 3.3.3 */
1678 
1679  /* If a Transfer-Encoding header field
1680  * is present in a request and the chunked transfer coding is not
1681  * the final encoding, the message body length cannot be determined
1682  * reliably; the server MUST respond with the 400 (Bad Request)
1683  * status code and then close the connection.
1684  */
1685  CROW_SET_ERRNO(CHPE_INVALID_TRANSFER_ENCODING);
1686  parser->nread = nread;
1687  return (p - data); /* Error */
1688  }
1689  else
1690  {
1691  /* RFC 7230 3.3.3 */
1692 
1693  /* If a Transfer-Encoding header field is present in a response and
1694  * the chunked transfer coding is not the final encoding, the
1695  * message body length is determined by reading the connection until
1696  * it is closed by the server.
1697  */
1698  parser->state = s_body_identity_eof;
1699  }
1700  }
1701  else
1702  {
1703  if (parser->content_length == 0)
1704  {
1705  /* Content-Length header given but zero: Content-Length: 0\r\n */
1706  CROW_CALLBACK_NOTIFY(message_complete);
1707  }
1708  else if (parser->content_length != CROW_ULLONG_MAX)
1709  {
1710  /* Content-Length header given and non-zero */
1711  parser->state = s_body_identity;
1712  }
1713  else
1714  {
1715  /* Assume content-length 0 - read the next */
1716  CROW_CALLBACK_NOTIFY(message_complete);
1717  }
1718  }
1719 
1720  break;
1721  }
1722 
1723  case s_body_identity:
1724  {
1725  uint64_t to_read = CROW_MIN(parser->content_length,
1726  (uint64_t) ((data + len) - p));
1727 
1728  assert(parser->content_length != 0
1729  && parser->content_length != CROW_ULLONG_MAX);
1730 
1731  /* The difference between advancing content_length and p is because
1732  * the latter will automaticaly advance on the next loop iteration.
1733  * Further, if content_length ends up at 0, we want to see the last
1734  * byte again for our message complete callback.
1735  */
1736  CROW_MARK(body);
1737  parser->content_length -= to_read;
1738  p += to_read - 1;
1739 
1740  if (parser->content_length == 0) {
1741  parser->state = s_message_done;
1742 
1743  /* Mimic CROW_CALLBACK_DATA_NOADVANCE() but with one extra byte.
1744  *
1745  * The alternative to doing this is to wait for the next byte to
1746  * trigger the data callback, just as in every other case. The
1747  * problem with this is that this makes it difficult for the test
1748  * harness to distinguish between complete-on-EOF and
1749  * complete-on-length. It's not clear that this distinction is
1750  * important for applications, but let's keep it for now.
1751  */
1752  CROW_CALLBACK_DATA_(body, p - body_mark + 1, p - data);
1753  CROW_REEXECUTE();
1754  }
1755 
1756  break;
1757  }
1758 
1759  /* read until EOF */
1760  case s_body_identity_eof:
1761  CROW_MARK(body);
1762  p = data + len - 1;
1763 
1764  break;
1765 
1766  case s_message_done:
1767  CROW_CALLBACK_NOTIFY(message_complete);
1768  break;
1769 
1770  case s_chunk_size_start:
1771  {
1772  assert(nread == 1);
1773  assert(parser->flags & F_CHUNKED);
1774 
1775  unhex_val = unhex[static_cast<unsigned char>(ch)];
1776  if (CROW_UNLIKELY(unhex_val == -1)) {
1777  CROW_SET_ERRNO(CHPE_INVALID_CHUNK_SIZE);
1778  goto error;
1779  }
1780 
1781  parser->content_length = unhex_val;
1782  parser->state = s_chunk_size;
1783  break;
1784  }
1785 
1786  case s_chunk_size:
1787  {
1788  uint64_t t;
1789 
1790  assert(parser->flags & F_CHUNKED);
1791 
1792  if (ch == cr) {
1793  parser->state = s_chunk_size_almost_done;
1794  break;
1795  }
1796 
1797  unhex_val = unhex[static_cast<unsigned char>(ch)];
1798 
1799  if (unhex_val == -1) {
1800  if (ch == ';' || ch == ' ') {
1801  parser->state = s_chunk_parameters;
1802  break;
1803  }
1804 
1805  CROW_SET_ERRNO(CHPE_INVALID_CHUNK_SIZE);
1806  goto error;
1807  }
1808 
1809  t = parser->content_length;
1810  t *= 16;
1811  t += unhex_val;
1812 
1813  /* Overflow? Test against a conservative limit for simplicity. */
1814  if (CROW_UNLIKELY((CROW_ULLONG_MAX - 16) / 16 < parser->content_length)) {
1815  CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH);
1816  goto error;
1817  }
1818 
1819  parser->content_length = t;
1820  break;
1821  }
1822 
1823  case s_chunk_parameters:
1824  {
1825  assert(parser->flags & F_CHUNKED);
1826  /* just ignore this shit. TODO check for overflow */
1827  if (ch == cr) {
1828  parser->state = s_chunk_size_almost_done;
1829  break;
1830  }
1831  break;
1832  }
1833 
1834  case s_chunk_size_almost_done:
1835  {
1836  assert(parser->flags & F_CHUNKED);
1837  CROW_STRICT_CHECK(ch != lf);
1838 
1839  parser->nread = 0;
1840  nread = 0;
1841 
1842  if (parser->content_length == 0) {
1843  parser->flags |= F_TRAILING;
1844  parser->state = s_header_field_start;
1845  } else {
1846  parser->state = s_chunk_data;
1847  }
1848  break;
1849  }
1850 
1851  case s_chunk_data:
1852  {
1853  uint64_t to_read = CROW_MIN(parser->content_length,
1854  (uint64_t) ((data + len) - p));
1855 
1856  assert(parser->flags & F_CHUNKED);
1857  assert(parser->content_length != 0
1858  && parser->content_length != CROW_ULLONG_MAX);
1859 
1860  /* See the explanation in s_body_identity for why the content
1861  * length and data pointers are managed this way.
1862  */
1863  CROW_MARK(body);
1864  parser->content_length -= to_read;
1865  p += to_read - 1;
1866 
1867  if (parser->content_length == 0) {
1868  parser->state = s_chunk_data_almost_done;
1869  }
1870 
1871  break;
1872  }
1873 
1874  case s_chunk_data_almost_done:
1875  assert(parser->flags & F_CHUNKED);
1876  assert(parser->content_length == 0);
1877  CROW_STRICT_CHECK(ch != cr);
1878  parser->state = s_chunk_data_done;
1879  CROW_CALLBACK_DATA(body);
1880  break;
1881 
1882  case s_chunk_data_done:
1883  assert(parser->flags & F_CHUNKED);
1884  CROW_STRICT_CHECK(ch != lf);
1885  parser->nread = 0;
1886  nread = 0;
1887  parser->state = s_chunk_size_start;
1888  break;
1889 
1890  default:
1891  assert(0 && "unhandled state");
1892  CROW_SET_ERRNO(CHPE_INVALID_INTERNAL_STATE);
1893  goto error;
1894  }
1895  }
1896 
1897  /* Run callbacks for any marks that we have leftover after we ran out of
1898  * bytes. There should be at most one of these set, so it's OK to invoke
1899  * them in series (unset marks will not result in callbacks).
1900  *
1901  * We use the NOADVANCE() variety of callbacks here because 'p' has already
1902  * overflowed 'data' and this allows us to correct for the off-by-one that
1903  * we'd otherwise have (since CROW_CALLBACK_DATA() is meant to be run with a 'p'
1904  * value that's in-bounds).
1905  */
1906 
1907  assert(((header_field_mark ? 1 : 0) +
1908  (header_value_mark ? 1 : 0) +
1909  (url_mark ? 1 : 0) +
1910  (body_mark ? 1 : 0)) <= 1);
1911 
1912  CROW_CALLBACK_DATA_NOADVANCE(header_field);
1913  CROW_CALLBACK_DATA_NOADVANCE(header_value);
1914  CROW_CALLBACK_DATA_NOADVANCE(url);
1915  CROW_CALLBACK_DATA_NOADVANCE(body);
1916 
1917  parser->nread = nread;
1918  return len;
1919 
1920 error:
1921  if (CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK) {
1922  CROW_SET_ERRNO(CHPE_UNKNOWN);
1923  }
1924 
1925  parser->nread = nread;
1926  return (p - data);
1927 }
1928 
1929 inline void
1930  http_parser_init(http_parser* parser)
1931 {
1932  void *data = parser->data; /* preserve application data */
1933  memset(parser, 0, sizeof(*parser));
1934  parser->data = data;
1935  parser->state = s_start_req;
1936  parser->http_errno = CHPE_OK;
1937 }
1938 
1939 /* Return a string name of the given error */
1940 inline const char *
1941 http_errno_name(enum http_errno err) {
1942 /* Map errno values to strings for human-readable output */
1943 #define CROW_HTTP_STRERROR_GEN(n, s) { "CHPE_" #n, s },
1944 static struct {
1945  const char *name;
1946  const char *description;
1947 } http_strerror_tab[] = {
1948  CROW_HTTP_ERRNO_MAP(CROW_HTTP_STRERROR_GEN)
1949 };
1950 #undef CROW_HTTP_STRERROR_GEN
1951  assert(((size_t) err) < CROW_ARRAY_SIZE(http_strerror_tab));
1952  return http_strerror_tab[err].name;
1953 }
1954 
1955 /* Return a string description of the given error */
1956 inline const char *
1957 http_errno_description(enum http_errno err) {
1958 /* Map errno values to strings for human-readable output */
1959 #define CROW_HTTP_STRERROR_GEN(n, s) { "CHPE_" #n, s },
1960 static struct {
1961  const char *name;
1962  const char *description;
1963 } http_strerror_tab[] = {
1964  CROW_HTTP_ERRNO_MAP(CROW_HTTP_STRERROR_GEN)
1965 };
1966 #undef CROW_HTTP_STRERROR_GEN
1967  assert(((size_t) err) < CROW_ARRAY_SIZE(http_strerror_tab));
1968  return http_strerror_tab[err].description;
1969 }
1970 
1971 /* Checks if this is the final chunk of the body. */
1972 inline int
1973 http_body_is_final(const struct http_parser *parser) {
1974  return parser->state == s_message_done;
1975 }
1976 
1977 /* Change the maximum header size provided at compile time. */
1978 inline void
1979 http_parser_set_max_header_size(uint32_t size) {
1980  max_header_size = size;
1981 }
1982 
1983 #undef CROW_HTTP_ERRNO_MAP
1984 #undef CROW_SET_ERRNO
1985 #undef CROW_CALLBACK_NOTIFY_
1986 #undef CROW_CALLBACK_NOTIFY
1987 #undef CROW_CALLBACK_NOTIFY_NOADVANCE
1988 #undef CROW_CALLBACK_DATA_
1989 #undef CROW_CALLBACK_DATA
1990 #undef CROW_CALLBACK_DATA_NOADVANCE
1991 #undef CROW_MARK
1992 #undef CROW_PROXY_CONNECTION
1993 #undef CROW_CONNECTION
1994 #undef CROW_CONTENT_LENGTH
1995 #undef CROW_TRANSFER_ENCODING
1996 #undef CROW_UPGRADE
1997 #undef CROW_CHUNKED
1998 #undef CROW_KEEP_ALIVE
1999 #undef CROW_CLOSE
2000 #undef CROW_PARSING_HEADER
2001 #undef CROW_LOWER
2002 #undef CROW_IS_ALPHA
2003 #undef CROW_IS_NUM
2004 #undef CROW_IS_ALPHANUM
2005 //#undef CROW_IS_HEX
2006 #undef CROW_IS_MARK
2007 #undef CROW_IS_USERINFO_CHAR
2008 #undef CROW_TOKEN
2009 #undef CROW_IS_URL_CHAR
2010 //#undef CROW_IS_HOST_CHAR
2011 #undef CROW_STRICT_CHECK
2012 
2013 }
2014 
2015 // clang-format on
crow
The main namespace of the library. In this namespace is defined the most important classes and functi...
crow::http_parser_settings
Definition: http_parser_merged.h:181
crow::http_parser
Definition: http_parser_merged.h:148
crow::http_parser::http_major
unsigned char http_major
Definition: http_parser_merged.h:163
crow::http_parser::flags
unsigned int flags
Definition: http_parser_merged.h:150
crow::http_parser::data
void * data
Definition: http_parser_merged.h:176