http_parser.cpp-Dateireferenz

#include "http_parser.h"
#include <assert.h>
#include <stddef.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>

Include-Abhängigkeitsdiagramm für http_parser.cpp:

Makrodefinitionen
#define	ULLONG_MAX   ((uint64_t) -1) /* 2^64-1 */
#define	MIN(a, b)
#define	ARRAY_SIZE(a)
#define	BIT_AT(a, i)
#define	ELEM_AT(a, i, v)
#define	SET_ERRNO(e)
#define	CURRENT_STATE()
#define	UPDATE_STATE(V)
#define	RETURN(V)
#define	REEXECUTE()
#define	LIKELY(X)
#define	UNLIKELY(X)
#define	CALLBACK_NOTIFY_(FOR, ER)
#define	CALLBACK_NOTIFY(FOR)
#define	CALLBACK_NOTIFY_NOADVANCE(FOR)
#define	CALLBACK_DATA_(FOR, LEN, ER)
#define	CALLBACK_DATA(FOR)
#define	CALLBACK_DATA_NOADVANCE(FOR)
#define	MARK(FOR)
#define	COUNT_HEADER_SIZE(V)
#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"
#define	XX(num, name, string)
#define	T(v)
#define	PARSING_HEADER(state)
#define	CR   '\r'
#define	LF   '\n'
#define	LOWER(c)
#define	IS_ALPHA(c)
#define	IS_NUM(c)
#define	IS_ALPHANUM(c)
#define	IS_HEX(c)
#define	IS_MARK(c)
#define	IS_USERINFO_CHAR(c)
#define	STRICT_TOKEN(c)
#define	TOKEN(c)
#define	IS_URL_CHAR(c)
#define	IS_HOST_CHAR(c)
#define	IS_HEADER_CHAR(ch)
#define	start_state   (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
#define	STRICT_CHECK(cond)
#define	NEW_MESSAGE()
#define	HTTP_STRERROR_GEN(n, s)
#define	XX(meth, pos, ch, new_meth)
#define	XX(num, name, string)

Aufzählungen
enum	state {   s_dead = 1 , 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_I , s_req_http_IC , 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 , s_chunk_data , s_chunk_data_almost_done ,   s_chunk_data_done , s_body_identity , s_body_identity_eof , s_message_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_token_start ,   h_matching_transfer_encoding_chunked , h_matching_transfer_encoding_token , 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 }

Funktionen
int	http_message_needs_eof (const http_parser *parser)
size_t	http_parser_execute (http_parser *parser, const http_parser_settings *settings, const char *data, size_t len)
int	http_should_keep_alive (const http_parser *parser)
const char *	http_method_str (enum http_method m)
const char *	http_status_str (enum http_status s)
void	http_parser_init (http_parser *parser, enum http_parser_type t)
void	http_parser_settings_init (http_parser_settings *settings)
const char *	http_errno_name (enum http_errno err)
const char *	http_errno_description (enum http_errno err)
void	http_parser_url_init (struct http_parser_url *u)
int	http_parser_parse_url (const char *buf, size_t buflen, int is_connect, struct http_parser_url *u)
void	http_parser_pause (http_parser *parser, int paused)
int	http_body_is_final (const struct http_parser *parser)
unsigned long	http_parser_version (void)
void	http_parser_set_max_header_size (uint32_t size)

Makro-Dokumentation

ARRAY_SIZE

#define ARRAY_SIZE

(

a

)

Wert:

(sizeof(a) / sizeof((a)[0]))

BIT_AT

#define BIT_AT	(		a,
			i )

Wert:

  (!!((unsigned int) (a)[(unsigned int) (i) >> 3] &                  \
   (1 << ((unsigned int) (i) & 7))))

CALLBACK_DATA

#define CALLBACK_DATA

(

FOR

)

Wert:

    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)

CALLBACK_DATA_

#define CALLBACK_DATA_	(		FOR,
			LEN,
			ER )

Wert:

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)

CALLBACK_DATA_NOADVANCE

#define CALLBACK_DATA_NOADVANCE

(

FOR

)

Wert:

    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)

CALLBACK_NOTIFY

#define CALLBACK_NOTIFY

(

FOR

)

Wert:

CALLBACK_NOTIFY_(FOR, p - data + 1)

CALLBACK_NOTIFY_

#define CALLBACK_NOTIFY_	(		FOR,
			ER )

Wert:

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)

CALLBACK_NOTIFY_NOADVANCE

#define CALLBACK_NOTIFY_NOADVANCE

(

FOR

)

Wert:

CALLBACK_NOTIFY_(FOR, p - data)

CHUNKED

#define CHUNKED   "chunked"

CLOSE

#define CLOSE   "close"

CONNECTION

#define CONNECTION   "connection"

CONTENT_LENGTH

#define CONTENT_LENGTH   "content-length"

COUNT_HEADER_SIZE

#define COUNT_HEADER_SIZE

(

V

)

Wert:

do {                                                                 \
  nread += (uint32_t)(V);                                            \
  if (UNLIKELY(nread > max_header_size)) {                           \
    SET_ERRNO(HPE_HEADER_OVERFLOW);                                  \
    goto error;                                                      \
  }                                                                  \
} while (0)

CR

#define CR   '\r'

CURRENT_STATE

#define CURRENT_STATE

(

)

Wert:

p_state

ELEM_AT

#define ELEM_AT	(		a,
			i,
			v )

Wert:

((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v))

HTTP_STRERROR_GEN

#define HTTP_STRERROR_GEN	(		n,
			s )

Wert:

{ "HPE_" #n, s },

IS_ALPHA

#define IS_ALPHA

(

c

)

Wert:

(LOWER(c) >= 'a' && LOWER(c) <= 'z')

IS_ALPHANUM

#define IS_ALPHANUM

(

c

)

Wert:

(IS_ALPHA(c) || IS_NUM(c))

IS_HEADER_CHAR

#define IS_HEADER_CHAR

(

ch

)

Wert:

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

Verify that a char is a valid visible (printable) US-ASCII character or x80-FF

IS_HEX

#define IS_HEX

(

c

)

Wert:

(IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f'))

IS_HOST_CHAR

#define IS_HOST_CHAR

(

c

)

Wert:

(IS_ALPHANUM(c) || (c) == '.' || (c) == '-')

IS_MARK

#define IS_MARK

(

c

)

Wert:

  ((c) == '-' || (c) == '_' || (c) == '.' || \
  (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \
  (c) == ')')

IS_NUM

#define IS_NUM

(

c

)

Wert:

((c) >= '0' && (c) <= '9')

IS_URL_CHAR

#define IS_URL_CHAR

(

c

)

Wert:

(BIT_AT(normal_url_char, (unsigned char)c))

IS_USERINFO_CHAR

#define IS_USERINFO_CHAR

(

c

)

Wert:

  (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \
  (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \
  (c) == '$' || (c) == ',')

KEEP_ALIVE

#define KEEP_ALIVE   "keep-alive"

LF

#define LF   '\n'

LIKELY

#define LIKELY

(

X

)

Wert:

(X)

LOWER

#define LOWER

(

c

)

Wert:

(unsigned char)(c | 0x20)

MARK

#define MARK

(

FOR

)

Wert:

do {                                                                 \
  if (!FOR##_mark) {                                                 \
    FOR##_mark = p;                                                  \
  }                                                                  \
} while (0)

MIN

#define MIN	(		a,
			b )

Wert:

((a) < (b) ? (a) : (b))

NEW_MESSAGE

#define NEW_MESSAGE

(

)

Wert:

(http_should_keep_alive(parser) ? start_state : s_dead)

PARSING_HEADER

#define PARSING_HEADER

(

state

)

Wert:

(state <= s_headers_done)

PROXY_CONNECTION

#define PROXY_CONNECTION   "proxy-connection"

REEXECUTE

#define REEXECUTE

(

)

Wert:

  goto reexecute;                                                    \

RETURN

#define RETURN

(

V

)

Wert:

do {                                                                 \
  parser->nread = nread;                                             \
  parser->state = CURRENT_STATE();                                   \
  return (V);                                                        \
} while (0);

SET_ERRNO

#define SET_ERRNO

(

e

)

Wert:

do {                                                                 \
  parser->nread = nread;                                             \
  parser->http_errno = (e);                                          \
} while(0)

start_state

#define start_state   (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)

STRICT_CHECK

#define STRICT_CHECK

(

cond

)

Wert:

do {                                                                 \
  if (cond) {                                                        \
    SET_ERRNO(HPE_STRICT);                                           \
    goto error;                                                      \
  }                                                                  \
} while (0)

STRICT_TOKEN

#define STRICT_TOKEN

(

c

)

Wert:

((c == ' ') ? 0 : tokens[(unsigned char)c])

T

#define T

(

v

)

Wert:

0

TOKEN

#define TOKEN

(

c

)

Wert:

STRICT_TOKEN(c)

TRANSFER_ENCODING

#define TRANSFER_ENCODING   "transfer-encoding"

ULLONG_MAX

#define ULLONG_MAX   ((uint64_t) -1) /* 2^64-1 */

UNLIKELY

#define UNLIKELY

(

X

)

Wert:

(X)

UPDATE_STATE

#define UPDATE_STATE

(

V

)

Wert:

p_state = (enum state) (V);

UPGRADE

#define UPGRADE   "upgrade"

XX [1/3]

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

Wert:

            case (HTTP_##meth << 16 | pos << 8 | ch): \
              parser->method = HTTP_##new_meth; break;

XX [2/3]

#define XX	(		num,
			name,
			string )

Wert:

#string,

XX [3/3]

#define XX	(		num,
			name,
			string )

Wert:

case HTTP_STATUS_##name: return #string;

Dokumentation der Aufzählungstypen

header_states

enum header_states

Aufzählungswerte
h_general
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_token_start
h_matching_transfer_encoding_chunked
h_matching_transfer_encoding_token
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

http_host_state

enum http_host_state

Aufzählungswerte
s_http_host_dead
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

state

enum state

Aufzählungswerte
s_dead
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_I
s_req_http_IC
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
s_chunk_data
s_chunk_data_almost_done
s_chunk_data_done
s_body_identity
s_body_identity_eof
s_message_done

Dokumentation der Funktionen

http_body_is_final()

int http_body_is_final

(

const struct http_parser *

parser

)

http_errno_description()

const char * http_errno_description

(

enum http_errno

err

)

http_errno_name()

const char * http_errno_name

(

enum http_errno

err

)

http_message_needs_eof()

int http_message_needs_eof

(

const http_parser *

parser

)

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

http_method_str()

const char * http_method_str

(

enum http_method

m

)

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

http_parser_execute()

size_t http_parser_execute	(	http_parser *	parser,
		const http_parser_settings *	settings,
		const char *	data,
		size_t	len )

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

http_parser_init()

void http_parser_init	(	http_parser *	parser,
		enum http_parser_type	t )

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

http_parser_parse_url()

int http_parser_parse_url	(	const char *	buf,
		size_t	buflen,
		int	is_connect,
		struct http_parser_url *	u )

http_parser_pause()

void http_parser_pause	(	http_parser *	parser,
		int	paused )

http_parser_set_max_header_size()

void http_parser_set_max_header_size

(

uint32_t

size

)

http_parser_settings_init()

void http_parser_settings_init

(

http_parser_settings *

settings

)

http_parser_url_init()

void http_parser_url_init

(

struct http_parser_url *

u

)

http_parser_version()

unsigned long http_parser_version

(

void

)

http_should_keep_alive()

int http_should_keep_alive

(

const http_parser *

parser

)

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

http_status_str()

const char * http_status_str

(

enum http_status

s

)

Variablen-Dokumentation

description

const char* description

name

const char* name