proxygen: proxygen/external/http_parser/test.c File Reference

#include "http_parser.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

Go to the source code of this file.

Classes
struct	message

struct	url_test

Macros
#define	TRUE 1

#define	FALSE 0

#define	MAX_HEADERS 13

#define	MAX_ELEMENT_SIZE 500

#define	MAX_CHUNKS 16

#define	MIN(a, b) ((a) < (b) ? (a) : (b))

#define	CURL_GET 0

#define	FIREFOX_GET 1

#define	DUMBFUCK 2

#define	FRAGMENT_IN_URI 3

#define	GET_NO_HEADERS_NO_BODY 4

#define	GET_ONE_HEADER_NO_BODY 5

#define	GET_FUNKY_CONTENT_LENGTH 6

#define	POST_IDENTITY_BODY_WORLD 7

#define	POST_CHUNKED_ALL_YOUR_BASE 8

#define	TWO_CHUNKS_MULT_ZERO_END 9

#define	CHUNKED_W_TRAILING_HEADERS 10

#define	CHUNKED_W_BULLSHIT_AFTER_LENGTH 11

#define	WITH_QUOTES 12

#define	APACHEBENCH_GET 13

#define	QUERY_URL_WITH_QUESTION_MARK_GET 14

#define	PREFIX_NEWLINE_GET 15

#define	UPGRADE_REQUEST 16

#define	CONNECT_REQUEST 17

#define	REPORT_REQ 18

#define	NO_HTTP_VERSION 19

#define	MSEARCH_REQ 20

#define	LINE_FOLDING_IN_HEADER 20

#define	QUERY_TERMINATED_HOST 21

#define	QUERY_TERMINATED_HOSTPORT 22

#define	SPACE_TERMINATED_HOSTPORT 23

#define	UTF8_PATH_REQ 24

#define	HOSTNAME_UNDERSCORE 25

#define	PATCH_REQ 26

#define	CONNECT_CAPS_REQUEST 27

#define	IPV6_LITERAL_URI_GET 28

#define	IPV6_LITERAL_URI_CONNECT 29

#define	UPGRADE_POST_REQUEST 30

#define	CONNECT_WITH_BODY_REQUEST 31

#define	GOOGLE_301 0

#define	NO_CONTENT_LENGTH_RESPONSE 1

#define	NO_HEADERS_NO_BODY_404 2

#define	NO_REASON_PHRASE 3

#define	TRAILING_SPACE_ON_CHUNKED_BODY 4

#define	NO_CARRIAGE_RET 5

#define	PROXY_CONNECTION 6

#define	UNDERSTORE_HEADER_KEY 7

#define	BONJOUR_MADAME_FR 8

#define	RES_FIELD_UNDERSCORE 10

#define	NON_ASCII_IN_STATUS_LINE 11

#define	MESSAGE_CHECK_STR_EQ(expected, found, prop) if (!check_str_eq(expected, #prop, expected->prop, found->prop)) return 0

#define	MESSAGE_CHECK_NUM_EQ(expected, found, prop) if (!check_num_eq(expected, #prop, expected->prop, found->prop)) return 0

Functions
int	request_url_cb (http_parser p, const char buf, size_t len)

int	header_field_cb (http_parser p, const char buf, size_t len)

int	header_value_cb (http_parser p, const char buf, size_t len)

int	body_cb (http_parser p, const char buf, size_t len)

int	count_body_cb (http_parser p, const char buf, size_t len)

int	message_begin_cb (http_parser *p)

int	headers_complete_cb (http_parser p, const char buf, size_t len)

int	message_complete_cb (http_parser *p)

int	response_reason_cb (http_parser p, const char buf, size_t len)

int	chunk_header_cb (http_parser *p)

int	chunk_complete_cb (http_parser *p)

int	dontcall_message_begin_cb (http_parser *p)

int	dontcall_header_field_cb (http_parser p, const char buf, size_t len)

int	dontcall_header_value_cb (http_parser p, const char buf, size_t len)

int	dontcall_request_url_cb (http_parser p, const char buf, size_t len)

int	dontcall_body_cb (http_parser p, const char buf, size_t len)

int	dontcall_headers_complete_cb (http_parser p, const char buf, size_t len)

int	dontcall_message_complete_cb (http_parser *p)

int	dontcall_response_reason_cb (http_parser p, const char buf, size_t len)

int	dontcall_chunk_header_cb (http_parser *p)

int	dontcall_chunk_complete_cb (http_parser *p)

int	pause_message_begin_cb (http_parser *p)

int	pause_header_field_cb (http_parser p, const char buf, size_t len)

int	pause_header_value_cb (http_parser p, const char buf, size_t len)

int	pause_request_url_cb (http_parser p, const char buf, size_t len)

int	pause_body_cb (http_parser p, const char buf, size_t len)

int	pause_headers_complete_cb (http_parser p, const char buf, size_t len)

int	pause_message_complete_cb (http_parser *p)

int	pause_response_reason_cb (http_parser p, const char buf, size_t len)

int	pause_chunk_header_cb (http_parser *p)

int	pause_chunk_complete_cb (http_parser *p)

int	empty_cb (http_parser *p)

int	empty_data_cb (http_parser p, const char buf, size_t len)

void	parser_init (enum http_parser_type type)

void	parser_free ()

size_t	parse (const char *buf, size_t len)

size_t	parse_count_body (const char *buf, size_t len)

size_t	parse_pause (const char *buf, size_t len)

static int	check_str_eq (const struct message m, const char prop, const char expected, const char found)

static int	check_num_eq (const struct message m, const char prop, int expected, int found)

int	message_eq (int index, const struct message *expected)

size_t	count_parsed_messages (const size_t nmsgs,...)

void	upgrade_message_fix (char *body, const size_t nread, const size_t nmsgs,...)

static void	print_error (const char *raw, size_t error_location)

void	dump_url (const char url, const struct http_parser_url u)

void	test_parse_url (void)

void	test_message (const struct message *message)

void	test_message_count_body (const struct message *message)

void	test_simple (const char *buf, enum http_errno err_expected)

void	test_header_overflow_error (int req)

void	test_no_overflow_long_body (int req, size_t length)

void	test_multiple3 (const struct message r1, const struct message r2, const struct message *r3)

void	test_scan (const struct message r1, const struct message r2, const struct message *r3)

char *	create_large_chunked_message (int body_size_in_kb, const char *headers)

void	test_message_pause (const struct message *msg)

void	test_on_message_begin_cb (const struct message *message)

int	main (void)

Variables
static http_parser *	parser

static int	currently_parsing_eof

static struct message	messages [5]

static int	num_messages

static http_parser_settings *	current_pause_parser

const struct message	requests []

const struct message	responses []

const struct message	on_message_begin_cb_test []

static http_parser_settings	settings_dontcall

static http_parser_settings	settings_pause

static http_parser_settings	settings

static http_parser_settings	settings_count_body

static http_parser_settings	settings_null

const struct url_test	url_tests []

Macro Definition Documentation

#define APACHEBENCH_GET 13

#define BONJOUR_MADAME_FR 8

Referenced by main().

#define CHUNKED_W_BULLSHIT_AFTER_LENGTH 11

Referenced by main().

#define CHUNKED_W_TRAILING_HEADERS 10

Referenced by main().

#define CONNECT_CAPS_REQUEST 27

#define CONNECT_REQUEST 17

Referenced by main().

#define CONNECT_WITH_BODY_REQUEST 31

#define CURL_GET 0

#define DUMBFUCK 2

#define FALSE 0

Definition at line 32 of file test.c.

Referenced by testing::internal::GetThreadCount(), main(), testing::internal::NoDefaultContructor::NoDefaultContructor(), and testing::internal::TEST().

#define FIREFOX_GET 1

#define FRAGMENT_IN_URI 3

#define GET_FUNKY_CONTENT_LENGTH 6

Referenced by main().

#define GET_NO_HEADERS_NO_BODY 4

Referenced by main().

#define GET_ONE_HEADER_NO_BODY 5

Referenced by main().

#define GOOGLE_301 0

#define HOSTNAME_UNDERSCORE 25

#define IPV6_LITERAL_URI_CONNECT 29

#define IPV6_LITERAL_URI_GET 28

#define LINE_FOLDING_IN_HEADER 20

#define MAX_CHUNKS 16

Definition at line 36 of file test.c.

Referenced by chunk_header_cb(), main(), and message_eq().

#define MAX_ELEMENT_SIZE 500

Definition at line 35 of file test.c.

Referenced by header_value_cb().

#define MAX_HEADERS 13

Definition at line 34 of file test.c.

#define MESSAGE_CHECK_NUM_EQ	(	expected,
		found,
		prop
	)	if (!check_num_eq(expected, #prop, expected->prop, found->prop)) return 0

Definition at line 1655 of file test.c.

Referenced by message_eq().

#define MESSAGE_CHECK_STR_EQ	(	expected,
		found,
		prop
	)	if (!check_str_eq(expected, #prop, expected->prop, found->prop)) return 0

Definition at line 1652 of file test.c.

Referenced by message_eq().

#define MIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

Definition at line 38 of file test.c.

Referenced by test_message_count_body().

#define MSEARCH_REQ 20

#define NO_CARRIAGE_RET 5

Referenced by main().

#define NO_CONTENT_LENGTH_RESPONSE 1

#define NO_HEADERS_NO_BODY_404 2

Referenced by main().

#define NO_HTTP_VERSION 19

#define NO_REASON_PHRASE 3

Referenced by main().

#define NON_ASCII_IN_STATUS_LINE 11

#define PATCH_REQ 26

#define POST_CHUNKED_ALL_YOUR_BASE 8

Referenced by main().

#define POST_IDENTITY_BODY_WORLD 7

Referenced by main().

#define PREFIX_NEWLINE_GET 15

Referenced by main().

#define PROXY_CONNECTION 6

#define QUERY_TERMINATED_HOST 21

#define QUERY_TERMINATED_HOSTPORT 22

#define QUERY_URL_WITH_QUESTION_MARK_GET 14

Referenced by main().

#define REPORT_REQ 18

#define RES_FIELD_UNDERSCORE 10

#define SPACE_TERMINATED_HOSTPORT 23

#define TRAILING_SPACE_ON_CHUNKED_BODY 4

Referenced by main().

#define TRUE 1

Definition at line 30 of file test.c.

Referenced by testing::internal::GetThreadCount(), headers_complete_cb(), message_complete_cb(), testing::internal::NoDefaultContructor::NoDefaultContructor(), and testing::internal::TEST().

#define TWO_CHUNKS_MULT_ZERO_END 9

Referenced by main().

#define UNDERSTORE_HEADER_KEY 7

Referenced by main().

#define UPGRADE_POST_REQUEST 30

#define UPGRADE_REQUEST 16

#define UTF8_PATH_REQ 24

#define WITH_QUOTES 12

Function Documentation

int body_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1246 of file test.c.

References message::body, message::body_size, messages, and num_messages.

Referenced by pause_body_cb().

 {
   assert(p == parser);
   strncat(messages[num_messages].body, buf, len);
   messages[num_messages].body_size += len;
  // printf("body_cb: '%s'\n", requests[num_messages].body);
   return 0;
 }

static int check_num_eq	(	const struct message *	m,
		const char *	prop,
		int	expected,
		int	found
	)

inlinestatic

Definition at line 1639 of file test.c.

References message::name.

                          {
   if (expected != found) {
     printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
     printf("expected %d\n", expected);
     printf("   found %d\n", found);
     return 0;
   }
   return 1;
 }

static int check_str_eq	(	const struct message *	m,
		const char *	prop,
		const char *	expected,
		const char *	found
	)

inlinestatic

Definition at line 1619 of file test.c.

References message::name.

Referenced by message_eq(), and upgrade_message_fix().

                                  {
   if ((expected == NULL) != (found == NULL)) {
     printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
     printf("expected %s\n", (expected == NULL) ? "NULL" : expected);
     printf("   found %s\n", (found == NULL) ? "NULL" : found);
     return 0;
   }
   if (expected != NULL && 0 != strcmp(expected, found)) {
     printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
     printf("expected '%s'\n", expected);
     printf("   found '%s'\n", found);
     return 0;
   }
   return 1;
 }

int chunk_complete_cb ( http_parser * p )

Definition at line 1324 of file test.c.

References messages, message::num_chunks_complete, and num_messages.

Referenced by pause_chunk_complete_cb().

 {
   assert(p == parser);
   ++messages[num_messages].num_chunks_complete;
   return 0;
 }

int chunk_header_cb ( http_parser * p )

Definition at line 1306 of file test.c.

References message::chunk_lengths, http_parser::content_length, MAX_CHUNKS, messages, message::num_chunks, and num_messages.

Referenced by pause_chunk_header_cb().

 {
   assert(p == parser);
   if (p->content_length == 0) {
     // Terminating chunk.  Don't increment num_chunks in this case.
     return 0;
   }
 
   int chunk_idx = messages[num_messages].num_chunks;
   ++messages[num_messages].num_chunks;
   if (chunk_idx < MAX_CHUNKS) {
     messages[num_messages].chunk_lengths[chunk_idx] = p->content_length;
   }
 
   return 0;
 }

int count_body_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1256 of file test.c.

References message::body_size, messages, and num_messages.

 {
   assert(p == parser);
   assert(buf);
   messages[num_messages].body_size += len;
   return 0;
 }

size_t count_parsed_messages	(	const size_t	nmsgs,
			...
	)

Definition at line 1715 of file test.c.

References i, m, and message::upgrade.

Referenced by test_multiple3(), and test_scan().

                                                {
   size_t i;
   va_list ap;
 
   va_start(ap, nmsgs);
 
   for (i = 0; i < nmsgs; i++) {
     struct message *m = va_arg(ap, struct message *);
 
     if (m->upgrade) {
       va_end(ap);
       return i + 1;
     }
   }
 
   va_end(ap);
   return nmsgs;
 }

char* create_large_chunked_message	(	int	body_size_in_kb,
		const char *	headers
	)

Definition at line 2740 of file test.c.

References i.

Referenced by main().

 {
   int i;
   size_t wrote = 0;
   size_t headers_len = strlen(headers);
   size_t bufsize = headers_len + (5+1024+2)*body_size_in_kb + 6;
   char * buf = malloc(bufsize);
 
   memcpy(buf, headers, headers_len);
   wrote += headers_len;
 
   for (i = 0; i < body_size_in_kb; i++) {
     // write 1kb chunk into the body.
     memcpy(buf + wrote, "400\r\n", 5);
     wrote += 5;
     memset(buf + wrote, 'C', 1024);
     wrote += 1024;
     strcpy(buf + wrote, "\r\n");
     wrote += 2;
   }
 
   memcpy(buf + wrote, "0\r\n\r\n", 6);
   wrote += 6;
   assert(wrote == bufsize);
 
   return buf;
 }

int dontcall_body_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1366 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_body_cb() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_chunk_complete_cb ( http_parser * p )

Definition at line 1408 of file test.c.

 {
   if (p) { } // gcc
   fprintf(stderr, "\n\n*** on_chunk_complete() "
           "called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_chunk_header_cb ( http_parser * p )

Definition at line 1400 of file test.c.

 {
   if (p) { } // gcc
   fprintf(stderr, "\n\n*** on_chunk_header() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_header_field_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1342 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_header_field() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_header_value_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1350 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_header_value() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_headers_complete_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1374 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_headers_complete() called on paused "
                   "parser ***\n\n");
   exit(1);
 }

int dontcall_message_begin_cb ( http_parser * p )

Definition at line 1334 of file test.c.

 {
   if (p) { } // gcc
   fprintf(stderr, "\n\n*** on_message_begin() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_message_complete_cb ( http_parser * p )

Definition at line 1383 of file test.c.

 {
   if (p) { } // gcc
   fprintf(stderr, "\n\n*** on_message_complete() called on paused "
                   "parser ***\n\n");
   exit(1);
 }

int dontcall_request_url_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1358 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_request_url() called on paused parser ***\n\n");
   exit(1);
 }

int dontcall_response_reason_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1392 of file test.c.

 {
   if (p || buf || len) { } // gcc
   fprintf(stderr, "\n\n*** on_reason() called on paused parser ***\n\n");
   exit(1);
 }

void dump_url	(	const char *	url,
		const struct http_parser_url *	u
	)

Definition at line 2309 of file test.c.

References http_parser_url::field_data, http_parser_url::field_set, i, http_parser_url::len, http_parser_url::off, http_parser_url::port, and UF_MAX.

Referenced by test_parse_url().

 {
   unsigned int i;
 
   printf("\tfield_set: 0x%x, port: %u\n", u->field_set, u->port);
   for (i = 0; i < UF_MAX; i++) {
     if ((u->field_set & (1 << i)) == 0) {
       printf("\tfield_data[%u]: unset\n", i);
       continue;
     }
 
     printf("\tfield_data[%u]: off: %u len: %u part: \"%.*s\n\"",
            i,
            u->field_data[i].off,
            u->field_data[i].len,
            u->field_data[i].len,
            url + u->field_data[i].off);
   }
 }

int empty_cb ( http_parser * p )

Definition at line 1513 of file test.c.

1513 { return 0; }

int empty_data_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1514 of file test.c.

1514 { return 0; }

int header_field_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1212 of file test.c.

References message::FIELD, message::headers, message::last_header_element, m, messages, message::num_headers, and num_messages.

Referenced by pause_header_field_cb().

 {
   assert(p == parser);
   struct message *m = &messages[num_messages];
 
   if (m->last_header_element != FIELD)
     m->num_headers++;
 
   strncat(m->headers[m->num_headers-1][0], buf, len);
 
   m->last_header_element = FIELD;
 
   return 0;
 }

int header_value_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1228 of file test.c.

References message::headers, message::last_header_element, m, MAX_ELEMENT_SIZE, messages, message::num_headers, num_messages, and message::VALUE.

Referenced by pause_header_value_cb().

 {
   assert(p == parser);
   struct message *m = &messages[num_messages];
 
   const size_t cursize = strlen(m->headers[m->num_headers-1][1]);
   if (cursize + len + 1 > MAX_ELEMENT_SIZE) {
     len = MAX_ELEMENT_SIZE - (cursize + 1);
   }
 
   strncat(m->headers[m->num_headers-1][1], buf, len);
 
   m->last_header_element = VALUE;
 
   return 0;
 }

int headers_complete_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1273 of file test.c.

References message::headers_complete_cb_called, message::http_major, http_parser::http_major, message::http_minor, http_parser::http_minor, messages, message::method, http_parser::method, num_messages, message::status_code, http_parser::status_code, and TRUE.

Referenced by pause_headers_complete_cb().

 {
   assert(p == parser);
   assert(!buf);
   messages[num_messages].method = parser->method;
   messages[num_messages].status_code = parser->status_code;
   messages[num_messages].http_major = parser->http_major;
   messages[num_messages].http_minor = parser->http_minor;
   messages[num_messages].headers_complete_cb_called = TRUE;
   return 0;
 }

int main ( void )

TESTING ON_MESSAGE_BEGIN CALLS

REQUESTS

Definition at line 2834 of file test.c.

References BONJOUR_MADAME_FR, message::chunk_lengths, CHUNKED_W_BULLSHIT_AFTER_LENGTH, CHUNKED_W_TRAILING_HEADERS, CONNECT_REQUEST, create_large_chunked_message(), FALSE, bm::free(), GET_FUNKY_CONTENT_LENGTH, GET_NO_HEADERS_NO_BODY, GET_ONE_HEADER_NO_BODY, HPE_INVALID_CONTENT_LENGTH, HPE_INVALID_HEADER_TOKEN, HPE_INVALID_METHOD, HPE_INVALID_TRANSFER_ENCODING, HPE_INVALID_UPGRADE, HPE_INVALID_VERSION, HPE_OK, HPE_STRICT, HPE_UNKNOWN, HTTP_REQUEST, HTTP_RESPONSE, i, k, MAX_CHUNKS, message::name, NO_CARRIAGE_RET, NO_HEADERS_NO_BODY_404, NO_REASON_PHRASE, POST_CHUNKED_ALL_YOUR_BASE, POST_IDENTITY_BODY_WORLD, PREFIX_NEWLINE_GET, QUERY_URL_WITH_QUESTION_MARK_GET, message::should_keep_alive, test_header_overflow_error(), test_message(), test_message_count_body(), test_message_pause(), test_multiple3(), test_no_overflow_long_body(), test_on_message_begin_cb(), test_parse_url(), test_scan(), test_simple(), TRAILING_SPACE_ON_CHUNKED_BODY, TWO_CHUNKS_MULT_ZERO_END, and UNDERSTORE_HEADER_KEY.

Referenced by cmake_minimum_required().

 {
   parser = NULL;
   int i, j, k;
   int request_count;
   int response_count;
   int on_message_begin_cb_count;
 
   printf("sizeof(http_parser) = %u\n", (unsigned int)sizeof(http_parser));
 
   for (request_count = 0; requests[request_count].name; request_count++);
   for (response_count = 0; responses[response_count].name; response_count++);
   for (on_message_begin_cb_count = 0;
        on_message_begin_cb_test[on_message_begin_cb_count].name;
        on_message_begin_cb_count++);
 
   test_parse_url();
 
   for (i = 0 ; i < on_message_begin_cb_count; i++) {
     test_on_message_begin_cb(&on_message_begin_cb_test[i]);
   }
 
 
   test_header_overflow_error(HTTP_REQUEST);
   test_no_overflow_long_body(HTTP_REQUEST, 1000);
   test_no_overflow_long_body(HTTP_REQUEST, 100000);
 
   test_header_overflow_error(HTTP_RESPONSE);
   test_no_overflow_long_body(HTTP_RESPONSE, 1000);
   test_no_overflow_long_body(HTTP_RESPONSE, 100000);
 
 
   for (i = 0; i < response_count; i++) {
     test_message(&responses[i]);
   }
 
   for (i = 0; i < response_count; i++) {
     test_message_pause(&responses[i]);
   }
 
   for (i = 0; i < response_count; i++) {
     if (!responses[i].should_keep_alive) continue;
     for (j = 0; j < response_count; j++) {
       if (!responses[j].should_keep_alive) continue;
       for (k = 0; k < response_count; k++) {
         test_multiple3(&responses[i], &responses[j], &responses[k]);
       }
     }
   }
 
   test_message_count_body(&responses[NO_HEADERS_NO_BODY_404]);
   test_message_count_body(&responses[TRAILING_SPACE_ON_CHUNKED_BODY]);
 
   // test very large chunked response
   {
     char * msg = create_large_chunked_message(31337,
       "HTTP/1.0 200 OK\r\n"
       "Transfer-Encoding: chunked\r\n"
       "Content-Type: text/plain\r\n"
       "\r\n");
     struct message large_chunked =
       {.name= "large chunked"
       ,.type= HTTP_RESPONSE
       ,.raw= msg
       ,.should_keep_alive= FALSE
       ,.message_complete_on_eof= FALSE
       ,.http_major= 1
       ,.http_minor= 0
       ,.status_code= 200
       ,.response_reason= "OK"
       ,.num_headers= 2
       ,.headers=
         { { "Transfer-Encoding", "chunked" }
         , { "Content-Type", "text/plain" }
         }
       ,.body_size= 31337*1024
       ,.num_chunks= 31337
       ,.num_chunks_complete= 31338
       };
     for (i = 0; i < MAX_CHUNKS; ++i) {
       large_chunked.chunk_lengths[i] = 1024;
     }
     test_message_count_body(&large_chunked);
     free(msg);
   }
 
 
 
   printf("response scan 1/2      ");
   test_scan( &responses[TRAILING_SPACE_ON_CHUNKED_BODY]
            , &responses[NO_REASON_PHRASE]
            , &responses[NO_HEADERS_NO_BODY_404]
            );
 
   printf("response scan 2/2      ");
   test_scan( &responses[BONJOUR_MADAME_FR]
            , &responses[UNDERSTORE_HEADER_KEY]
            , &responses[NO_CARRIAGE_RET]
            );
 
   puts("responses okay");
 
 
 
   test_simple("hello world", HPE_INVALID_METHOD);
   test_simple("GET / HTP/1.1\r\n\r\n", HPE_INVALID_VERSION);
 
 
   test_simple("ASDF / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
   test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
   test_simple("GETA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
 
   // Well-formed but incomplete
   test_simple("GET / HTTP/1.1\r\n"
               "Content-Type: text/plain\r\n"
               "Content-Length: 6\r\n"
               "\r\n"
               "fooba",
               HPE_OK);
 
   static const char *all_methods[] = {
     "DELETE",
     "GET",
     "HEAD",
     "POST",
     "PUT",
     //"CONNECT", //CONNECT can't be tested like other methods, it's a tunnel
     "OPTIONS",
     "TRACE",
     "COPY",
     "LOCK",
     "MKCOL",
     "MOVE",
     "PROPFIND",
     "PROPPATCH",
     "UNLOCK",
     "REPORT",
     "MKACTIVITY",
     "CHECKOUT",
     "MERGE",
     "M-SEARCH",
     "NOTIFY",
     "SUBSCRIBE",
     "UNSUBSCRIBE",
     "PATCH",
     0 };
   const char **this_method;
   for (this_method = all_methods; *this_method; this_method++) {
     char buf[200];
     sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
     test_simple(buf, HPE_OK);
   }
 
   static const char *bad_methods[] = {
       "C******",
       "M****",
       0 };
   for (this_method = bad_methods; *this_method; this_method++) {
     char buf[200];
     sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
     test_simple(buf, HPE_UNKNOWN);
   }
 
   const char *dumbfuck2 =
     "GET / HTTP/1.1\r\n"
     "X-SSL-Bullshit:   -----BEGIN CERTIFICATE-----\r\n"
     "\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n"
     "\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n"
     "\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n"
     "\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n"
     "\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n"
     "\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n"
     "\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n"
     "\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n"
     "\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n"
     "\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n"
     "\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n"
     "\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n"
     "\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgHTTPAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n"
     "\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n"
     "\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n"
     "\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n"
     "\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n"
     "\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n"
     "\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n"
     "\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n"
     "\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n"
     "\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n"
     "\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n"
     "\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n"
     "\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n"
     "\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n"
     "\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n"
     "\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n"
     "\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n"
     "\tRA==\r\n"
     "\t-----END CERTIFICATE-----\r\n"
     "\r\n";
   test_simple(dumbfuck2, HPE_OK);
 
   const char *corrupted_header_name =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "X-Some-Header\r\033\065\325eep-Alive\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(corrupted_header_name, HPE_INVALID_HEADER_TOKEN);
 
   const char *header_with_space =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Foo Foo: some_value\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(header_with_space, HPE_INVALID_HEADER_TOKEN);
 
   const char *header_with_curly_brace =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Foo}Foo: some_value\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(header_with_curly_brace, HPE_INVALID_HEADER_TOKEN);
 
   const char *header_with_quote =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Foo\"Foo: some_value\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(header_with_quote, HPE_INVALID_HEADER_TOKEN);
 
   const char *header_with_forward_slash =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Foo/Foo: some_value\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(header_with_forward_slash, HPE_INVALID_HEADER_TOKEN);
 
   const char *header_with_trailing_space =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "X-Some-Header : some_value\r\n"
     "\r\n";
   test_simple(header_with_trailing_space, HPE_INVALID_HEADER_TOKEN);
 
   const char *bad_end_of_headers_1 =
     "GET / HTTP/1.1\r\n"
     "Host: www.example1.com\r\n"
     "X-Some-Header: some_value"
     "\r\n\r*";
   test_simple(bad_end_of_headers_1, HPE_STRICT);
 
   const char *bad_end_of_headers_2 =
     "GET / HTTP/1.1\r\n"
     "Host: www.example2.com\r\n"
     "X-Some-Header: some_value"
     "\n\r*";
   test_simple(bad_end_of_headers_2, HPE_STRICT);
 
   const char *empty_content_length_header =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Content-Length:\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(empty_content_length_header, HPE_INVALID_CONTENT_LENGTH);
 
   const char *empty_transfer_encoding_header =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Transfer-Encoding:\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(empty_transfer_encoding_header, HPE_INVALID_TRANSFER_ENCODING);
 
   const char *empty_upgrade_header =
     "GET / HTTP/1.1\r\n"
     "Host: www.example.com\r\n"
     "Upgrade:\r\n"
     "Accept-Encoding: gzip\r\n"
     "\r\n";
   test_simple(empty_upgrade_header, HPE_INVALID_UPGRADE);
 
   #if 0
   // NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body
   // until EOF.
   //
   // no content-length
   // error if there is a body without content length
   const char *bad_get_no_headers_no_body = "GET /bad_get_no_headers_no_body/world HTTP/1.1\r\n"
                                            "Accept: */*\r\n"
                                            "\r\n"
                                            "HELLO";
   test_simple(bad_get_no_headers_no_body, 0);
 #endif
   /* TODO sending junk and large headers gets rejected */
 
 
   /* check to make sure our predefined requests are okay */
   for (i = 0; requests[i].name; i++) {
     test_message(&requests[i]);
   }
 
   for (i = 0; i < request_count; i++) {
     test_message_pause(&requests[i]);
   }
 
   for (i = 0; i < request_count; i++) {
     if (!requests[i].should_keep_alive) continue;
     for (j = 0; j < request_count; j++) {
       if (!requests[j].should_keep_alive) continue;
       for (k = 0; k < request_count; k++) {
         test_multiple3(&requests[i], &requests[j], &requests[k]);
       }
     }
   }
 
   printf("request scan 1/4      ");
   test_scan( &requests[GET_NO_HEADERS_NO_BODY]
            , &requests[GET_ONE_HEADER_NO_BODY]
            , &requests[GET_NO_HEADERS_NO_BODY]
            );
 
   printf("request scan 2/4      ");
   test_scan( &requests[POST_CHUNKED_ALL_YOUR_BASE]
            , &requests[POST_IDENTITY_BODY_WORLD]
            , &requests[GET_FUNKY_CONTENT_LENGTH]
            );
 
   printf("request scan 3/4      ");
   test_scan( &requests[TWO_CHUNKS_MULT_ZERO_END]
            , &requests[CHUNKED_W_TRAILING_HEADERS]
            , &requests[CHUNKED_W_BULLSHIT_AFTER_LENGTH]
            );
 
   printf("request scan 4/4      ");
   test_scan( &requests[QUERY_URL_WITH_QUESTION_MARK_GET]
            , &requests[PREFIX_NEWLINE_GET ]
            , &requests[CONNECT_REQUEST]
            );
 
   puts("requests okay");
 
   return 0;
 }

int message_begin_cb ( http_parser * p )

Definition at line 1265 of file test.c.

References message::message_begin_cb_called, messages, and num_messages.

Referenced by pause_message_begin_cb().

 {
   assert(p == parser);
   messages[num_messages].message_begin_cb_called++;
   return 0;
 }

int message_complete_cb ( http_parser * p )

Definition at line 1286 of file test.c.

References currently_parsing_eof, message::message_complete_cb_called, message::message_complete_on_eof, messages, num_messages, and TRUE.

Referenced by pause_message_complete_cb().

 {
   assert(p == parser);
   messages[num_messages].message_complete_cb_called = TRUE;
 
   messages[num_messages].message_complete_on_eof = currently_parsing_eof;
 
   num_messages++;
   return 0;
 }

int message_eq	(	int	index,
		const struct message *	expected
	)

Definition at line 1660 of file test.c.

References message::body, message::body_size, check_str_eq(), message::chunk_lengths, message::headers, message::headers_complete_cb_called, message::http_major, message::http_minor, HTTP_REQUEST, i, m, MAX_CHUNKS, message::message_begin_cb_called, MESSAGE_CHECK_NUM_EQ, MESSAGE_CHECK_STR_EQ, message::message_complete_cb_called, message::message_complete_on_eof, messages, message::method, message::num_chunks, message::num_chunks_complete, message::num_headers, message::request_url, message::response_reason, message::status_code, message::type, and message::upgrade.

Referenced by test_message(), test_message_count_body(), test_message_pause(), test_multiple3(), and test_scan().

 {
   int i;
   struct message *m = &messages[index];
 
   MESSAGE_CHECK_NUM_EQ(expected, m, http_major);
   MESSAGE_CHECK_NUM_EQ(expected, m, http_minor);
 
   if (expected->type == HTTP_REQUEST) {
     MESSAGE_CHECK_NUM_EQ(expected, m, method);
   } else {
     MESSAGE_CHECK_NUM_EQ(expected, m, status_code);
     MESSAGE_CHECK_STR_EQ(expected, m, response_reason);
   }
 
   MESSAGE_CHECK_NUM_EQ(expected, m, message_complete_on_eof);
 
   assert(m->message_begin_cb_called);
   assert(m->headers_complete_cb_called);
   assert(m->message_complete_cb_called);
 
 
   MESSAGE_CHECK_STR_EQ(expected, m, request_url);
   if (expected->body_size) {
     MESSAGE_CHECK_NUM_EQ(expected, m, body_size);
   } else {
     MESSAGE_CHECK_STR_EQ(expected, m, body);
   }
 
   MESSAGE_CHECK_NUM_EQ(expected, m, num_chunks);
   MESSAGE_CHECK_NUM_EQ(expected, m, num_chunks_complete);
   for (i = 0; i < m->num_chunks && i < MAX_CHUNKS; i++) {
     MESSAGE_CHECK_NUM_EQ(expected, m, chunk_lengths[i]);
   }
 
   MESSAGE_CHECK_NUM_EQ(expected, m, num_headers);
 
   int r;
   for (i = 0; i < m->num_headers; i++) {
     r = check_str_eq(expected, "header field", expected->headers[i][0], m->headers[i][0]);
     if (!r) return 0;
     r = check_str_eq(expected, "header value", expected->headers[i][1], m->headers[i][1]);
     if (!r) return 0;
   }
 
   MESSAGE_CHECK_STR_EQ(expected, m, upgrade);
 
   return 1;
 }

size_t parse	(	const char *	buf,
		size_t	len
	)

Definition at line 1591 of file test.c.

References currently_parsing_eof, and http_parser_execute().

Referenced by folly::DynamicParser::arrayItems(), HTTP2FramerTest::dataFrameTest(), folly::DynamicParser::objectItems(), folly::DynamicParser::optional(), HTTP2FramerTest::parse(), parseSPDY(), folly::DynamicParser::required(), folly::DynamicParser::setAllowNonStringKeyErrors(), TEST(), TEST_F(), test_message(), test_multiple3(), test_on_message_begin_cb(), test_scan(), test_simple(), and proxygen::RFC1867Base::testSimple().

 {
   size_t nparsed;
   currently_parsing_eof = (len == 0);
   nparsed = http_parser_execute(parser, &settings, buf, len);
   return nparsed;
 }

size_t parse_count_body	(	const char *	buf,
		size_t	len
	)

Definition at line 1599 of file test.c.

References currently_parsing_eof, and http_parser_execute().

Referenced by test_message_count_body().

 {
   size_t nparsed;
   currently_parsing_eof = (len == 0);
   nparsed = http_parser_execute(parser, &settings_count_body, buf, len);
   return nparsed;
 }

size_t parse_pause	(	const char *	buf,
		size_t	len
	)

Definition at line 1607 of file test.c.

References currently_parsing_eof, http_parser_execute(), s, and settings_pause.

Referenced by test_message_pause().

 {
   size_t nparsed;
   http_parser_settings s = settings_pause;
 
   currently_parsing_eof = (len == 0);
   current_pause_parser = &s;
   nparsed = http_parser_execute(parser, current_pause_parser, buf, len);
   return nparsed;
 }

void parser_free ( )

Definition at line 1584 of file test.c.

References bm::free().

Referenced by test_message(), test_message_count_body(), test_message_pause(), test_multiple3(), test_on_message_begin_cb(), test_scan(), and test_simple().

 {
   assert(parser);
   free(parser);
   parser = NULL;
 }

void parser_init ( enum http_parser_type type )

Definition at line 1569 of file test.c.

References http_parser_init(), messages, and num_messages.

Referenced by test_message(), test_message_count_body(), test_message_pause(), test_multiple3(), test_on_message_begin_cb(), test_scan(), and test_simple().

 {
   num_messages = 0;
 
   assert(parser == NULL);
 
   parser = malloc(sizeof(http_parser));
 
   http_parser_init(parser, type);
 
   memset(&messages, 0, sizeof messages);
 
 }

int pause_body_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1466 of file test.c.

References body_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return body_cb(p, buf, len);
 }

int pause_chunk_complete_cb ( http_parser * p )

Definition at line 1506 of file test.c.

References chunk_complete_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return chunk_complete_cb(p);
 }

int pause_chunk_header_cb ( http_parser * p )

Definition at line 1498 of file test.c.

References chunk_header_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return chunk_header_cb(p);
 }

int pause_header_field_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1442 of file test.c.

References header_field_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return header_field_cb(p, buf, len);
 }

int pause_header_value_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1450 of file test.c.

References header_value_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return header_value_cb(p, buf, len);
 }

int pause_headers_complete_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1474 of file test.c.

References headers_complete_cb(), http_parser_pause(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return headers_complete_cb(p, buf, len);
 }

int pause_message_begin_cb ( http_parser * p )

Definition at line 1434 of file test.c.

References http_parser_pause(), message_begin_cb(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return message_begin_cb(p);
 }

int pause_message_complete_cb ( http_parser * p )

Definition at line 1482 of file test.c.

References http_parser_pause(), message_complete_cb(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return message_complete_cb(p);
 }

int pause_request_url_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1458 of file test.c.

References http_parser_pause(), request_url_cb(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return request_url_cb(p, buf, len);
 }

int pause_response_reason_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1490 of file test.c.

References http_parser_pause(), response_reason_cb(), and settings_dontcall.

 {
   http_parser_pause(p, 1);
   *current_pause_parser = settings_dontcall;
   return response_reason_cb(p, buf, len);
 }

static void print_error	(	const char *	raw,
		size_t	error_location
	)

static

Definition at line 1775 of file test.c.

References http_errno_description(), HTTP_PARSER_ERRNO, HTTP_PARSER_ERRNO_LINE, and i.

Referenced by test_message(), test_message_count_body(), test_multiple3(), and test_scan().

 {
   fprintf(stderr, "\n*** %s:%d -- %s ***\n\n",
           "http_parser.c", HTTP_PARSER_ERRNO_LINE(parser),
           http_errno_description(HTTP_PARSER_ERRNO(parser)));
 
   int this_line = 0, char_len = 0;
   size_t i, j, len = strlen(raw), error_location_line = 0;
   for (i = 0; i < len; i++) {
     if (i == error_location) this_line = 1;
     switch (raw[i]) {
       case '\r':
         char_len = 2;
         fprintf(stderr, "\\r");
         break;
 
       case '\n':
         char_len = 2;
         fprintf(stderr, "\\n\n");
 
         if (this_line) goto print;
 
         error_location_line = 0;
         continue;
 
       default:
         char_len = 1;
         fputc(raw[i], stderr);
         break;
     }
     if (!this_line) error_location_line += char_len;
   }
 
   fprintf(stderr, "[eof]\n");
 
  print:
   for (j = 0; j < error_location_line; j++) {
     fputc(' ', stderr);
   }
   fprintf(stderr, "^\n\nerror location: %u\n", (unsigned int)error_location);
 }

int request_url_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1204 of file test.c.

References messages, num_messages, and message::request_url.

Referenced by pause_request_url_cb().

 {
   assert(p == parser);
   strncat(messages[num_messages].request_url, buf, len);
   return 0;
 }

int response_reason_cb	(	http_parser *	p,
		const char *	buf,
		size_t	len
	)

Definition at line 1298 of file test.c.

References messages, num_messages, and message::response_reason.

Referenced by pause_response_reason_cb().

 {
   assert(p == parser);
   strncat(messages[num_messages].response_reason, buf, len);
   return 0;
 }

void test_header_overflow_error ( int req )

Definition at line 2504 of file test.c.

References HPE_HEADER_OVERFLOW, HTTP_PARSER_ERRNO, http_parser_execute(), http_parser_init(), HTTP_REQUEST, HTTP_RESPONSE, i, and parser.

Referenced by main().

 {
   http_parser parser;
   http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
   size_t parsed;
   const char *buf;
   buf = req ? "GET / HTTP/1.1\r\n" : "HTTP/1.0 200 OK\r\n";
   parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
   assert(parsed == strlen(buf));
 
   buf = "header-key: header-value\r\n";
   size_t buflen = strlen(buf);
 
   int i;
   for (i = 0; i < 10000; i++) {
     parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
     if (parsed != buflen) {
       //fprintf(stderr, "error found on iter %d\n", i);
       assert(HTTP_PARSER_ERRNO(&parser) == HPE_HEADER_OVERFLOW);
       return;
     }
   }
 
   fprintf(stderr, "\n*** Error expected but none in header overflow test ***\n");
   exit(1);
 }

void test_message ( const struct message * message )

Definition at line 2377 of file test.c.

References message_eq(), messages, message::name, num_messages, parse(), parser_free(), parser_init(), print_error(), message::raw, fizz::detail::read(), test(), message::type, message::upgrade, and http_parser::upgrade.

Referenced by main().

 {
   size_t raw_len = strlen(message->raw);
   size_t msg1len;
   for (msg1len = 0; msg1len < raw_len; msg1len++) {
     parser_init(message->type);
 
     size_t read;
     const char *msg1 = message->raw;
     const char *msg2 = msg1 + msg1len;
     size_t msg2len = raw_len - msg1len;
 
     if (msg1len) {
       read = parse(msg1, msg1len);
 
       if (message->upgrade && parser->upgrade && num_messages > 0) {
         messages[num_messages - 1].upgrade = msg1 + read;
         goto test;
       }
 
       if (read != msg1len) {
         print_error(msg1, read);
         exit(1);
       }
     }
 
 
     read = parse(msg2, msg2len);
 
     if (message->upgrade && parser->upgrade) {
       messages[num_messages - 1].upgrade = msg2 + read;
       goto test;
     }
 
     if (read != msg2len) {
       print_error(msg2, read);
       exit(1);
     }
 
     read = parse(NULL, 0);
 
     if (read != 0) {
       print_error(message->raw, read);
       exit(1);
     }
 
   test:
 
     if (num_messages != 1) {
       printf("\n*** num_messages != 1 after testing '%s' ***\n\n", message->name);
       exit(1);
     }
 
     if(!message_eq(0, message)) exit(1);
 
     parser_free();
   }
 }

void test_message_count_body ( const struct message * message )

Definition at line 2437 of file test.c.

References i, message_eq(), MIN, message::name, num_messages, parse_count_body(), parser_free(), parser_init(), print_error(), message::raw, fizz::detail::read(), and message::type.

Referenced by main().

 {
   parser_init(message->type);
 
   size_t read;
   size_t l = strlen(message->raw);
   size_t i, toread;
   size_t chunk = 4024;
 
   for (i = 0; i < l; i+= chunk) {
     toread = MIN(l-i, chunk);
     read = parse_count_body(message->raw + i, toread);
     if (read != toread) {
       print_error(message->raw, read);
       exit(1);
     }
   }
 
 
   read = parse_count_body(NULL, 0);
   if (read != 0) {
     print_error(message->raw, read);
     exit(1);
   }
 
   if (num_messages != 1) {
     printf("\n*** num_messages != 1 after testing '%s' ***\n\n", message->name);
     exit(1);
   }
 
   if(!message_eq(0, message)) exit(1);
 
   parser_free();
 }

void test_message_pause ( const struct message * msg )

Definition at line 2771 of file test.c.

References HPE_PAUSED, HPE_STRICT, HTTP_PARSER_ERRNO, http_parser_pause(), message::message_complete_cb_called, message_eq(), messages, message::name, num_messages, parse_pause(), parser_free(), parser_init(), message::raw, test(), message::type, message::upgrade, and http_parser::upgrade.

Referenced by main().

 {
   char *buf = (char*) msg->raw;
   size_t buflen = strlen(msg->raw);
   size_t nread;
 
   parser_init(msg->type);
 
   do {
     nread = parse_pause(buf, buflen);
 
     // We can only set the upgrade buffer once we've gotten our message
     // completion callback.
     if (messages[0].message_complete_cb_called &&
         msg->upgrade &&
         parser->upgrade) {
       messages[0].upgrade = buf + nread;
       goto test;
     }
 
     if (nread < buflen) {
 
       // Not much do to if we failed a strict-mode check
       if (HTTP_PARSER_ERRNO(parser) == HPE_STRICT) {
         parser_free();
         return;
       }
 
       assert (HTTP_PARSER_ERRNO(parser) == HPE_PAUSED);
     }
 
     buf += nread;
     buflen -= nread;
     http_parser_pause(parser, 0);
   } while (buflen > 0);
 
   nread = parse_pause(NULL, 0);
   assert (nread == 0);
 
 test:
   if (num_messages != 1) {
     printf("\n*** num_messages != 1 after testing '%s' ***\n\n", msg->name);
     exit(1);
   }
 
   if(!message_eq(0, msg)) exit(1);
 
   parser_free();
 }

void test_multiple3	(	const struct message *	r1,
		const struct message *	r2,
		const struct message *	r3
	)

Definition at line 2565 of file test.c.

References count_parsed_messages(), message_eq(), num_messages, parse(), parser_free(), parser_init(), print_error(), message::raw, fizz::detail::read(), test(), message::type, http_parser::upgrade, and upgrade_message_fix().

Referenced by main().

 {
   int message_count = count_parsed_messages(3, r1, r2, r3);
 
   char total[ strlen(r1->raw)
             + strlen(r2->raw)
             + strlen(r3->raw)
             + 1
             ];
   total[0] = '\0';
 
   strcat(total, r1->raw);
   strcat(total, r2->raw);
   strcat(total, r3->raw);
 
   parser_init(r1->type);
 
   size_t read;
 
   read = parse(total, strlen(total));
 
   if (parser->upgrade) {
     upgrade_message_fix(total, read, 3, r1, r2, r3);
     goto test;
   }
 
   if (read != strlen(total)) {
     print_error(total, read);
     exit(1);
   }
 
   read = parse(NULL, 0);
 
   if (read != 0) {
     print_error(total, read);
     exit(1);
   }
 
 test:
 
   if (message_count != num_messages) {
     fprintf(stderr, "\n\n*** Parser didn't see 3 messages only %d *** \n", num_messages);
     exit(1);
   }
 
   if (!message_eq(0, r1)) exit(1);
   if (message_count > 1 && !message_eq(1, r2)) exit(1);
   if (message_count > 2 && !message_eq(2, r3)) exit(1);
 
   parser_free();
 }

void test_no_overflow_long_body	(	int	req,
		size_t	length
	)

Definition at line 2532 of file test.c.

References http_parser_execute(), http_parser_init(), HTTP_REQUEST, HTTP_RESPONSE, i, and parser.

Referenced by main().

 {
   http_parser parser;
   http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
   size_t parsed;
   size_t i;
   char buf1[3000];
   size_t buf1len = sprintf(buf1, "%s\r\nConnection: Keep-Alive\r\nContent-Length: %zu\r\n\r\n",
       req ? "POST / HTTP/1.0" : "HTTP/1.0 200 OK", length);
   parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
   if (parsed != buf1len)
     goto err;
 
   for (i = 0; i < length; i++) {
     char foo = 'a';
     parsed = http_parser_execute(&parser, &settings_null, &foo, 1);
     if (parsed != 1)
       goto err;
   }
 
   parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
   if (parsed != buf1len) goto err;
   return;
 
  err:
   fprintf(stderr,
           "\n*** error in test_no_overflow_long_body %s of length %zu ***\n",
           req ? "REQUEST" : "RESPONSE",
           length);
   exit(1);
 }

void test_on_message_begin_cb ( const struct message * message )

Definition at line 2824 of file test.c.

References message::message_begin_cb_called, messages, num_messages, parse(), parser_free(), parser_init(), message::raw, and message::type.

Referenced by main().

 {
   parser_init(message->type);
   assert(messages[num_messages].message_begin_cb_called == 0);
   parse(message->raw, strlen(message->raw));
   assert(messages[num_messages].message_begin_cb_called == 1);
   parser_free();
 }

void test_parse_url ( void )

Definition at line 2330 of file test.c.

References dump_url(), http_parser_parse_url(), i, url_test::is_connect, url_test::name, url_test::rv, test(), url_test::u, url_test::url, and url_tests.

Referenced by main().

 {
   struct http_parser_url u;
   const struct url_test *test;
   unsigned int i;
   int rv;
 
   for (i = 0; i < (sizeof(url_tests) / sizeof(url_tests[0])); i++) {
     test = &url_tests[i];
     memset(&u, 0, sizeof(u));
 
     rv = http_parser_parse_url(test->url,
                                strlen(test->url),
                                test->is_connect,
                                &u);
 
     if (test->rv == 0) {
       if (rv != 0) {
         printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
                "unexpected rv %d ***\n\n", test->url, test->name, rv);
         abort();
       }
 
       if (memcmp(&u, &test->u, sizeof(u)) != 0) {
         printf("\n*** http_parser_parse_url(\"%s\") \"%s\" failed ***\n",
                test->url, test->name);
 
         printf("target http_parser_url:\n");
         dump_url(test->url, &test->u);
         printf("result http_parser_url:\n");
         dump_url(test->url, &u);
 
         abort();
       }
     } else {
       /* test->rv != 0 */
       if (rv == 0) {
         printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
                "unexpected rv %d ***\n\n", test->url, test->name, rv);
         abort();
       }
     }
   }
 }

void test_scan	(	const struct message *	r1,
		const struct message *	r2,
		const struct message *	r3
	)

Definition at line 2622 of file test.c.

References count_parsed_messages(), folly::pushmi::operators::error(), HTTP_BOTH, i, message_eq(), num_messages, ops, parse(), parser_free(), parser_init(), print_error(), message::raw, fizz::detail::read(), test(), message::type, http_parser::upgrade, and upgrade_message_fix().

Referenced by main().

 {
   char total[80*1024] = "\0";
   char buf1[80*1024] = "\0";
   char buf2[80*1024] = "\0";
   char buf3[80*1024] = "\0";
 
   strcat(total, r1->raw);
   strcat(total, r2->raw);
   strcat(total, r3->raw);
 
   size_t read;
 
   int total_len = strlen(total);
 
   int total_ops = 2 * (total_len - 1) * (total_len - 2) / 2;
   int ops = 0 ;
 
   size_t buf1_len, buf2_len, buf3_len;
   int message_count = count_parsed_messages(3, r1, r2, r3);
 
   int i,j,type_both;
   for (type_both = 0; type_both < 2; type_both ++ ) {
     for (j = 2; j < total_len; j ++ ) {
       for (i = 1; i < j; i ++ ) {
 
         if (ops % 1000 == 0)  {
           printf("\b\b\b\b%3.0f%%", 100 * (float)ops /(float)total_ops);
           fflush(stdout);
         }
         ops += 1;
 
         parser_init(type_both ? HTTP_BOTH : r1->type);
 
         buf1_len = i;
         strncpy(buf1, total, buf1_len);
         buf1[buf1_len] = 0;
 
         buf2_len = j - i;
         strncpy(buf2, total+i, buf2_len);
         buf2[buf2_len] = 0;
 
         buf3_len = total_len - j;
         strncpy(buf3, total+j, buf3_len);
         buf3[buf3_len] = 0;
 
         read = parse(buf1, buf1_len);
 
         if (parser->upgrade) goto test;
 
         if (read != buf1_len) {
           print_error(buf1, read);
           goto error;
         }
 
         read += parse(buf2, buf2_len);
 
         if (parser->upgrade) goto test;
 
         if (read != buf1_len + buf2_len) {
           print_error(buf2, read);
           goto error;
         }
 
         read += parse(buf3, buf3_len);
         if (parser->upgrade) goto test;
 
         if (read != buf1_len + buf2_len + buf3_len) {
           print_error(buf3, read);
           goto error;
         }
 
         parse(NULL, 0);
 
 test:
         if (parser->upgrade) {
           upgrade_message_fix(total, read, 3, r1, r2, r3);
         }
 
         if (message_count != num_messages) {
           fprintf(stderr, "\n\nParser didn't see %d messages only %d\n",
             message_count, num_messages);
           goto error;
         }
 
         if (!message_eq(0, r1)) {
           fprintf(stderr, "\n\nError matching messages[0] in test_scan.\n");
           goto error;
         }
 
         if (message_count > 1 && !message_eq(1, r2)) {
           fprintf(stderr, "\n\nError matching messages[1] in test_scan.\n");
           goto error;
         }
 
         if (message_count > 2 && !message_eq(2, r3)) {
           fprintf(stderr, "\n\nError matching messages[2] in test_scan.\n");
           goto error;
         }
 
         parser_free();
       }
     }
   }
   puts("\b\b\b\b100%");
   return;
 
  error:
   fprintf(stderr, "i=%d  j=%d\n", i, j);
   fprintf(stderr, "buf1 (%u) %s\n\n", (unsigned int)buf1_len, buf1);
   fprintf(stderr, "buf2 (%u) %s\n\n", (unsigned int)buf2_len , buf2);
   fprintf(stderr, "buf3 (%u) %s\n", (unsigned int)buf3_len, buf3);
   exit(1);
 }

void test_simple	(	const char *	buf,
		enum http_errno	err_expected
	)

Definition at line 2473 of file test.c.

References HPE_OK, HPE_STRICT, http_errno_name(), HTTP_PARSER_ERRNO, HTTP_REQUEST, parse(), parser_free(), and parser_init().

Referenced by main().

 {
   parser_init(HTTP_REQUEST);
 
   size_t parsed;
   int pass;
   enum http_errno err;
 
   parsed = parse(buf, strlen(buf));
   pass = (parsed == strlen(buf));
   err = HTTP_PARSER_ERRNO(parser);
   parsed = parse(NULL, 0);
   pass &= (parsed == 0);
 
   parser_free();
 
   /* In strict mode, allow us to pass with an unexpected HPE_STRICT as
    * long as the caller isn't expecting success.
    */
 #if HTTP_PARSER_STRICT
   if (err_expected != err && err_expected != HPE_OK && err != HPE_STRICT) {
 #else
   if (err_expected != err) {
 #endif
     fprintf(stderr, "\n*** test_simple expected %s, but saw %s ***\n\n%s\n",
         http_errno_name(err_expected), http_errno_name(err), buf);
     exit(1);
   }
 }

void upgrade_message_fix	(	char *	body,
		const size_t	nread,
		const size_t	nmsgs,
			...
	)

Definition at line 1738 of file test.c.

References check_str_eq(), i, m, messages, num_messages, message::raw, and message::upgrade.

Referenced by test_multiple3(), and test_scan().

                                                                              {
   va_list ap;
   size_t i;
   size_t off = 0;
 
   va_start(ap, nmsgs);
 
   for (i = 0; i < nmsgs; i++) {
     struct message *m = va_arg(ap, struct message *);
 
     off += strlen(m->raw);
 
     if (m->upgrade) {
       off -= strlen(m->upgrade);
 
       /* Check the portion of the response after its specified upgrade */
       if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
         exit(1);
       }
 
       /* Fix up the response so that message_eq() will verify the beginning
        * of the upgrade */
       *(body + nread + strlen(m->upgrade)) = '\0';
       messages[num_messages -1 ].upgrade = body + nread;
 
       va_end(ap);
       return;
     }
   }
 
   va_end(ap);
   printf("\n\n*** Error: expected a message with upgrade ***\n");
 
   exit(1);
 }

Variable Documentation

http_parser_settings* current_pause_parser

static

Definition at line 77 of file test.c.

int currently_parsing_eof

static

Definition at line 73 of file test.c.

Referenced by message_complete_cb(), parse(), parse_count_body(), and parse_pause().

struct message messages[5]

static

int num_messages

static

Definition at line 76 of file test.c.

Referenced by body_cb(), chunk_complete_cb(), chunk_header_cb(), count_body_cb(), header_field_cb(), header_value_cb(), headers_complete_cb(), message_begin_cb(), message_complete_cb(), parser_init(), request_url_cb(), response_reason_cb(), test_message(), test_message_count_body(), test_message_pause(), test_multiple3(), test_on_message_begin_cb(), test_scan(), and upgrade_message_fix().

const struct message on_message_begin_cb_test[]

Definition at line 1138 of file test.c.

http_parser* parser

static

Definition at line 40 of file test.c.

Referenced by folly::getGFlags(), test_header_overflow_error(), and test_no_overflow_long_body().

const struct message requests[]

Definition at line 80 of file test.c.

const struct message responses[]

Definition at line 791 of file test.c.

http_parser_settings settings

static

Initial value:

=
  {.on_message_begin = message_begin_cb
  ,.on_header_field = header_field_cb
  ,.on_header_value = header_value_cb
  ,.on_url = request_url_cb
  ,.on_body = body_cb
  ,.on_headers_complete = headers_complete_cb
  ,.on_message_complete = message_complete_cb
  ,.on_reason = response_reason_cb
  ,.on_chunk_header = chunk_header_cb
  ,.on_chunk_complete = chunk_complete_cb
  }

Definition at line 1529 of file test.c.

Referenced by proxygen::HTTPSessionBase::enableExHeadersSettings(), HTTPDownstreamTest< SPDY3_1CodecPair >::expectResponses(), proxygen::HTTP2Codec::generateSettings(), proxygen::HTTPSession::getCodecSendWindowSize(), proxygen::HTTP2Codec::getHeaderIndexingStrategy(), proxygen::HTTPSession::getSecurityProtocol(), proxygen::SPDYCodec::onControlFrame(), proxygen::HTTP2Codec::onIngressUpgradeMessage(), proxygen::HTTPSession::onNativeProtocolUpgradeImpl(), proxygen::HTTP2Codec::parseSettings(), proxygen::http2::parseSettings(), proxygen::PassThroughHTTPCodecFilter::PassThroughHTTPCodecFilter(), proxygen::HTTPSession::setEgressSettings(), proxygen::HTTPSession::setFlowControl(), proxygen::HTTPSession::setMaxConcurrentIncomingStreams(), proxygen::HTTPSession::setupCodec(), proxygen::HTTPDownstreamSession::setupOnHeadersComplete(), TEST(), TEST_F(), HTTP2CodecTest::testFrameSizeLimit(), HTTP2CodecTest::testHeaderListSize(), and TYPED_TEST_P().

http_parser_settings settings_count_body

static

Initial value:

=
  {.on_message_begin = message_begin_cb
  ,.on_header_field = header_field_cb
  ,.on_header_value = header_value_cb
  ,.on_url = request_url_cb
  ,.on_body = count_body_cb
  ,.on_headers_complete = headers_complete_cb
  ,.on_message_complete = message_complete_cb
  ,.on_reason = response_reason_cb
  ,.on_chunk_header = chunk_header_cb
  ,.on_chunk_complete = chunk_complete_cb
  }

Definition at line 1542 of file test.c.

http_parser_settings settings_dontcall

static

Initial value:

=
  {.on_message_begin = dontcall_message_begin_cb
  ,.on_header_field = dontcall_header_field_cb
  ,.on_header_value = dontcall_header_value_cb
  ,.on_url = dontcall_request_url_cb
  ,.on_body = dontcall_body_cb
  ,.on_headers_complete = dontcall_headers_complete_cb
  ,.on_message_complete = dontcall_message_complete_cb
  ,.on_reason = dontcall_response_reason_cb
  ,.on_chunk_header = dontcall_chunk_header_cb
  ,.on_chunk_complete = dontcall_chunk_complete_cb
  }

Definition at line 1416 of file test.c.

Referenced by pause_body_cb(), pause_chunk_complete_cb(), pause_chunk_header_cb(), pause_header_field_cb(), pause_header_value_cb(), pause_headers_complete_cb(), pause_message_begin_cb(), pause_message_complete_cb(), pause_request_url_cb(), and pause_response_reason_cb().

http_parser_settings settings_null

static

Initial value:

=
  {.on_message_begin = empty_cb
  ,.on_header_field = empty_data_cb
  ,.on_header_value = empty_data_cb
  ,.on_url = empty_data_cb
  ,.on_body = empty_data_cb
  ,.on_headers_complete = empty_data_cb
  ,.on_message_complete = empty_cb
  ,.on_reason = empty_data_cb
  ,.on_chunk_header = empty_cb
  ,.on_chunk_complete = empty_cb
  }

Definition at line 1555 of file test.c.

http_parser_settings settings_pause

static

Initial value:

=
  {.on_message_begin = pause_message_begin_cb
  ,.on_header_field = pause_header_field_cb
  ,.on_header_value = pause_header_value_cb
  ,.on_url = pause_request_url_cb
  ,.on_body = pause_body_cb
  ,.on_headers_complete = pause_headers_complete_cb
  ,.on_message_complete = pause_message_complete_cb
  ,.on_reason = pause_response_reason_cb
  ,.on_chunk_header = pause_chunk_header_cb
  ,.on_chunk_complete = pause_chunk_complete_cb
  }

Definition at line 1516 of file test.c.

Referenced by parse_pause().

const struct url_test url_tests[]

Definition at line 1826 of file test.c.

Referenced by test_parse_url().

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation