/* Copyright Joyent, Inc. and other Node contributors.

*

* 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 <assert.h>

#include <stddef.h>

#include <ctype.h>

#include <string.h>

#include <limits.h>

static uint32_t max_header_size = HTTP_MAX_HEADER_SIZE;

#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)

#define CURRENT_STATE() p_state

#define UPDATE_STATE(V) p_state = (enum state) (V);

#define RETURN(V) \

do { \

parser->state = CURRENT_STATE(); \

return (V); \

} while (0);

#define REEXECUTE() \

goto reexecute; \

#ifdef __GNUC__

# define LIKELY(X) __builtin_expect(!!(X), 1)

# define UNLIKELY(X) __builtin_expect(!!(X), 0)

#else

# define LIKELY(X) (X)

# define UNLIKELY(X) (X)

#endif

/* Run the notify callback FOR, returning ER if it fails */

#define CALLBACK_NOTIFY_(FOR, ER) \

do { \

assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \

\

if (LIKELY(settings->on_##FOR)) { \

parser->state = CURRENT_STATE(); \

if (UNLIKELY(0 != settings->on_##FOR(parser))) { \

SET_ERRNO(HPE_CB_##FOR); \

} \

UPDATE_STATE(parser->state); \

\

/* We either errored above or got paused; get out */ \

if (UNLIKELY(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 (LIKELY(settings->on_##FOR)) { \

parser->state = CURRENT_STATE(); \

if (UNLIKELY(0 != \

settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \

SET_ERRNO(HPE_CB_##FOR); \

} \

UPDATE_STATE(parser->state); \

\

/* We either errored above or got paused; get out */ \

if (UNLIKELY(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)

/* Don't allow the total size of the HTTP headers (including the status

* line) to exceed max_header_size. This check is here to protect

* embedders against denial-of-service attacks where the attacker feeds

* us a never-ending header that the embedder keeps buffering.

*

* This check is arguably the responsibility of embedders but we're doing

* it on the embedder's behalf because most won't bother and this way we

* make the web a little safer. max_header_size is still far bigger

* than any reasonable request or response so this should never affect

* day-to-day operation.

*/

#define COUNT_HEADER_SIZE(V) \

do { \

parser->nread += (V); \

if (UNLIKELY(parser->nread > max_header_size)) { \

SET_ERRNO(HPE_HEADER_OVERFLOW); \

goto error; \

} \

} 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*<any CHAR except CTLs or separators>

* 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_http_major

, s_res_http_dot

, s_res_http_minor

, s_res_http_end

, s_res_first_status_code

, s_res_status_code

, s_res_status_start

, 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_http_major

, s_req_http_dot

, s_req_http_minor

, s_req_http_end

, s_req_line_almost_done

, s_header_field_start

, s_header_field

, s_header_value_discard_ws

, s_header_value_discard_ws_almost_done

, s_header_value_discard_lws

, 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_content_length_num

, h_content_length_ws

, h_transfer_encoding

, h_upgrade

, h_matching_transfer_encoding_chunked

, h_matching_connection_token_start

, h_matching_connection_keep_alive

, h_matching_connection_close

, h_matching_connection_upgrade

, h_matching_connection_token

, h_transfer_encoding_chunked

, h_connection_keep_alive

, h_connection_close

, h_connection_upgrade

};

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_v6_zone_start

, s_http_host_v6_zone

, 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) == ',')

#define STRICT_TOKEN(c) (tokens[(unsigned char)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

/**

* Verify that a char is a valid visible (printable) US-ASCII

* character or %x80-FF

**/

#define IS_HEADER_CHAR(ch) \

(ch == CR || ch == LF || ch == 9 || ((unsigned char)ch > 31 && ch != 127))

#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;

}

if (IS_ALPHA(ch)) {

return s_req_schema;

}

break;

case s_req_schema:

if (IS_ALPHA(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;

const char *status_mark = 0;

enum state p_state = (enum state) parser->state;

const unsigned int lenient = parser->lenient_http_headers;

/* We're in an error state. Don't bother doing anything. */

if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {

return 0;

}

if (len == 0) {

switch (CURRENT_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 (CURRENT_STATE() == s_header_field)

header_field_mark = data;

if (CURRENT_STATE() == s_header_value)

header_value_mark = data;

switch (CURRENT_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;

case s_res_status:

status_mark = data;

break;

default:

break;

}

for (p=data; p != data + len; p++) {

ch = *p;

if (PARSING_HEADER(CURRENT_STATE()))

COUNT_HEADER_SIZE(1);

reexecute:

switch (CURRENT_STATE()) {

case s_dead:

/* this state is used after a 'Connection: close' message

* the parser will error out if it reads another message

*/

if (LIKELY(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') {

UPDATE_STATE(s_res_or_resp_H);

CALLBACK_NOTIFY(message_begin);

} else {

parser->type = HTTP_REQUEST;

UPDATE_STATE(s_start_req);

REEXECUTE();

}

break;

}

case s_res_or_resp_H:

if (ch == 'T') {

parser->type = HTTP_RESPONSE;

UPDATE_STATE(s_res_HT);

} else {

if (UNLIKELY(ch != 'E')) {

SET_ERRNO(HPE_INVALID_CONSTANT);

goto error;

}

parser->type = HTTP_REQUEST;

parser->method = HTTP_HEAD;

parser->index = 2;

UPDATE_STATE(s_req_method);

}

break;

case s_start_res:

{

parser->flags = 0;

parser->content_length = ULLONG_MAX;

switch (ch) {

case 'H':

UPDATE_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');

UPDATE_STATE(s_res_HT);

break;

case s_res_HT:

STRICT_CHECK(ch != 'T');

UPDATE_STATE(s_res_HTT);

break;

case s_res_HTT:

STRICT_CHECK(ch != 'P');

UPDATE_STATE(s_res_HTTP);

break;

case s_res_HTTP:

STRICT_CHECK(ch != '/');

UPDATE_STATE(s_res_http_major);

break;

case s_res_http_major:

if (UNLIKELY(!IS_NUM(ch))) {

SET_ERRNO(HPE_INVALID_VERSION);

goto error;

}

parser->http_major = ch - '0';

UPDATE_STATE(s_res_http_dot);

break;

case s_res_http_dot:

{

if (UNLIKELY(ch != '.')) {

SET_ERRNO(HPE_INVALID_VERSION);

goto error;

}

UPDATE_STATE(s_res_http_minor);

break;

}

case s_res_http_minor:

if (UNLIKELY(!IS_NUM(ch))) {

SET_ERRNO(HPE_INVALID_VERSION);

goto error;

}

parser->http_minor = ch - '0';

UPDATE_STATE(s_res_http_end);

break;

case s_res_http_end:

{

if (UNLIKELY(ch != ' ')) {

SET_ERRNO(HPE_INVALID_VERSION);

goto error;

}

UPDATE_STATE(s_res_first_status_code);

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';

UPDATE_STATE(s_res_status_code);

break;

}

case s_res_status_code:

{

if (!IS_NUM(ch)) {

switch (ch) {

case ' ':

UPDATE_STATE(s_res_status_start);

break;

case CR:

case LF:

UPDATE_STATE(s_res_status_start);

REEXECUTE();

break;

default:

SET_ERRNO(HPE_INVALID_STATUS);

goto error;

}

break;

}

parser->status_code *= 10;

parser->status_code += ch - '0';

if (UNLIKELY(parser->status_code > 999)) {

SET_ERRNO(HPE_INVALID_STATUS);

goto error;

}

break;

}

case s_res_status_start:

{

MARK(status);

UPDATE_STATE(s_res_status);

parser->index = 0;

if (ch == CR || ch == LF)

REEXECUTE();

break;

}

case s_res_status:

if (ch == CR) {

UPDATE_STATE(s_res_line_almost_done);

CALLBACK_DATA(status);

break;

}

if (ch == LF) {

UPDATE_STATE(s_header_field_start);

CALLBACK_DATA(status);

break;

}

break;

case s_res_line_almost_done:

STRICT_CHECK(ch != LF);

UPDATE_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 (UNLIKELY(!IS_ALPHA(ch))) {

SET_ERRNO(HPE_INVALID_METHOD);

goto error;

}

parser->method = (enum http_method) 0;

parser->index = 1;

switch (ch) {

case 'A': parser->method = HTTP_ACL; break;

case 'B': parser->method = HTTP_BIND; break;

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; /* or LINK */ break;

case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ 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; /* or REBIND */ break;

case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH, SOURCE */ break;

case 'T': parser->method = HTTP_TRACE; break;

case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break;

default:

SET_ERRNO(HPE_INVALID_METHOD);

goto error;

}

UPDATE_STATE(s_req_method);

CALLBACK_NOTIFY(message_begin);

break;

}

case s_req_method:

{

const char *matcher;

if (UNLIKELY(ch == '\0')) {

SET_ERRNO(HPE_INVALID_METHOD);

goto error;

}

matcher = method_strings[parser->method];

if (ch == ' ' && matcher[parser->index] == '\0') {

UPDATE_STATE(s_req_spaces_before_url);

} else if (ch == matcher[parser->index]) {

; /* nada */

} else if ((ch >= 'A' && ch <= 'Z') || ch == '-') {

switch (parser->method << 16 | parser->index << 8 | ch) {

#define XX(meth, pos, ch, new_meth) \

case (HTTP_##meth << 16 | pos << 8 | ch): \

parser->method = HTTP_##new_meth; break;

XX(POST, 1, 'U', PUT)

XX(POST, 1, 'A', PATCH)

XX(POST, 1, 'R', PROPFIND)

XX(PUT, 2, 'R', PURGE)

XX(CONNECT, 1, 'H', CHECKOUT)

XX(CONNECT, 2, 'P', COPY)

XX(MKCOL, 1, 'O', MOVE)

XX(MKCOL, 1, 'E', MERGE)

XX(MKCOL, 1, '-', MSEARCH)

XX(MKCOL, 2, 'A', MKACTIVITY)

XX(MKCOL, 3, 'A', MKCALENDAR)

XX(SUBSCRIBE, 1, 'E', SEARCH)

XX(SUBSCRIBE, 1, 'O', SOURCE)

XX(REPORT, 2, 'B', REBIND)

XX(PROPFIND, 4, 'P', PROPPATCH)

XX(LOCK, 1, 'I', LINK)

XX(UNLOCK, 2, 'S', UNSUBSCRIBE)

XX(UNLOCK, 2, 'B', UNBIND)