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

#include <stddef.h>

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h>

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