Peter M. Groen / openbr

Browse Code »

Commit 6f90f78bc0f6f503d2ac749dc5be7c01162efb1d

Authored by Josh Klontz 2021-09-02 11:30:42 -0600

1 parent 2d6ccbf1

removed http-parser

Inline Side-by-side

Showing 14 changed files with 0 additions and 6572 deletions

3rdparty/http-parser-2.1/.gitignore deleted

View file @2d6ccbf

1	-/out/
2	-core
3	-tags
4	-*.o
5	-test
6	-test_g
7	-test_fast
8	-url_parser
9	-parsertrace
10	-parsertrace_g
11	-*.mk
12	-*.Makefile
13	-*.so
14	-*.a

3rdparty/http-parser-2.1/.mailmap deleted

View file @2d6ccbf

1	-# update AUTHORS with:
2	-# git log --all --reverse --format='%aN <%aE>' \| perl -ne 'BEGIN{print "# Authors ordered by first contribution.\n"} print unless $h{$_}; $h{$_} = 1' > AUTHORS
3	-Ryan Dahl <ry@tinyclouds.org>
4	-Salman Haq <salman.haq@asti-usa.com>
5	-Simon Zimmermann <simonz05@gmail.com>
6	-Thomas LE ROUX <thomas@november-eleven.fr> LE ROUX Thomas <thomas@procheo.fr>
7	-Thomas LE ROUX <thomas@november-eleven.fr> Thomas LE ROUX <thomas@procheo.fr>

3rdparty/http-parser-2.1/.travis.yml deleted

View file @2d6ccbf

1	-language: c
2	-
3	-compiler:
4	- - clang
5	- - gcc
6	-
7	-script:
8	- - "make"
9	-
10	-notifications:
11	- email: false
12	- irc:
13	- - "irc.freenode.net#libuv"

3rdparty/http-parser-2.1/AUTHORS deleted

View file @2d6ccbf

1	-# Authors ordered by first contribution.
2	-Ryan Dahl <ry@tinyclouds.org>
3	-Jeremy Hinegardner <jeremy@hinegardner.org>
4	-Sergey Shepelev <temotor@gmail.com>
5	-Joe Damato <ice799@gmail.com>
6	-tomika <tomika_nospam@freemail.hu>
7	-Phoenix Sol <phoenix@burninglabs.com>
8	-Cliff Frey <cliff@meraki.com>
9	-Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
10	-Santiago Gala <sgala@apache.org>
11	-Tim Becker <tim.becker@syngenio.de>
12	-Jeff Terrace <jterrace@gmail.com>
13	-Ben Noordhuis <info@bnoordhuis.nl>
14	-Nathan Rajlich <nathan@tootallnate.net>
15	-Mark Nottingham <mnot@mnot.net>
16	-Aman Gupta <aman@tmm1.net>
17	-Tim Becker <tim.becker@kuriositaet.de>
18	-Sean Cunningham <sean.cunningham@mandiant.com>
19	-Peter Griess <pg@std.in>
20	-Salman Haq <salman.haq@asti-usa.com>
21	-Cliff Frey <clifffrey@gmail.com>
22	-Jon Kolb <jon@b0g.us>
23	-Fouad Mardini <f.mardini@gmail.com>
24	-Paul Querna <pquerna@apache.org>
25	-Felix Geisendörfer <felix@debuggable.com>
26	-koichik <koichik@improvement.jp>
27	-Andre Caron <andre.l.caron@gmail.com>
28	-Ivo Raisr <ivosh@ivosh.net>
29	-James McLaughlin <jamie@lacewing-project.org>
30	-David Gwynne <loki@animata.net>
31	-Thomas LE ROUX <thomas@november-eleven.fr>
32	-Randy Rizun <rrizun@ortivawireless.com>
33	-Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
34	-Simon Zimmermann <simonz05@gmail.com>
35	-Erik Dubbelboer <erik@dubbelboer.com>
36	-Martell Malone <martellmalone@gmail.com>
37	-Bertrand Paquet <bpaquet@octo.com>
38	-BogDan Vatra <bogdan@kde.org>
39	-Peter Faiman <peter@thepicard.org>
40	-Corey Richardson <corey@octayn.net>
41	-Tóth Tamás <tomika_nospam@freemail.hu>

3rdparty/http-parser-2.1/CONTRIBUTIONS deleted

View file @2d6ccbf

1	-Contributors must agree to the Contributor License Agreement before patches
2	-can be accepted.
3	-
4	-http://spreadsheets2.google.com/viewform?hl=en&formkey=dDJXOGUwbzlYaWM4cHN1MERwQS1CSnc6MQ

3rdparty/http-parser-2.1/LICENSE-MIT deleted

View file @2d6ccbf

1	-http_parser.c is based on src/http/ngx_http_parse.c from NGINX copyright
2	-Igor Sysoev.
3	-
4	-Additional changes are licensed under the same terms as NGINX and
5	-copyright Joyent, Inc. and other Node contributors. All rights reserved.
6	-
7	-Permission is hereby granted, free of charge, to any person obtaining a copy
8	-of this software and associated documentation files (the "Software"), to
9	-deal in the Software without restriction, including without limitation the
10	-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
11	-sell copies of the Software, and to permit persons to whom the Software is
12	-furnished to do so, subject to the following conditions:
13	-
14	-The above copyright notice and this permission notice shall be included in
15	-all copies or substantial portions of the Software.
16	-
17	-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18	-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19	-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20	-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21	-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22	-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23	-IN THE SOFTWARE.

3rdparty/http-parser-2.1/Makefile deleted

View file @2d6ccbf

1	-CC?=gcc
2	-AR?=ar
3	-
4	-CPPFLAGS += -I.
5	-CPPFLAGS_DEBUG = $(CPPFLAGS) -DHTTP_PARSER_STRICT=1
6	-CPPFLAGS_DEBUG += $(CPPFLAGS_DEBUG_EXTRA)
7	-CPPFLAGS_FAST = $(CPPFLAGS) -DHTTP_PARSER_STRICT=0
8	-CPPFLAGS_FAST += $(CPPFLAGS_FAST_EXTRA)
9	-
10	-CFLAGS += -Wall -Wextra -Werror
11	-CFLAGS_DEBUG = $(CFLAGS) -O0 -g $(CFLAGS_DEBUG_EXTRA)
12	-CFLAGS_FAST = $(CFLAGS) -O3 $(CFLAGS_FAST_EXTRA)
13	-CFLAGS_LIB = $(CFLAGS_FAST) -fPIC
14	-
15	-test: test_g test_fast
16	- ./test_g
17	- ./test_fast
18	-
19	-test_g: http_parser_g.o test_g.o
20	- $(CC) $(CFLAGS_DEBUG) $(LDFLAGS) http_parser_g.o test_g.o -o $@
21	-
22	-test_g.o: test.c http_parser.h Makefile
23	- $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c test.c -o $@
24	-
25	-http_parser_g.o: http_parser.c http_parser.h Makefile
26	- $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c http_parser.c -o $@
27	-
28	-test_fast: http_parser.o test.o http_parser.h
29	- $(CC) $(CFLAGS_FAST) $(LDFLAGS) http_parser.o test.o -o $@
30	-
31	-test.o: test.c http_parser.h Makefile
32	- $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c test.c -o $@
33	-
34	-http_parser.o: http_parser.c http_parser.h Makefile
35	- $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c http_parser.c
36	-
37	-test-run-timed: test_fast
38	- while(true) do time ./test_fast > /dev/null; done
39	-
40	-test-valgrind: test_g
41	- valgrind ./test_g
42	-
43	-libhttp_parser.o: http_parser.c http_parser.h Makefile
44	- $(CC) $(CPPFLAGS_FAST) $(CFLAGS_LIB) -c http_parser.c -o libhttp_parser.o
45	-
46	-library: libhttp_parser.o
47	- $(CC) -shared -o libhttp_parser.so libhttp_parser.o
48	-
49	-package: http_parser.o
50	- $(AR) rcs libhttp_parser.a http_parser.o
51	-
52	-url_parser: http_parser.o contrib/url_parser.c
53	- $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) $^ -o $@
54	-
55	-url_parser_g: http_parser_g.o contrib/url_parser.c
56	- $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) $^ -o $@
57	-
58	-parsertrace: http_parser.o contrib/parsertrace.c
59	- $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) $^ -o parsertrace
60	-
61	-parsertrace_g: http_parser_g.o contrib/parsertrace.c
62	- $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) $^ -o parsertrace_g
63	-
64	-tags: http_parser.c http_parser.h test.c
65	- ctags $^
66	-
67	-clean:
68	- rm -f .o .a tags test test_fast test_g \
69	- http_parser.tar libhttp_parser.so \
70	- url_parser url_parser_g parsertrace parsertrace_g
71	-
72	-contrib/url_parser.c: http_parser.h
73	-contrib/parsertrace.c: http_parser.h
74	-
75	-.PHONY: clean package test-run test-run-timed test-valgrind

3rdparty/http-parser-2.1/README.md deleted

View file @2d6ccbf

1	-HTTP Parser
2	-===========
3	-
4	-[![Build Status](https://travis-ci.org/joyent/http-parser.png?branch=master)](https://travis-ci.org/joyent/http-parser)
5	-
6	-This is a parser for HTTP messages written in C. It parses both requests and
7	-responses. The parser is designed to be used in performance HTTP
8	-applications. It does not make any syscalls nor allocations, it does not
9	-buffer data, it can be interrupted at anytime. Depending on your
10	-architecture, it only requires about 40 bytes of data per message
11	-stream (in a web server that is per connection).
12	-
13	-Features:
14	-
15	- * No dependencies
16	- * Handles persistent streams (keep-alive).
17	- * Decodes chunked encoding.
18	- * Upgrade support
19	- * Defends against buffer overflow attacks.
20	-
21	-The parser extracts the following information from HTTP messages:
22	-
23	- * Header fields and values
24	- * Content-Length
25	- * Request method
26	- * Response status code
27	- * Transfer-Encoding
28	- * HTTP version
29	- * Request URL
30	- * Message body
31	-
32	-
33	-Usage
34	------
35	-
36	-One `http_parser` object is used per TCP connection. Initialize the struct
37	-using `http_parser_init()` and set the callbacks. That might look something
38	-like this for a request parser:
39	-
40	- http_parser_settings settings;
41	- settings.on_url = my_url_callback;
42	- settings.on_header_field = my_header_field_callback;
43	- /* ... */
44	-
45	- http_parser *parser = malloc(sizeof(http_parser));
46	- http_parser_init(parser, HTTP_REQUEST);
47	- parser->data = my_socket;
48	-
49	-When data is received on the socket execute the parser and check for errors.
50	-
51	- size_t len = 80*1024, nparsed;
52	- char buf[len];
53	- ssize_t recved;
54	-
55	- recved = recv(fd, buf, len, 0);
56	-
57	- if (recved < 0) {
58	- /* Handle error. */
59	- }
60	-
61	- /* Start up / continue the parser.
62	- * Note we pass recved==0 to signal that EOF has been recieved.
63	- */
64	- nparsed = http_parser_execute(parser, &settings, buf, recved);
65	-
66	- if (parser->upgrade) {
67	- /* handle new protocol */
68	- } else if (nparsed != recved) {
69	- /* Handle error. Usually just close the connection. */
70	- }
71	-
72	-HTTP needs to know where the end of the stream is. For example, sometimes
73	-servers send responses without Content-Length and expect the client to
74	-consume input (for the body) until EOF. To tell http_parser about EOF, give
75	-`0` as the forth parameter to `http_parser_execute()`. Callbacks and errors
76	-can still be encountered during an EOF, so one must still be prepared
77	-to receive them.
78	-
79	-Scalar valued message information such as `status_code`, `method`, and the
80	-HTTP version are stored in the parser structure. This data is only
81	-temporally stored in `http_parser` and gets reset on each new message. If
82	-this information is needed later, copy it out of the structure during the
83	-`headers_complete` callback.
84	-
85	-The parser decodes the transfer-encoding for both requests and responses
86	-transparently. That is, a chunked encoding is decoded before being sent to
87	-the on_body callback.
88	-
89	-
90	-The Special Problem of Upgrade
91	-------------------------------
92	-
93	-HTTP supports upgrading the connection to a different protocol. An
94	-increasingly common example of this is the Web Socket protocol which sends
95	-a request like
96	-
97	- GET /demo HTTP/1.1
98	- Upgrade: WebSocket
99	- Connection: Upgrade
100	- Host: example.com
101	- Origin: http://example.com
102	- WebSocket-Protocol: sample
103	-
104	-followed by non-HTTP data.
105	-
106	-(See http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 for more
107	-information the Web Socket protocol.)
108	-
109	-To support this, the parser will treat this as a normal HTTP message without a
110	-body. Issuing both on_headers_complete and on_message_complete callbacks. However
111	-http_parser_execute() will stop parsing at the end of the headers and return.
112	-
113	-The user is expected to check if `parser->upgrade` has been set to 1 after
114	-`http_parser_execute()` returns. Non-HTTP data begins at the buffer supplied
115	-offset by the return value of `http_parser_execute()`.
116	-
117	-
118	-Callbacks
119	----------
120	-
121	-During the `http_parser_execute()` call, the callbacks set in
122	-`http_parser_settings` will be executed. The parser maintains state and
123	-never looks behind, so buffering the data is not necessary. If you need to
124	-save certain data for later usage, you can do that from the callbacks.
125	-
126	-There are two types of callbacks:
127	-
128	-* notification `typedef int (http_cb) (http_parser);`
129	- Callbacks: on_message_begin, on_headers_complete, on_message_complete.
130	-* data `typedef int (http_data_cb) (http_parser, const char *at, size_t length);`
131	- Callbacks: (requests only) on_uri,
132	- (common) on_header_field, on_header_value, on_body;
133	-
134	-Callbacks must return 0 on success. Returning a non-zero value indicates
135	-error to the parser, making it exit immediately.
136	-
137	-In case you parse HTTP message in chunks (i.e. `read()` request line
138	-from socket, parse, read half headers, parse, etc) your data callbacks
139	-may be called more than once. Http-parser guarantees that data pointer is only
140	-valid for the lifetime of callback. You can also `read()` into a heap allocated
141	-buffer to avoid copying memory around if this fits your application.
142	-
143	-Reading headers may be a tricky task if you read/parse headers partially.
144	-Basically, you need to remember whether last header callback was field or value
145	-and apply following logic:
146	-
147	- (on_header_field and on_header_value shortened to on_h_*)
148	- ------------------------ ------------ --------------------------------------------
149	- \| State (prev. callback) \| Callback \| Description/action \|
150	- ------------------------ ------------ --------------------------------------------
151	- \| nothing (first call) \| on_h_field \| Allocate new buffer and copy callback data \|
152	- \| \| \| into it \|
153	- ------------------------ ------------ --------------------------------------------
154	- \| value \| on_h_field \| New header started. \|
155	- \| \| \| Copy current name,value buffers to headers \|
156	- \| \| \| list and allocate new buffer for new name \|
157	- ------------------------ ------------ --------------------------------------------
158	- \| field \| on_h_field \| Previous name continues. Reallocate name \|
159	- \| \| \| buffer and append callback data to it \|
160	- ------------------------ ------------ --------------------------------------------
161	- \| field \| on_h_value \| Value for current header started. Allocate \|
162	- \| \| \| new buffer and copy callback data to it \|
163	- ------------------------ ------------ --------------------------------------------
164	- \| value \| on_h_value \| Value continues. Reallocate value buffer \|
165	- \| \| \| and append callback data to it \|
166	- ------------------------ ------------ --------------------------------------------
167	-
168	-
169	-Parsing URLs
170	-------------
171	-
172	-A simplistic zero-copy URL parser is provided as `http_parser_parse_url()`.
173	-Users of this library may wish to use it to parse URLs constructed from
174	-consecutive `on_url` callbacks.
175	-
176	-See examples of reading in headers:
177	-
178	-* [partial example](http://gist.github.com/155877) in C
179	-* [from http-parser tests](http://github.com/joyent/http-parser/blob/37a0ff8/test.c#L403) in C
180	-* [from Node library](http://github.com/joyent/node/blob/842eaf4/src/http.js#L284) in Javascript

3rdparty/http-parser-2.1/contrib/parsertrace.c deleted

View file @2d6ccbf

1	-/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev
2	- *
3	- * Additional changes are licensed under the same terms as NGINX and
4	- * copyright Joyent, Inc. and other Node contributors. All rights reserved.
5	- *
6	- * Permission is hereby granted, free of charge, to any person obtaining a copy
7	- * of this software and associated documentation files (the "Software"), to
8	- * deal in the Software without restriction, including without limitation the
9	- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10	- * sell copies of the Software, and to permit persons to whom the Software is
11	- * furnished to do so, subject to the following conditions:
12	- *
13	- * The above copyright notice and this permission notice shall be included in
14	- * all copies or substantial portions of the Software.
15	- *
16	- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21	- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22	- * IN THE SOFTWARE.
23	- */
24	-
25	-/* Dump what the parser finds to stdout as it happen */
26	-
27	-#include "http_parser.h"
28	-#include <stdio.h>
29	-#include <stdlib.h>
30	-#include <string.h>
31	-
32	-int on_message_begin(http_parser* _) {
33	- (void)_;
34	- printf("\n*MESSAGE BEGIN*\n\n");
35	- return 0;
36	-}
37	-
38	-int on_headers_complete(http_parser* _) {
39	- (void)_;
40	- printf("\n*HEADERS COMPLETE*\n\n");
41	- return 0;
42	-}
43	-
44	-int on_message_complete(http_parser* _) {
45	- (void)_;
46	- printf("\n*MESSAGE COMPLETE*\n\n");
47	- return 0;
48	-}
49	-
50	-int on_url(http_parser* _, const char* at, size_t length) {
51	- (void)_;
52	- printf("Url: %.*s\n", (int)length, at);
53	- return 0;
54	-}
55	-
56	-int on_header_field(http_parser* _, const char* at, size_t length) {
57	- (void)_;
58	- printf("Header field: %.*s\n", (int)length, at);
59	- return 0;
60	-}
61	-
62	-int on_header_value(http_parser* _, const char* at, size_t length) {
63	- (void)_;
64	- printf("Header value: %.*s\n", (int)length, at);
65	- return 0;
66	-}
67	-
68	-int on_body(http_parser* _, const char* at, size_t length) {
69	- (void)_;
70	- printf("Body: %.*s\n", (int)length, at);
71	- return 0;
72	-}
73	-
74	-void usage(const char* name) {
75	- fprintf(stderr,
76	- "Usage: %s $type $filename\n"
77	- " type: -x, where x is one of {r,b,q}\n"
78	- " parses file as a Response, reQuest, or Both\n",
79	- name);
80	- exit(EXIT_FAILURE);
81	-}
82	-
83	-int main(int argc, char* argv[]) {
84	- enum http_parser_type file_type;
85	-
86	- if (argc != 3) {
87	- usage(argv[0]);
88	- }
89	-
90	- char* type = argv[1];
91	- if (type[0] != '-') {
92	- usage(argv[0]);
93	- }
94	-
95	- switch (type[1]) {
96	- /* in the case of "-", type[1] will be NUL */
97	- case 'r':
98	- file_type = HTTP_RESPONSE;
99	- break;
100	- case 'q':
101	- file_type = HTTP_REQUEST;
102	- break;
103	- case 'b':
104	- file_type = HTTP_BOTH;
105	- break;
106	- default:
107	- usage(argv[0]);
108	- }
109	-
110	- char* filename = argv[2];
111	- FILE* file = fopen(filename, "r");
112	- if (file == NULL) {
113	- perror("fopen");
114	- return EXIT_FAILURE;
115	- }
116	-
117	- fseek(file, 0, SEEK_END);
118	- long file_length = ftell(file);
119	- if (file_length == -1) {
120	- perror("ftell");
121	- return EXIT_FAILURE;
122	- }
123	- fseek(file, 0, SEEK_SET);
124	-
125	- char* data = malloc(file_length);
126	- if (fread(data, 1, file_length, file) != (size_t)file_length) {
127	- fprintf(stderr, "couldn't read entire file\n");
128	- free(data);
129	- return EXIT_FAILURE;
130	- }
131	-
132	- http_parser_settings settings;
133	- memset(&settings, 0, sizeof(settings));
134	- settings.on_message_begin = on_message_begin;
135	- settings.on_url = on_url;
136	- settings.on_header_field = on_header_field;
137	- settings.on_header_value = on_header_value;
138	- settings.on_headers_complete = on_headers_complete;
139	- settings.on_body = on_body;
140	- settings.on_message_complete = on_message_complete;
141	-
142	- http_parser parser;
143	- http_parser_init(&parser, file_type);
144	- size_t nparsed = http_parser_execute(&parser, &settings, data, file_length);
145	- free(data);
146	-
147	- if (nparsed != (size_t)file_length) {
148	- fprintf(stderr,
149	- "Error: %s (%s)\n",
150	- http_errno_description(HTTP_PARSER_ERRNO(&parser)),
151	- http_errno_name(HTTP_PARSER_ERRNO(&parser)));
152	- return EXIT_FAILURE;
153	- }
154	-
155	- return EXIT_SUCCESS;
156	-}

3rdparty/http-parser-2.1/contrib/url_parser.c deleted

View file @2d6ccbf

1	-#include "http_parser.h"
2	-#include <stdio.h>
3	-#include <string.h>
4	-
5	-void
6	-dump_url (const char url, const struct http_parser_url u)
7	-{
8	- unsigned int i;
9	-
10	- printf("\tfield_set: 0x%x, port: %u\n", u->field_set, u->port);
11	- for (i = 0; i < UF_MAX; i++) {
12	- if ((u->field_set & (1 << i)) == 0) {
13	- printf("\tfield_data[%u]: unset\n", i);
14	- continue;
15	- }
16	-
17	- printf("\tfield_data[%u]: off: %u len: %u part: \"%.*s\n",
18	- i,
19	- u->field_data[i].off,
20	- u->field_data[i].len,
21	- u->field_data[i].len,
22	- url + u->field_data[i].off);
23	- }
24	-}
25	-
26	-int main(int argc, char ** argv) {
27	- if (argc != 3) {
28	- printf("Syntax : %s connect\|get url\n", argv[0]);
29	- return 1;
30	- }
31	- struct http_parser_url u;
32	- int len = strlen(argv[2]);
33	- int connect = strcmp("connect", argv[1]) == 0 ? 1 : 0;
34	- printf("Parsing %s, connect %d\n", argv[2], connect);
35	-
36	- int result = http_parser_parse_url(argv[2], len, connect, &u);
37	- if (result != 0) {
38	- printf("Parse error : %d\n", result);
39	- return result;
40	- }
41	- printf("Parse ok, result : \n");
42	- dump_url(argv[2], &u);
43	- return 0;
44	-}
45	\ No newline at end of file	0	\ No newline at end of file

3rdparty/http-parser-2.1/http_parser.c deleted

View file @2d6ccbf

1	-/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev
2	- *
3	- * Additional changes are licensed under the same terms as NGINX and
4	- * copyright Joyent, Inc. and other Node contributors. All rights reserved.
5	- *
6	- * Permission is hereby granted, free of charge, to any person obtaining a copy
7	- * of this software and associated documentation files (the "Software"), to
8	- * deal in the Software without restriction, including without limitation the
9	- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10	- * sell copies of the Software, and to permit persons to whom the Software is
11	- * furnished to do so, subject to the following conditions:
12	- *
13	- * The above copyright notice and this permission notice shall be included in
14	- * all copies or substantial portions of the Software.
15	- *
16	- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21	- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22	- * IN THE SOFTWARE.
23	- */
24	-#include "http_parser.h"
25	-#include <assert.h>
26	-#include <stddef.h>
27	-#include <ctype.h>
28	-#include <stdlib.h>
29	-#include <string.h>
30	-#include <limits.h>
31	-
32	-#ifndef ULLONG_MAX
33	-# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */
34	-#endif
35	-
36	-#ifndef MIN
37	-# define MIN(a,b) ((a) < (b) ? (a) : (b))
38	-#endif
39	-
40	-#ifndef ARRAY_SIZE
41	-# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
42	-#endif
43	-
44	-#ifndef BIT_AT
45	-# define BIT_AT(a, i) \
46	- (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \
47	- (1 << ((unsigned int) (i) & 7))))
48	-#endif
49	-
50	-#ifndef ELEM_AT
51	-# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v))
52	-#endif
53	-
54	-#define SET_ERRNO(e) \
55	-do { \
56	- parser->http_errno = (e); \
57	-} while(0)
58	-
59	-
60	-/* Run the notify callback FOR, returning ER if it fails */
61	-#define CALLBACK_NOTIFY_(FOR, ER) \
62	-do { \
63	- assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \
64	- \
65	- if (settings->on_##FOR) { \
66	- if (0 != settings->on_##FOR(parser)) { \
67	- SET_ERRNO(HPE_CB_##FOR); \
68	- } \
69	- \
70	- /* We either errored above or got paused; get out */ \
71	- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \
72	- return (ER); \
73	- } \
74	- } \
75	-} while (0)
76	-
77	-/* Run the notify callback FOR and consume the current byte */
78	-#define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1)
79	-
80	-/* Run the notify callback FOR and don't consume the current byte */
81	-#define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data)
82	-
83	-/* Run data callback FOR with LEN bytes, returning ER if it fails */
84	-#define CALLBACK_DATA_(FOR, LEN, ER) \
85	-do { \
86	- assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \
87	- \
88	- if (FOR##_mark) { \
89	- if (settings->on_##FOR) { \
90	- if (0 != settings->on_##FOR(parser, FOR##_mark, (LEN))) { \
91	- SET_ERRNO(HPE_CB_##FOR); \
92	- } \
93	- \
94	- /* We either errored above or got paused; get out */ \
95	- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \
96	- return (ER); \
97	- } \
98	- } \
99	- FOR##_mark = NULL; \
100	- } \
101	-} while (0)
102	-
103	-/* Run the data callback FOR and consume the current byte */
104	-#define CALLBACK_DATA(FOR) \
105	- CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)
106	-
107	-/* Run the data callback FOR and don't consume the current byte */
108	-#define CALLBACK_DATA_NOADVANCE(FOR) \
109	- CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)
110	-
111	-/* Set the mark FOR; non-destructive if mark is already set */
112	-#define MARK(FOR) \
113	-do { \
114	- if (!FOR##_mark) { \
115	- FOR##_mark = p; \
116	- } \
117	-} while (0)
118	-
119	-
120	-#define PROXY_CONNECTION "proxy-connection"
121	-#define CONNECTION "connection"
122	-#define CONTENT_LENGTH "content-length"
123	-#define TRANSFER_ENCODING "transfer-encoding"
124	-#define UPGRADE "upgrade"
125	-#define CHUNKED "chunked"
126	-#define KEEP_ALIVE "keep-alive"
127	-#define CLOSE "close"
128	-
129	-
130	-static const char *method_strings[] =
131	- {
132	-#define XX(num, name, string) #string,
133	- HTTP_METHOD_MAP(XX)
134	-#undef XX
135	- };
136	-
137	-
138	-/* Tokens as defined by rfc 2616. Also lowercases them.
139	- * token = 1*<any CHAR except CTLs or separators>
140	- * separators = "(" \| ")" \| "<" \| ">" \| "@"
141	- * \| "," \| ";" \| ":" \| "\" \| <">
142	- * \| "/" \| "[" \| "]" \| "?" \| "="
143	- * \| "{" \| "}" \| SP \| HT
144	- */
145	-static const char tokens[256] = {
146	-/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
147	- 0, 0, 0, 0, 0, 0, 0, 0,
148	-/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
149	- 0, 0, 0, 0, 0, 0, 0, 0,
150	-/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
151	- 0, 0, 0, 0, 0, 0, 0, 0,
152	-/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
153	- 0, 0, 0, 0, 0, 0, 0, 0,
154	-/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
155	- 0, '!', 0, '#', '$', '%', '&', '\'',
156	-/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
157	- 0, 0, '*', '+', 0, '-', '.', 0,
158	-/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
159	- '0', '1', '2', '3', '4', '5', '6', '7',
160	-/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
161	- '8', '9', 0, 0, 0, 0, 0, 0,
162	-/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
163	- 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
164	-/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
165	- 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
166	-/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
167	- 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
168	-/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
169	- 'x', 'y', 'z', 0, 0, 0, '^', '_',
170	-/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
171	- '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
172	-/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
173	- 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
174	-/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
175	- 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
176	-/* 120 x 121 y 122 z 123 { 124 \| 125 } 126 ~ 127 del */
177	- 'x', 'y', 'z', 0, '\|', 0, '~', 0 };
178	-
179	-
180	-static const int8_t unhex[256] =
181	- {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
182	- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
183	- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
184	- , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
185	- ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
186	- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
187	- ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
188	- ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
189	- };
190	-
191	-
192	-#if HTTP_PARSER_STRICT
193	-# define T(v) 0
194	-#else
195	-# define T(v) v
196	-#endif
197	-
198	-
199	-static const uint8_t normal_url_char[32] = {
200	-/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
201	- 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0,
202	-/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
203	- 0 \| T(2) \| 0 \| 0 \| T(16) \| 0 \| 0 \| 0,
204	-/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
205	- 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0,
206	-/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
207	- 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0 \| 0,
208	-/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
209	- 0 \| 2 \| 4 \| 0 \| 16 \| 32 \| 64 \| 128,
210	-/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
211	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
212	-/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
213	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
214	-/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
215	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 0,
216	-/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
217	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
218	-/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
219	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
220	-/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
221	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
222	-/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
223	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
224	-/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
225	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
226	-/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
227	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
228	-/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
229	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 128,
230	-/* 120 x 121 y 122 z 123 { 124 \| 125 } 126 ~ 127 del */
231	- 1 \| 2 \| 4 \| 8 \| 16 \| 32 \| 64 \| 0, };
232	-
233	-#undef T
234	-
235	-enum state
236	- { s_dead = 1 /* important that this is > 0 */
237	-
238	- , s_start_req_or_res
239	- , s_res_or_resp_H
240	- , s_start_res
241	- , s_res_H
242	- , s_res_HT
243	- , s_res_HTT
244	- , s_res_HTTP
245	- , s_res_first_http_major
246	- , s_res_http_major
247	- , s_res_first_http_minor
248	- , s_res_http_minor
249	- , s_res_first_status_code
250	- , s_res_status_code
251	- , s_res_status
252	- , s_res_line_almost_done
253	-
254	- , s_start_req
255	-
256	- , s_req_method
257	- , s_req_spaces_before_url
258	- , s_req_schema
259	- , s_req_schema_slash
260	- , s_req_schema_slash_slash
261	- , s_req_server_start
262	- , s_req_server
263	- , s_req_server_with_at
264	- , s_req_path
265	- , s_req_query_string_start
266	- , s_req_query_string
267	- , s_req_fragment_start
268	- , s_req_fragment
269	- , s_req_http_start
270	- , s_req_http_H
271	- , s_req_http_HT
272	- , s_req_http_HTT
273	- , s_req_http_HTTP
274	- , s_req_first_http_major
275	- , s_req_http_major
276	- , s_req_first_http_minor
277	- , s_req_http_minor
278	- , s_req_line_almost_done
279	-
280	- , s_header_field_start
281	- , s_header_field
282	- , s_header_value_start
283	- , s_header_value
284	- , s_header_value_lws
285	-
286	- , s_header_almost_done
287	-
288	- , s_chunk_size_start
289	- , s_chunk_size
290	- , s_chunk_parameters
291	- , s_chunk_size_almost_done
292	-
293	- , s_headers_almost_done
294	- , s_headers_done
295	-
296	- /* Important: 's_headers_done' must be the last 'header' state. All
297	- * states beyond this must be 'body' states. It is used for overflow
298	- * checking. See the PARSING_HEADER() macro.
299	- */
300	-
301	- , s_chunk_data
302	- , s_chunk_data_almost_done
303	- , s_chunk_data_done
304	-
305	- , s_body_identity
306	- , s_body_identity_eof
307	-
308	- , s_message_done
309	- };
310	-
311	-
312	-#define PARSING_HEADER(state) (state <= s_headers_done)
313	-
314	-
315	-enum header_states
316	- { h_general = 0
317	- , h_C
318	- , h_CO
319	- , h_CON
320	-
321	- , h_matching_connection
322	- , h_matching_proxy_connection
323	- , h_matching_content_length
324	- , h_matching_transfer_encoding
325	- , h_matching_upgrade
326	-
327	- , h_connection
328	- , h_content_length
329	- , h_transfer_encoding
330	- , h_upgrade
331	-
332	- , h_matching_transfer_encoding_chunked
333	- , h_matching_connection_keep_alive
334	- , h_matching_connection_close
335	-
336	- , h_transfer_encoding_chunked
337	- , h_connection_keep_alive
338	- , h_connection_close
339	- };
340	-
341	-enum http_host_state
342	- {
343	- s_http_host_dead = 1
344	- , s_http_userinfo_start
345	- , s_http_userinfo
346	- , s_http_host_start
347	- , s_http_host_v6_start
348	- , s_http_host
349	- , s_http_host_v6
350	- , s_http_host_v6_end
351	- , s_http_host_port_start
352	- , s_http_host_port
353	-};
354	-
355	-/* Macros for character classes; depends on strict-mode */
356	-#define CR '\r'
357	-#define LF '\n'
358	-#define LOWER(c) (unsigned char)(c \| 0x20)
359	-#define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z')
360	-#define IS_NUM(c) ((c) >= '0' && (c) <= '9')
361	-#define IS_ALPHANUM(c) (IS_ALPHA(c) \|\| IS_NUM(c))
362	-#define IS_HEX(c) (IS_NUM(c) \|\| (LOWER(c) >= 'a' && LOWER(c) <= 'f'))
363	-#define IS_MARK(c) ((c) == '-' \|\| (c) == '_' \|\| (c) == '.' \|\| \
364	- (c) == '!' \|\| (c) == '~' \|\| (c) == '*' \|\| (c) == '\'' \|\| (c) == '(' \|\| \
365	- (c) == ')')
366	-#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) \|\| IS_MARK(c) \|\| (c) == '%' \|\| \
367	- (c) == ';' \|\| (c) == ':' \|\| (c) == '&' \|\| (c) == '=' \|\| (c) == '+' \|\| \
368	- (c) == '$' \|\| (c) == ',')
369	-
370	-#if HTTP_PARSER_STRICT
371	-#define TOKEN(c) (tokens[(unsigned char)c])
372	-#define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c))
373	-#define IS_HOST_CHAR(c) (IS_ALPHANUM(c) \|\| (c) == '.' \|\| (c) == '-')
374	-#else
375	-#define TOKEN(c) ((c == ' ') ? ' ' : tokens[(unsigned char)c])
376	-#define IS_URL_CHAR(c) \
377	- (BIT_AT(normal_url_char, (unsigned char)c) \|\| ((c) & 0x80))
378	-#define IS_HOST_CHAR(c) \
379	- (IS_ALPHANUM(c) \|\| (c) == '.' \|\| (c) == '-' \|\| (c) == '_')
380	-#endif
381	-
382	-
383	-#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
384	-
385	-
386	-#if HTTP_PARSER_STRICT
387	-# define STRICT_CHECK(cond) \
388	-do { \
389	- if (cond) { \
390	- SET_ERRNO(HPE_STRICT); \
391	- goto error; \
392	- } \
393	-} while (0)
394	-# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
395	-#else
396	-# define STRICT_CHECK(cond)
397	-# define NEW_MESSAGE() start_state
398	-#endif
399	-
400	-
401	-/* Map errno values to strings for human-readable output */
402	-#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s },
403	-static struct {
404	- const char *name;
405	- const char *description;
406	-} http_strerror_tab[] = {
407	- HTTP_ERRNO_MAP(HTTP_STRERROR_GEN)
408	-};
409	-#undef HTTP_STRERROR_GEN
410	-
411	-int http_message_needs_eof(const http_parser *parser);
412	-
413	-/* Our URL parser.
414	- *
415	- * This is designed to be shared by http_parser_execute() for URL validation,
416	- * hence it has a state transition + byte-for-byte interface. In addition, it
417	- * is meant to be embedded in http_parser_parse_url(), which does the dirty
418	- * work of turning state transitions URL components for its API.
419	- *
420	- * This function should only be invoked with non-space characters. It is
421	- * assumed that the caller cares about (and can detect) the transition between
422	- * URL and non-URL states by looking for these.
423	- */
424	-static enum state
425	-parse_url_char(enum state s, const char ch)
426	-{
427	- if (ch == ' ' \|\| ch == '\r' \|\| ch == '\n') {
428	- return s_dead;
429	- }
430	-
431	-#if HTTP_PARSER_STRICT
432	- if (ch == '\t' \|\| ch == '\f') {
433	- return s_dead;
434	- }
435	-#endif
436	-
437	- switch (s) {
438	- case s_req_spaces_before_url:
439	- /* Proxied requests are followed by scheme of an absolute URI (alpha).
440	- * All methods except CONNECT are followed by '/' or '*'.
441	- */
442	-
443	- if (ch == '/' \|\| ch == '*') {
444	- return s_req_path;
445	- }
446	-
447	- if (IS_ALPHA(ch)) {
448	- return s_req_schema;
449	- }
450	-
451	- break;
452	-
453	- case s_req_schema:
454	- if (IS_ALPHA(ch)) {
455	- return s;
456	- }
457	-
458	- if (ch == ':') {
459	- return s_req_schema_slash;
460	- }
461	-
462	- break;
463	-
464	- case s_req_schema_slash:
465	- if (ch == '/') {
466	- return s_req_schema_slash_slash;
467	- }
468	-
469	- break;
470	-
471	- case s_req_schema_slash_slash:
472	- if (ch == '/') {
473	- return s_req_server_start;
474	- }
475	-
476	- break;
477	-
478	- case s_req_server_with_at:
479	- if (ch == '@') {
480	- return s_dead;
481	- }
482	-
483	- /* FALLTHROUGH */
484	- case s_req_server_start:
485	- case s_req_server:
486	- if (ch == '/') {
487	- return s_req_path;
488	- }
489	-
490	- if (ch == '?') {
491	- return s_req_query_string_start;
492	- }
493	-
494	- if (ch == '@') {
495	- return s_req_server_with_at;
496	- }
497	-
498	- if (IS_USERINFO_CHAR(ch) \|\| ch == '[' \|\| ch == ']') {
499	- return s_req_server;
500	- }
501	-
502	- break;
503	-
504	- case s_req_path:
505	- if (IS_URL_CHAR(ch)) {
506	- return s;
507	- }
508	-
509	- switch (ch) {
510	- case '?':
511	- return s_req_query_string_start;
512	-
513	- case '#':
514	- return s_req_fragment_start;
515	- }
516	-
517	- break;
518	-
519	- case s_req_query_string_start:
520	- case s_req_query_string:
521	- if (IS_URL_CHAR(ch)) {
522	- return s_req_query_string;
523	- }
524	-
525	- switch (ch) {
526	- case '?':
527	- /* allow extra '?' in query string */
528	- return s_req_query_string;
529	-
530	- case '#':
531	- return s_req_fragment_start;
532	- }
533	-
534	- break;
535	-
536	- case s_req_fragment_start:
537	- if (IS_URL_CHAR(ch)) {
538	- return s_req_fragment;
539	- }
540	-
541	- switch (ch) {
542	- case '?':
543	- return s_req_fragment;
544	-
545	- case '#':
546	- return s;
547	- }
548	-
549	- break;
550	-
551	- case s_req_fragment:
552	- if (IS_URL_CHAR(ch)) {
553	- return s;
554	- }
555	-
556	- switch (ch) {
557	- case '?':
558	- case '#':
559	- return s;
560	- }
561	-
562	- break;
563	-
564	- default:
565	- break;
566	- }
567	-
568	- /* We should never fall out of the switch above unless there's an error */
569	- return s_dead;
570	-}
571	-
572	-size_t http_parser_execute (http_parser *parser,
573	- const http_parser_settings *settings,
574	- const char *data,
575	- size_t len)
576	-{
577	- char c, ch;
578	- int8_t unhex_val;
579	- const char *p = data;
580	- const char *header_field_mark = 0;
581	- const char *header_value_mark = 0;
582	- const char *url_mark = 0;
583	- const char *body_mark = 0;
584	-
585	- /* We're in an error state. Don't bother doing anything. */
586	- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
587	- return 0;
588	- }
589	-
590	- if (len == 0) {
591	- switch (parser->state) {
592	- case s_body_identity_eof:
593	- /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if
594	- * we got paused.
595	- */
596	- CALLBACK_NOTIFY_NOADVANCE(message_complete);
597	- return 0;
598	-
599	- case s_dead:
600	- case s_start_req_or_res:
601	- case s_start_res:
602	- case s_start_req:
603	- return 0;
604	-
605	- default:
606	- SET_ERRNO(HPE_INVALID_EOF_STATE);
607	- return 1;
608	- }
609	- }
610	-
611	-
612	- if (parser->state == s_header_field)
613	- header_field_mark = data;
614	- if (parser->state == s_header_value)
615	- header_value_mark = data;
616	- switch (parser->state) {
617	- case s_req_path:
618	- case s_req_schema:
619	- case s_req_schema_slash:
620	- case s_req_schema_slash_slash:
621	- case s_req_server_start:
622	- case s_req_server:
623	- case s_req_server_with_at:
624	- case s_req_query_string_start:
625	- case s_req_query_string:
626	- case s_req_fragment_start:
627	- case s_req_fragment:
628	- url_mark = data;
629	- break;
630	- }
631	-
632	- for (p=data; p != data + len; p++) {
633	- ch = *p;
634	-
635	- if (PARSING_HEADER(parser->state)) {
636	- ++parser->nread;
637	- /* Buffer overflow attack */
638	- if (parser->nread > HTTP_MAX_HEADER_SIZE) {
639	- SET_ERRNO(HPE_HEADER_OVERFLOW);
640	- goto error;
641	- }
642	- }
643	-
644	- reexecute_byte:
645	- switch (parser->state) {
646	-
647	- case s_dead:
648	- /* this state is used after a 'Connection: close' message
649	- * the parser will error out if it reads another message
650	- */
651	- if (ch == CR \|\| ch == LF)
652	- break;
653	-
654	- SET_ERRNO(HPE_CLOSED_CONNECTION);
655	- goto error;
656	-
657	- case s_start_req_or_res:
658	- {
659	- if (ch == CR \|\| ch == LF)
660	- break;
661	- parser->flags = 0;
662	- parser->content_length = ULLONG_MAX;
663	-
664	- if (ch == 'H') {
665	- parser->state = s_res_or_resp_H;
666	-
667	- CALLBACK_NOTIFY(message_begin);
668	- } else {
669	- parser->type = HTTP_REQUEST;
670	- parser->state = s_start_req;
671	- goto reexecute_byte;
672	- }
673	-
674	- break;
675	- }
676	-
677	- case s_res_or_resp_H:
678	- if (ch == 'T') {
679	- parser->type = HTTP_RESPONSE;
680	- parser->state = s_res_HT;
681	- } else {
682	- if (ch != 'E') {
683	- SET_ERRNO(HPE_INVALID_CONSTANT);
684	- goto error;
685	- }
686	-
687	- parser->type = HTTP_REQUEST;
688	- parser->method = HTTP_HEAD;
689	- parser->index = 2;
690	- parser->state = s_req_method;
691	- }
692	- break;
693	-
694	- case s_start_res:
695	- {
696	- parser->flags = 0;
697	- parser->content_length = ULLONG_MAX;
698	-
699	- switch (ch) {
700	- case 'H':
701	- parser->state = s_res_H;
702	- break;
703	-
704	- case CR:
705	- case LF:
706	- break;
707	-
708	- default:
709	- SET_ERRNO(HPE_INVALID_CONSTANT);
710	- goto error;
711	- }
712	-
713	- CALLBACK_NOTIFY(message_begin);
714	- break;
715	- }
716	-
717	- case s_res_H:
718	- STRICT_CHECK(ch != 'T');
719	- parser->state = s_res_HT;
720	- break;
721	-
722	- case s_res_HT:
723	- STRICT_CHECK(ch != 'T');
724	- parser->state = s_res_HTT;
725	- break;
726	-
727	- case s_res_HTT:
728	- STRICT_CHECK(ch != 'P');
729	- parser->state = s_res_HTTP;
730	- break;
731	-
732	- case s_res_HTTP:
733	- STRICT_CHECK(ch != '/');
734	- parser->state = s_res_first_http_major;
735	- break;
736	-
737	- case s_res_first_http_major:
738	- if (ch < '0' \|\| ch > '9') {
739	- SET_ERRNO(HPE_INVALID_VERSION);
740	- goto error;
741	- }
742	-
743	- parser->http_major = ch - '0';
744	- parser->state = s_res_http_major;
745	- break;
746	-
747	- /* major HTTP version or dot */
748	- case s_res_http_major:
749	- {
750	- if (ch == '.') {
751	- parser->state = s_res_first_http_minor;
752	- break;
753	- }
754	-
755	- if (!IS_NUM(ch)) {
756	- SET_ERRNO(HPE_INVALID_VERSION);
757	- goto error;
758	- }
759	-
760	- parser->http_major *= 10;
761	- parser->http_major += ch - '0';
762	-
763	- if (parser->http_major > 999) {
764	- SET_ERRNO(HPE_INVALID_VERSION);
765	- goto error;
766	- }
767	-
768	- break;
769	- }
770	-
771	- /* first digit of minor HTTP version */
772	- case s_res_first_http_minor:
773	- if (!IS_NUM(ch)) {
774	- SET_ERRNO(HPE_INVALID_VERSION);
775	- goto error;
776	- }
777	-
778	- parser->http_minor = ch - '0';
779	- parser->state = s_res_http_minor;
780	- break;
781	-
782	- /* minor HTTP version or end of request line */
783	- case s_res_http_minor:
784	- {
785	- if (ch == ' ') {
786	- parser->state = s_res_first_status_code;
787	- break;
788	- }
789	-
790	- if (!IS_NUM(ch)) {
791	- SET_ERRNO(HPE_INVALID_VERSION);
792	- goto error;
793	- }
794	-
795	- parser->http_minor *= 10;
796	- parser->http_minor += ch - '0';
797	-
798	- if (parser->http_minor > 999) {
799	- SET_ERRNO(HPE_INVALID_VERSION);
800	- goto error;
801	- }
802	-
803	- break;
804	- }
805	-
806	- case s_res_first_status_code:
807	- {
808	- if (!IS_NUM(ch)) {
809	- if (ch == ' ') {
810	- break;
811	- }
812	-
813	- SET_ERRNO(HPE_INVALID_STATUS);
814	- goto error;
815	- }
816	- parser->status_code = ch - '0';
817	- parser->state = s_res_status_code;
818	- break;
819	- }
820	-
821	- case s_res_status_code:
822	- {
823	- if (!IS_NUM(ch)) {
824	- switch (ch) {
825	- case ' ':
826	- parser->state = s_res_status;
827	- break;
828	- case CR:
829	- parser->state = s_res_line_almost_done;
830	- break;
831	- case LF:
832	- parser->state = s_header_field_start;
833	- break;
834	- default:
835	- SET_ERRNO(HPE_INVALID_STATUS);
836	- goto error;
837	- }
838	- break;
839	- }
840	-
841	- parser->status_code *= 10;
842	- parser->status_code += ch - '0';
843	-
844	- if (parser->status_code > 999) {
845	- SET_ERRNO(HPE_INVALID_STATUS);
846	- goto error;
847	- }
848	-
849	- break;
850	- }
851	-
852	- case s_res_status:
853	- /* the human readable status. e.g. "NOT FOUND"
854	- * we are not humans so just ignore this */
855	- if (ch == CR) {
856	- parser->state = s_res_line_almost_done;
857	- break;
858	- }
859	-
860	- if (ch == LF) {
861	- parser->state = s_header_field_start;
862	- break;
863	- }
864	- break;
865	-
866	- case s_res_line_almost_done:
867	- STRICT_CHECK(ch != LF);
868	- parser->state = s_header_field_start;
869	- CALLBACK_NOTIFY(status_complete);
870	- break;
871	-
872	- case s_start_req:
873	- {
874	- if (ch == CR \|\| ch == LF)
875	- break;
876	- parser->flags = 0;
877	- parser->content_length = ULLONG_MAX;
878	-
879	- if (!IS_ALPHA(ch)) {
880	- SET_ERRNO(HPE_INVALID_METHOD);
881	- goto error;
882	- }
883	-
884	- parser->method = (enum http_method) 0;
885	- parser->index = 1;
886	- switch (ch) {
887	- case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
888	- case 'D': parser->method = HTTP_DELETE; break;
889	- case 'G': parser->method = HTTP_GET; break;
890	- case 'H': parser->method = HTTP_HEAD; break;
891	- case 'L': parser->method = HTTP_LOCK; break;
892	- case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break;
893	- case 'N': parser->method = HTTP_NOTIFY; break;
894	- case 'O': parser->method = HTTP_OPTIONS; break;
895	- case 'P': parser->method = HTTP_POST;
896	- /* or PROPFIND\|PROPPATCH\|PUT\|PATCH\|PURGE */
897	- break;
898	- case 'R': parser->method = HTTP_REPORT; break;
899	- case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH */ break;
900	- case 'T': parser->method = HTTP_TRACE; break;
901	- case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break;
902	- default:
903	- SET_ERRNO(HPE_INVALID_METHOD);
904	- goto error;
905	- }
906	- parser->state = s_req_method;
907	-
908	- CALLBACK_NOTIFY(message_begin);
909	-
910	- break;
911	- }
912	-
913	- case s_req_method:
914	- {
915	- const char *matcher;
916	- if (ch == '\0') {
917	- SET_ERRNO(HPE_INVALID_METHOD);
918	- goto error;
919	- }
920	-
921	- matcher = method_strings[parser->method];
922	- if (ch == ' ' && matcher[parser->index] == '\0') {
923	- parser->state = s_req_spaces_before_url;
924	- } else if (ch == matcher[parser->index]) {
925	- ; /* nada */
926	- } else if (parser->method == HTTP_CONNECT) {
927	- if (parser->index == 1 && ch == 'H') {
928	- parser->method = HTTP_CHECKOUT;
929	- } else if (parser->index == 2 && ch == 'P') {
930	- parser->method = HTTP_COPY;
931	- } else {
932	- goto error;
933	- }
934	- } else if (parser->method == HTTP_MKCOL) {
935	- if (parser->index == 1 && ch == 'O') {
936	- parser->method = HTTP_MOVE;
937	- } else if (parser->index == 1 && ch == 'E') {
938	- parser->method = HTTP_MERGE;
939	- } else if (parser->index == 1 && ch == '-') {
940	- parser->method = HTTP_MSEARCH;
941	- } else if (parser->index == 2 && ch == 'A') {
942	- parser->method = HTTP_MKACTIVITY;
943	- } else {
944	- goto error;
945	- }
946	- } else if (parser->method == HTTP_SUBSCRIBE) {
947	- if (parser->index == 1 && ch == 'E') {
948	- parser->method = HTTP_SEARCH;
949	- } else {
950	- goto error;
951	- }
952	- } else if (parser->index == 1 && parser->method == HTTP_POST) {
953	- if (ch == 'R') {
954	- parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */
955	- } else if (ch == 'U') {
956	- parser->method = HTTP_PUT; /* or HTTP_PURGE */
957	- } else if (ch == 'A') {
958	- parser->method = HTTP_PATCH;
959	- } else {
960	- goto error;
961	- }
962	- } else if (parser->index == 2) {
963	- if (parser->method == HTTP_PUT) {
964	- if (ch == 'R') parser->method = HTTP_PURGE;
965	- } else if (parser->method == HTTP_UNLOCK) {
966	- if (ch == 'S') parser->method = HTTP_UNSUBSCRIBE;
967	- }
968	- } else if (parser->index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') {
969	- parser->method = HTTP_PROPPATCH;
970	- } else {
971	- SET_ERRNO(HPE_INVALID_METHOD);
972	- goto error;
973	- }
974	-
975	- ++parser->index;
976	- break;
977	- }
978	-
979	- case s_req_spaces_before_url:
980	- {
981	- if (ch == ' ') break;
982	-
983	- MARK(url);
984	- if (parser->method == HTTP_CONNECT) {
985	- parser->state = s_req_server_start;
986	- }
987	-
988	- parser->state = parse_url_char((enum state)parser->state, ch);
989	- if (parser->state == s_dead) {
990	- SET_ERRNO(HPE_INVALID_URL);
991	- goto error;
992	- }
993	-
994	- break;
995	- }
996	-
997	- case s_req_schema:
998	- case s_req_schema_slash:
999	- case s_req_schema_slash_slash:
1000	- case s_req_server_start:
1001	- {
1002	- switch (ch) {
1003	- /* No whitespace allowed here */
1004	- case ' ':
1005	- case CR:
1006	- case LF:
1007	- SET_ERRNO(HPE_INVALID_URL);
1008	- goto error;
1009	- default:
1010	- parser->state = parse_url_char((enum state)parser->state, ch);
1011	- if (parser->state == s_dead) {
1012	- SET_ERRNO(HPE_INVALID_URL);
1013	- goto error;
1014	- }
1015	- }
1016	-
1017	- break;
1018	- }
1019	-
1020	- case s_req_server:
1021	- case s_req_server_with_at:
1022	- case s_req_path:
1023	- case s_req_query_string_start:
1024	- case s_req_query_string:
1025	- case s_req_fragment_start:
1026	- case s_req_fragment:
1027	- {
1028	- switch (ch) {
1029	- case ' ':
1030	- parser->state = s_req_http_start;
1031	- CALLBACK_DATA(url);
1032	- break;
1033	- case CR:
1034	- case LF:
1035	- parser->http_major = 0;
1036	- parser->http_minor = 9;
1037	- parser->state = (ch == CR) ?
1038	- s_req_line_almost_done :
1039	- s_header_field_start;
1040	- CALLBACK_DATA(url);
1041	- break;
1042	- default:
1043	- parser->state = parse_url_char((enum state)parser->state, ch);
1044	- if (parser->state == s_dead) {
1045	- SET_ERRNO(HPE_INVALID_URL);
1046	- goto error;
1047	- }
1048	- }
1049	- break;
1050	- }
1051	-
1052	- case s_req_http_start:
1053	- switch (ch) {
1054	- case 'H':
1055	- parser->state = s_req_http_H;
1056	- break;
1057	- case ' ':
1058	- break;
1059	- default:
1060	- SET_ERRNO(HPE_INVALID_CONSTANT);
1061	- goto error;
1062	- }
1063	- break;
1064	-
1065	- case s_req_http_H:
1066	- STRICT_CHECK(ch != 'T');
1067	- parser->state = s_req_http_HT;
1068	- break;
1069	-
1070	- case s_req_http_HT:
1071	- STRICT_CHECK(ch != 'T');
1072	- parser->state = s_req_http_HTT;
1073	- break;
1074	-
1075	- case s_req_http_HTT:
1076	- STRICT_CHECK(ch != 'P');
1077	- parser->state = s_req_http_HTTP;
1078	- break;
1079	-
1080	- case s_req_http_HTTP:
1081	- STRICT_CHECK(ch != '/');
1082	- parser->state = s_req_first_http_major;
1083	- break;
1084	-
1085	- /* first digit of major HTTP version */
1086	- case s_req_first_http_major:
1087	- if (ch < '1' \|\| ch > '9') {
1088	- SET_ERRNO(HPE_INVALID_VERSION);
1089	- goto error;
1090	- }
1091	-
1092	- parser->http_major = ch - '0';
1093	- parser->state = s_req_http_major;
1094	- break;
1095	-
1096	- /* major HTTP version or dot */
1097	- case s_req_http_major:
1098	- {
1099	- if (ch == '.') {
1100	- parser->state = s_req_first_http_minor;
1101	- break;
1102	- }
1103	-
1104	- if (!IS_NUM(ch)) {
1105	- SET_ERRNO(HPE_INVALID_VERSION);
1106	- goto error;
1107	- }
1108	-
1109	- parser->http_major *= 10;
1110	- parser->http_major += ch - '0';
1111	-
1112	- if (parser->http_major > 999) {
1113	- SET_ERRNO(HPE_INVALID_VERSION);
1114	- goto error;
1115	- }
1116	-
1117	- break;
1118	- }
1119	-
1120	- /* first digit of minor HTTP version */
1121	- case s_req_first_http_minor:
1122	- if (!IS_NUM(ch)) {
1123	- SET_ERRNO(HPE_INVALID_VERSION);
1124	- goto error;
1125	- }
1126	-
1127	- parser->http_minor = ch - '0';
1128	- parser->state = s_req_http_minor;
1129	- break;
1130	-
1131	- /* minor HTTP version or end of request line */
1132	- case s_req_http_minor:
1133	- {
1134	- if (ch == CR) {
1135	- parser->state = s_req_line_almost_done;
1136	- break;
1137	- }
1138	-
1139	- if (ch == LF) {
1140	- parser->state = s_header_field_start;
1141	- break;
1142	- }
1143	-
1144	- /* XXX allow spaces after digit? */
1145	-
1146	- if (!IS_NUM(ch)) {
1147	- SET_ERRNO(HPE_INVALID_VERSION);
1148	- goto error;
1149	- }
1150	-
1151	- parser->http_minor *= 10;
1152	- parser->http_minor += ch - '0';
1153	-
1154	- if (parser->http_minor > 999) {
1155	- SET_ERRNO(HPE_INVALID_VERSION);
1156	- goto error;
1157	- }
1158	-
1159	- break;
1160	- }
1161	-
1162	- /* end of request line */
1163	- case s_req_line_almost_done:
1164	- {
1165	- if (ch != LF) {
1166	- SET_ERRNO(HPE_LF_EXPECTED);
1167	- goto error;
1168	- }
1169	-
1170	- parser->state = s_header_field_start;
1171	- break;
1172	- }
1173	-
1174	- case s_header_field_start:
1175	- {
1176	- if (ch == CR) {
1177	- parser->state = s_headers_almost_done;
1178	- break;
1179	- }
1180	-
1181	- if (ch == LF) {
1182	- /* they might be just sending \n instead of \r\n so this would be
1183	- * the second \n to denote the end of headers*/
1184	- parser->state = s_headers_almost_done;
1185	- goto reexecute_byte;
1186	- }
1187	-
1188	- c = TOKEN(ch);
1189	-
1190	- if (!c) {
1191	- SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
1192	- goto error;
1193	- }
1194	-
1195	- MARK(header_field);
1196	-
1197	- parser->index = 0;
1198	- parser->state = s_header_field;
1199	-
1200	- switch (c) {
1201	- case 'c':
1202	- parser->header_state = h_C;
1203	- break;
1204	-
1205	- case 'p':
1206	- parser->header_state = h_matching_proxy_connection;
1207	- break;
1208	-
1209	- case 't':
1210	- parser->header_state = h_matching_transfer_encoding;
1211	- break;
1212	-
1213	- case 'u':
1214	- parser->header_state = h_matching_upgrade;
1215	- break;
1216	-
1217	- default:
1218	- parser->header_state = h_general;
1219	- break;
1220	- }
1221	- break;
1222	- }
1223	-
1224	- case s_header_field:
1225	- {
1226	- c = TOKEN(ch);
1227	-
1228	- if (c) {
1229	- switch (parser->header_state) {
1230	- case h_general:
1231	- break;
1232	-
1233	- case h_C:
1234	- parser->index++;
1235	- parser->header_state = (c == 'o' ? h_CO : h_general);
1236	- break;
1237	-
1238	- case h_CO:
1239	- parser->index++;
1240	- parser->header_state = (c == 'n' ? h_CON : h_general);
1241	- break;
1242	-
1243	- case h_CON:
1244	- parser->index++;
1245	- switch (c) {
1246	- case 'n':
1247	- parser->header_state = h_matching_connection;
1248	- break;
1249	- case 't':
1250	- parser->header_state = h_matching_content_length;
1251	- break;
1252	- default:
1253	- parser->header_state = h_general;
1254	- break;
1255	- }
1256	- break;
1257	-
1258	- /* connection */
1259	-
1260	- case h_matching_connection:
1261	- parser->index++;
1262	- if (parser->index > sizeof(CONNECTION)-1
1263	- \|\| c != CONNECTION[parser->index]) {
1264	- parser->header_state = h_general;
1265	- } else if (parser->index == sizeof(CONNECTION)-2) {
1266	- parser->header_state = h_connection;
1267	- }
1268	- break;
1269	-
1270	- /* proxy-connection */
1271	-
1272	- case h_matching_proxy_connection:
1273	- parser->index++;
1274	- if (parser->index > sizeof(PROXY_CONNECTION)-1
1275	- \|\| c != PROXY_CONNECTION[parser->index]) {
1276	- parser->header_state = h_general;
1277	- } else if (parser->index == sizeof(PROXY_CONNECTION)-2) {
1278	- parser->header_state = h_connection;
1279	- }
1280	- break;
1281	-
1282	- /* content-length */
1283	-
1284	- case h_matching_content_length:
1285	- parser->index++;
1286	- if (parser->index > sizeof(CONTENT_LENGTH)-1
1287	- \|\| c != CONTENT_LENGTH[parser->index]) {
1288	- parser->header_state = h_general;
1289	- } else if (parser->index == sizeof(CONTENT_LENGTH)-2) {
1290	- parser->header_state = h_content_length;
1291	- }
1292	- break;
1293	-
1294	- /* transfer-encoding */
1295	-
1296	- case h_matching_transfer_encoding:
1297	- parser->index++;
1298	- if (parser->index > sizeof(TRANSFER_ENCODING)-1
1299	- \|\| c != TRANSFER_ENCODING[parser->index]) {
1300	- parser->header_state = h_general;
1301	- } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) {
1302	- parser->header_state = h_transfer_encoding;
1303	- }
1304	- break;
1305	-
1306	- /* upgrade */
1307	-
1308	- case h_matching_upgrade:
1309	- parser->index++;
1310	- if (parser->index > sizeof(UPGRADE)-1
1311	- \|\| c != UPGRADE[parser->index]) {
1312	- parser->header_state = h_general;
1313	- } else if (parser->index == sizeof(UPGRADE)-2) {
1314	- parser->header_state = h_upgrade;
1315	- }
1316	- break;
1317	-
1318	- case h_connection:
1319	- case h_content_length:
1320	- case h_transfer_encoding:
1321	- case h_upgrade:
1322	- if (ch != ' ') parser->header_state = h_general;
1323	- break;
1324	-
1325	- default:
1326	- assert(0 && "Unknown header_state");
1327	- break;
1328	- }
1329	- break;
1330	- }
1331	-
1332	- if (ch == ':') {
1333	- parser->state = s_header_value_start;
1334	- CALLBACK_DATA(header_field);
1335	- break;
1336	- }
1337	-
1338	- if (ch == CR) {
1339	- parser->state = s_header_almost_done;
1340	- CALLBACK_DATA(header_field);
1341	- break;
1342	- }
1343	-
1344	- if (ch == LF) {
1345	- parser->state = s_header_field_start;
1346	- CALLBACK_DATA(header_field);
1347	- break;
1348	- }
1349	-
1350	- SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
1351	- goto error;
1352	- }
1353	-
1354	- case s_header_value_start:
1355	- {
1356	- if (ch == ' ' \|\| ch == '\t') break;
1357	-
1358	- MARK(header_value);
1359	-
1360	- parser->state = s_header_value;
1361	- parser->index = 0;
1362	-
1363	- if (ch == CR) {
1364	- parser->header_state = h_general;
1365	- parser->state = s_header_almost_done;
1366	- CALLBACK_DATA(header_value);
1367	- break;
1368	- }
1369	-
1370	- if (ch == LF) {
1371	- parser->state = s_header_field_start;
1372	- CALLBACK_DATA(header_value);
1373	- break;
1374	- }
1375	-
1376	- c = LOWER(ch);
1377	-
1378	- switch (parser->header_state) {
1379	- case h_upgrade:
1380	- parser->flags \|= F_UPGRADE;
1381	- parser->header_state = h_general;
1382	- break;
1383	-
1384	- case h_transfer_encoding:
1385	- /* looking for 'Transfer-Encoding: chunked' */
1386	- if ('c' == c) {
1387	- parser->header_state = h_matching_transfer_encoding_chunked;
1388	- } else {
1389	- parser->header_state = h_general;
1390	- }
1391	- break;
1392	-
1393	- case h_content_length:
1394	- if (!IS_NUM(ch)) {
1395	- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
1396	- goto error;
1397	- }
1398	-
1399	- parser->content_length = ch - '0';
1400	- break;
1401	-
1402	- case h_connection:
1403	- /* looking for 'Connection: keep-alive' */
1404	- if (c == 'k') {
1405	- parser->header_state = h_matching_connection_keep_alive;
1406	- /* looking for 'Connection: close' */
1407	- } else if (c == 'c') {
1408	- parser->header_state = h_matching_connection_close;
1409	- } else {
1410	- parser->header_state = h_general;
1411	- }
1412	- break;
1413	-
1414	- default:
1415	- parser->header_state = h_general;
1416	- break;
1417	- }
1418	- break;
1419	- }
1420	-
1421	- case s_header_value:
1422	- {
1423	-
1424	- if (ch == CR) {
1425	- parser->state = s_header_almost_done;
1426	- CALLBACK_DATA(header_value);
1427	- break;
1428	- }
1429	-
1430	- if (ch == LF) {
1431	- parser->state = s_header_almost_done;
1432	- CALLBACK_DATA_NOADVANCE(header_value);
1433	- goto reexecute_byte;
1434	- }
1435	-
1436	- c = LOWER(ch);
1437	-
1438	- switch (parser->header_state) {
1439	- case h_general:
1440	- break;
1441	-
1442	- case h_connection:
1443	- case h_transfer_encoding:
1444	- assert(0 && "Shouldn't get here.");
1445	- break;
1446	-
1447	- case h_content_length:
1448	- {
1449	- uint64_t t;
1450	-
1451	- if (ch == ' ') break;
1452	-
1453	- if (!IS_NUM(ch)) {
1454	- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
1455	- goto error;
1456	- }
1457	-
1458	- t = parser->content_length;
1459	- t *= 10;
1460	- t += ch - '0';
1461	-
1462	- /* Overflow? */
1463	- if (t < parser->content_length \|\| t == ULLONG_MAX) {
1464	- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
1465	- goto error;
1466	- }
1467	-
1468	- parser->content_length = t;
1469	- break;
1470	- }
1471	-
1472	- /* Transfer-Encoding: chunked */
1473	- case h_matching_transfer_encoding_chunked:
1474	- parser->index++;
1475	- if (parser->index > sizeof(CHUNKED)-1
1476	- \|\| c != CHUNKED[parser->index]) {
1477	- parser->header_state = h_general;
1478	- } else if (parser->index == sizeof(CHUNKED)-2) {
1479	- parser->header_state = h_transfer_encoding_chunked;
1480	- }
1481	- break;
1482	-
1483	- /* looking for 'Connection: keep-alive' */
1484	- case h_matching_connection_keep_alive:
1485	- parser->index++;
1486	- if (parser->index > sizeof(KEEP_ALIVE)-1
1487	- \|\| c != KEEP_ALIVE[parser->index]) {
1488	- parser->header_state = h_general;
1489	- } else if (parser->index == sizeof(KEEP_ALIVE)-2) {
1490	- parser->header_state = h_connection_keep_alive;
1491	- }
1492	- break;
1493	-
1494	- /* looking for 'Connection: close' */
1495	- case h_matching_connection_close:
1496	- parser->index++;
1497	- if (parser->index > sizeof(CLOSE)-1 \|\| c != CLOSE[parser->index]) {
1498	- parser->header_state = h_general;
1499	- } else if (parser->index == sizeof(CLOSE)-2) {
1500	- parser->header_state = h_connection_close;
1501	- }
1502	- break;
1503	-
1504	- case h_transfer_encoding_chunked:
1505	- case h_connection_keep_alive:
1506	- case h_connection_close:
1507	- if (ch != ' ') parser->header_state = h_general;
1508	- break;
1509	-
1510	- default:
1511	- parser->state = s_header_value;
1512	- parser->header_state = h_general;
1513	- break;
1514	- }
1515	- break;
1516	- }
1517	-
1518	- case s_header_almost_done:
1519	- {
1520	- STRICT_CHECK(ch != LF);
1521	-
1522	- parser->state = s_header_value_lws;
1523	-
1524	- switch (parser->header_state) {
1525	- case h_connection_keep_alive:
1526	- parser->flags \|= F_CONNECTION_KEEP_ALIVE;
1527	- break;
1528	- case h_connection_close:
1529	- parser->flags \|= F_CONNECTION_CLOSE;
1530	- break;
1531	- case h_transfer_encoding_chunked:
1532	- parser->flags \|= F_CHUNKED;
1533	- break;
1534	- default:
1535	- break;
1536	- }
1537	-
1538	- break;
1539	- }
1540	-
1541	- case s_header_value_lws:
1542	- {
1543	- if (ch == ' ' \|\| ch == '\t')
1544	- parser->state = s_header_value_start;
1545	- else
1546	- {
1547	- parser->state = s_header_field_start;
1548	- goto reexecute_byte;
1549	- }
1550	- break;
1551	- }
1552	-
1553	- case s_headers_almost_done:
1554	- {
1555	- STRICT_CHECK(ch != LF);
1556	-
1557	- if (parser->flags & F_TRAILING) {
1558	- /* End of a chunked request */
1559	- parser->state = NEW_MESSAGE();
1560	- CALLBACK_NOTIFY(message_complete);
1561	- break;
1562	- }
1563	-
1564	- parser->state = s_headers_done;
1565	-
1566	- /* Set this here so that on_headers_complete() callbacks can see it */
1567	- parser->upgrade =
1568	- (parser->flags & F_UPGRADE \|\| parser->method == HTTP_CONNECT);
1569	-
1570	- /* Here we call the headers_complete callback. This is somewhat
1571	- * different than other callbacks because if the user returns 1, we
1572	- * will interpret that as saying that this message has no body. This
1573	- * is needed for the annoying case of recieving a response to a HEAD
1574	- * request.
1575	- *
1576	- * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so
1577	- * we have to simulate it by handling a change in errno below.
1578	- */
1579	- if (settings->on_headers_complete) {
1580	- switch (settings->on_headers_complete(parser)) {
1581	- case 0:
1582	- break;
1583	-
1584	- case 1:
1585	- parser->flags \|= F_SKIPBODY;
1586	- break;
1587	-
1588	- default:
1589	- SET_ERRNO(HPE_CB_headers_complete);
1590	- return p - data; /* Error */
1591	- }
1592	- }
1593	-
1594	- if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
1595	- return p - data;
1596	- }
1597	-
1598	- goto reexecute_byte;
1599	- }
1600	-
1601	- case s_headers_done:
1602	- {
1603	- STRICT_CHECK(ch != LF);
1604	-
1605	- parser->nread = 0;
1606	-
1607	- /* Exit, the rest of the connect is in a different protocol. */
1608	- if (parser->upgrade) {
1609	- parser->state = NEW_MESSAGE();
1610	- CALLBACK_NOTIFY(message_complete);
1611	- return (p - data) + 1;
1612	- }
1613	-
1614	- if (parser->flags & F_SKIPBODY) {
1615	- parser->state = NEW_MESSAGE();
1616	- CALLBACK_NOTIFY(message_complete);
1617	- } else if (parser->flags & F_CHUNKED) {
1618	- /* chunked encoding - ignore Content-Length header */
1619	- parser->state = s_chunk_size_start;
1620	- } else {
1621	- if (parser->content_length == 0) {
1622	- /* Content-Length header given but zero: Content-Length: 0\r\n */
1623	- parser->state = NEW_MESSAGE();
1624	- CALLBACK_NOTIFY(message_complete);
1625	- } else if (parser->content_length != ULLONG_MAX) {
1626	- /* Content-Length header given and non-zero */
1627	- parser->state = s_body_identity;
1628	- } else {
1629	- if (parser->type == HTTP_REQUEST \|\|
1630	- !http_message_needs_eof(parser)) {
1631	- /* Assume content-length 0 - read the next */
1632	- parser->state = NEW_MESSAGE();
1633	- CALLBACK_NOTIFY(message_complete);
1634	- } else {
1635	- /* Read body until EOF */
1636	- parser->state = s_body_identity_eof;
1637	- }
1638	- }
1639	- }
1640	-
1641	- break;
1642	- }
1643	-
1644	- case s_body_identity:
1645	- {
1646	- uint64_t to_read = MIN(parser->content_length,
1647	- (uint64_t) ((data + len) - p));
1648	-
1649	- assert(parser->content_length != 0
1650	- && parser->content_length != ULLONG_MAX);
1651	-
1652	- /* The difference between advancing content_length and p is because
1653	- * the latter will automaticaly advance on the next loop iteration.
1654	- * Further, if content_length ends up at 0, we want to see the last
1655	- * byte again for our message complete callback.
1656	- */
1657	- MARK(body);
1658	- parser->content_length -= to_read;
1659	- p += to_read - 1;
1660	-
1661	- if (parser->content_length == 0) {
1662	- parser->state = s_message_done;
1663	-
1664	- /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte.
1665	- *
1666	- * The alternative to doing this is to wait for the next byte to
1667	- * trigger the data callback, just as in every other case. The
1668	- * problem with this is that this makes it difficult for the test
1669	- * harness to distinguish between complete-on-EOF and
1670	- * complete-on-length. It's not clear that this distinction is
1671	- * important for applications, but let's keep it for now.
1672	- */
1673	- CALLBACK_DATA_(body, p - body_mark + 1, p - data);
1674	- goto reexecute_byte;
1675	- }
1676	-
1677	- break;
1678	- }
1679	-
1680	- /* read until EOF */
1681	- case s_body_identity_eof:
1682	- MARK(body);
1683	- p = data + len - 1;
1684	-
1685	- break;
1686	-
1687	- case s_message_done:
1688	- parser->state = NEW_MESSAGE();
1689	- CALLBACK_NOTIFY(message_complete);
1690	- break;
1691	-
1692	- case s_chunk_size_start:
1693	- {
1694	- assert(parser->nread == 1);
1695	- assert(parser->flags & F_CHUNKED);
1696	-
1697	- unhex_val = unhex[(unsigned char)ch];
1698	- if (unhex_val == -1) {
1699	- SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
1700	- goto error;
1701	- }
1702	-
1703	- parser->content_length = unhex_val;
1704	- parser->state = s_chunk_size;
1705	- break;
1706	- }
1707	-
1708	- case s_chunk_size:
1709	- {
1710	- uint64_t t;
1711	-
1712	- assert(parser->flags & F_CHUNKED);
1713	-
1714	- if (ch == CR) {
1715	- parser->state = s_chunk_size_almost_done;
1716	- break;
1717	- }
1718	-
1719	- unhex_val = unhex[(unsigned char)ch];
1720	-
1721	- if (unhex_val == -1) {
1722	- if (ch == ';' \|\| ch == ' ') {
1723	- parser->state = s_chunk_parameters;
1724	- break;
1725	- }
1726	-
1727	- SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
1728	- goto error;
1729	- }
1730	-
1731	- t = parser->content_length;
1732	- t *= 16;
1733	- t += unhex_val;
1734	-
1735	- /* Overflow? */
1736	- if (t < parser->content_length \|\| t == ULLONG_MAX) {
1737	- SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
1738	- goto error;
1739	- }
1740	-
1741	- parser->content_length = t;
1742	- break;
1743	- }
1744	-
1745	- case s_chunk_parameters:
1746	- {
1747	- assert(parser->flags & F_CHUNKED);
1748	- /* just ignore this shit. TODO check for overflow */
1749	- if (ch == CR) {
1750	- parser->state = s_chunk_size_almost_done;
1751	- break;
1752	- }
1753	- break;
1754	- }
1755	-
1756	- case s_chunk_size_almost_done:
1757	- {
1758	- assert(parser->flags & F_CHUNKED);
1759	- STRICT_CHECK(ch != LF);
1760	-
1761	- parser->nread = 0;
1762	-
1763	- if (parser->content_length == 0) {
1764	- parser->flags \|= F_TRAILING;
1765	- parser->state = s_header_field_start;
1766	- } else {
1767	- parser->state = s_chunk_data;
1768	- }
1769	- break;
1770	- }
1771	-
1772	- case s_chunk_data:
1773	- {
1774	- uint64_t to_read = MIN(parser->content_length,
1775	- (uint64_t) ((data + len) - p));
1776	-
1777	- assert(parser->flags & F_CHUNKED);
1778	- assert(parser->content_length != 0
1779	- && parser->content_length != ULLONG_MAX);
1780	-
1781	- /* See the explanation in s_body_identity for why the content
1782	- * length and data pointers are managed this way.
1783	- */
1784	- MARK(body);
1785	- parser->content_length -= to_read;
1786	- p += to_read - 1;
1787	-
1788	- if (parser->content_length == 0) {
1789	- parser->state = s_chunk_data_almost_done;
1790	- }
1791	-
1792	- break;
1793	- }
1794	-
1795	- case s_chunk_data_almost_done:
1796	- assert(parser->flags & F_CHUNKED);
1797	- assert(parser->content_length == 0);
1798	- STRICT_CHECK(ch != CR);
1799	- parser->state = s_chunk_data_done;
1800	- CALLBACK_DATA(body);
1801	- break;
1802	-
1803	- case s_chunk_data_done:
1804	- assert(parser->flags & F_CHUNKED);
1805	- STRICT_CHECK(ch != LF);
1806	- parser->nread = 0;
1807	- parser->state = s_chunk_size_start;
1808	- break;
1809	-
1810	- default:
1811	- assert(0 && "unhandled state");
1812	- SET_ERRNO(HPE_INVALID_INTERNAL_STATE);
1813	- goto error;
1814	- }
1815	- }
1816	-
1817	- /* Run callbacks for any marks that we have leftover after we ran our of
1818	- * bytes. There should be at most one of these set, so it's OK to invoke
1819	- * them in series (unset marks will not result in callbacks).
1820	- *
1821	- * We use the NOADVANCE() variety of callbacks here because 'p' has already
1822	- * overflowed 'data' and this allows us to correct for the off-by-one that
1823	- * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p'
1824	- * value that's in-bounds).
1825	- */
1826	-
1827	- assert(((header_field_mark ? 1 : 0) +
1828	- (header_value_mark ? 1 : 0) +
1829	- (url_mark ? 1 : 0) +
1830	- (body_mark ? 1 : 0)) <= 1);
1831	-
1832	- CALLBACK_DATA_NOADVANCE(header_field);
1833	- CALLBACK_DATA_NOADVANCE(header_value);
1834	- CALLBACK_DATA_NOADVANCE(url);
1835	- CALLBACK_DATA_NOADVANCE(body);
1836	-
1837	- return len;
1838	-
1839	-error:
1840	- if (HTTP_PARSER_ERRNO(parser) == HPE_OK) {
1841	- SET_ERRNO(HPE_UNKNOWN);
1842	- }
1843	-
1844	- return (p - data);
1845	-}
1846	-
1847	-
1848	-/* Does the parser need to see an EOF to find the end of the message? */
1849	-int
1850	-http_message_needs_eof (const http_parser *parser)
1851	-{
1852	- if (parser->type == HTTP_REQUEST) {
1853	- return 0;
1854	- }
1855	-
1856	- /* See RFC 2616 section 4.4 */
1857	- if (parser->status_code / 100 == 1 \|\| /* 1xx e.g. Continue */
1858	- parser->status_code == 204 \|\| /* No Content */
1859	- parser->status_code == 304 \|\| /* Not Modified */
1860	- parser->flags & F_SKIPBODY) { /* response to a HEAD request */
1861	- return 0;
1862	- }
1863	-
1864	- if ((parser->flags & F_CHUNKED) \|\| parser->content_length != ULLONG_MAX) {
1865	- return 0;
1866	- }
1867	-
1868	- return 1;
1869	-}
1870	-
1871	-
1872	-int
1873	-http_should_keep_alive (const http_parser *parser)
1874	-{
1875	- if (parser->http_major > 0 && parser->http_minor > 0) {
1876	- /* HTTP/1.1 */
1877	- if (parser->flags & F_CONNECTION_CLOSE) {
1878	- return 0;
1879	- }
1880	- } else {
1881	- /* HTTP/1.0 or earlier */
1882	- if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
1883	- return 0;
1884	- }
1885	- }
1886	-
1887	- return !http_message_needs_eof(parser);
1888	-}
1889	-
1890	-
1891	-const char *
1892	-http_method_str (enum http_method m)
1893	-{
1894	- return ELEM_AT(method_strings, m, "<unknown>");
1895	-}
1896	-
1897	-
1898	-void
1899	-http_parser_init (http_parser *parser, enum http_parser_type t)
1900	-{
1901	- void data = parser->data; / preserve application data */
1902	- memset(parser, 0, sizeof(*parser));
1903	- parser->data = data;
1904	- parser->type = t;
1905	- parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
1906	- parser->http_errno = HPE_OK;
1907	-}
1908	-
1909	-const char *
1910	-http_errno_name(enum http_errno err) {
1911	- assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0])));
1912	- return http_strerror_tab[err].name;
1913	-}
1914	-
1915	-const char *
1916	-http_errno_description(enum http_errno err) {
1917	- assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0])));
1918	- return http_strerror_tab[err].description;
1919	-}
1920	-
1921	-static enum http_host_state
1922	-http_parse_host_char(enum http_host_state s, const char ch) {
1923	- switch(s) {
1924	- case s_http_userinfo:
1925	- case s_http_userinfo_start:
1926	- if (ch == '@') {
1927	- return s_http_host_start;
1928	- }
1929	-
1930	- if (IS_USERINFO_CHAR(ch)) {
1931	- return s_http_userinfo;
1932	- }
1933	- break;
1934	-
1935	- case s_http_host_start:
1936	- if (ch == '[') {
1937	- return s_http_host_v6_start;
1938	- }
1939	-
1940	- if (IS_HOST_CHAR(ch)) {
1941	- return s_http_host;
1942	- }
1943	-
1944	- break;
1945	-
1946	- case s_http_host:
1947	- if (IS_HOST_CHAR(ch)) {
1948	- return s_http_host;
1949	- }
1950	-
1951	- /* FALLTHROUGH */
1952	- case s_http_host_v6_end:
1953	- if (ch == ':') {
1954	- return s_http_host_port_start;
1955	- }
1956	-
1957	- break;
1958	-
1959	- case s_http_host_v6:
1960	- if (ch == ']') {
1961	- return s_http_host_v6_end;
1962	- }
1963	-
1964	- /* FALLTHROUGH */
1965	- case s_http_host_v6_start:
1966	- if (IS_HEX(ch) \|\| ch == ':' \|\| ch == '.') {
1967	- return s_http_host_v6;
1968	- }
1969	-
1970	- break;
1971	-
1972	- case s_http_host_port:
1973	- case s_http_host_port_start:
1974	- if (IS_NUM(ch)) {
1975	- return s_http_host_port;
1976	- }
1977	-
1978	- break;
1979	-
1980	- default:
1981	- break;
1982	- }
1983	- return s_http_host_dead;
1984	-}
1985	-
1986	-static int
1987	-http_parse_host(const char * buf, struct http_parser_url *u, int found_at) {
1988	- enum http_host_state s;
1989	-
1990	- const char *p;
1991	- size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len;
1992	-
1993	- u->field_data[UF_HOST].len = 0;
1994	-
1995	- s = found_at ? s_http_userinfo_start : s_http_host_start;
1996	-
1997	- for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) {
1998	- enum http_host_state new_s = http_parse_host_char(s, *p);
1999	-
2000	- if (new_s == s_http_host_dead) {
2001	- return 1;
2002	- }
2003	-
2004	- switch(new_s) {
2005	- case s_http_host:
2006	- if (s != s_http_host) {
2007	- u->field_data[UF_HOST].off = (uint16_t) (p - buf);
2008	- }
2009	- u->field_data[UF_HOST].len++;
2010	- break;
2011	-
2012	- case s_http_host_v6:
2013	- if (s != s_http_host_v6) {
2014	- u->field_data[UF_HOST].off = (uint16_t) (p - buf);
2015	- }
2016	- u->field_data[UF_HOST].len++;
2017	- break;
2018	-
2019	- case s_http_host_port:
2020	- if (s != s_http_host_port) {
2021	- u->field_data[UF_PORT].off = (uint16_t) (p - buf);
2022	- u->field_data[UF_PORT].len = 0;
2023	- u->field_set \|= (1 << UF_PORT);
2024	- }
2025	- u->field_data[UF_PORT].len++;
2026	- break;
2027	-
2028	- case s_http_userinfo:
2029	- if (s != s_http_userinfo) {
2030	- u->field_data[UF_USERINFO].off = (uint16_t) (p - buf) ;
2031	- u->field_data[UF_USERINFO].len = 0;
2032	- u->field_set \|= (1 << UF_USERINFO);
2033	- }
2034	- u->field_data[UF_USERINFO].len++;
2035	- break;
2036	-
2037	- default:
2038	- break;
2039	- }
2040	- s = new_s;
2041	- }
2042	-
2043	- /* Make sure we don't end somewhere unexpected */
2044	- switch (s) {
2045	- case s_http_host_start:
2046	- case s_http_host_v6_start:
2047	- case s_http_host_v6:
2048	- case s_http_host_port_start:
2049	- case s_http_userinfo:
2050	- case s_http_userinfo_start:
2051	- return 1;
2052	- default:
2053	- break;
2054	- }
2055	-
2056	- return 0;
2057	-}
2058	-
2059	-int
2060	-http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
2061	- struct http_parser_url *u)
2062	-{
2063	- enum state s;
2064	- const char *p;
2065	- enum http_parser_url_fields uf, old_uf;
2066	- int found_at = 0;
2067	-
2068	- u->port = u->field_set = 0;
2069	- s = is_connect ? s_req_server_start : s_req_spaces_before_url;
2070	- uf = old_uf = UF_MAX;
2071	-
2072	- for (p = buf; p < buf + buflen; p++) {
2073	- s = parse_url_char(s, *p);
2074	-
2075	- /* Figure out the next field that we're operating on */
2076	- switch (s) {
2077	- case s_dead:
2078	- return 1;
2079	-
2080	- /* Skip delimeters */
2081	- case s_req_schema_slash:
2082	- case s_req_schema_slash_slash:
2083	- case s_req_server_start:
2084	- case s_req_query_string_start:
2085	- case s_req_fragment_start:
2086	- continue;
2087	-
2088	- case s_req_schema:
2089	- uf = UF_SCHEMA;
2090	- break;
2091	-
2092	- case s_req_server_with_at:
2093	- found_at = 1;
2094	-
2095	- /* FALLTROUGH */
2096	- case s_req_server:
2097	- uf = UF_HOST;
2098	- break;
2099	-
2100	- case s_req_path:
2101	- uf = UF_PATH;
2102	- break;
2103	-
2104	- case s_req_query_string:
2105	- uf = UF_QUERY;
2106	- break;
2107	-
2108	- case s_req_fragment:
2109	- uf = UF_FRAGMENT;
2110	- break;
2111	-
2112	- default:
2113	- assert(!"Unexpected state");
2114	- return 1;
2115	- }
2116	-
2117	- /* Nothing's changed; soldier on */
2118	- if (uf == old_uf) {
2119	- u->field_data[uf].len++;
2120	- continue;
2121	- }
2122	-
2123	- u->field_data[uf].off = (uint16_t) (p - buf);
2124	- u->field_data[uf].len = 1;
2125	-
2126	- u->field_set \|= (1 << uf);
2127	- old_uf = uf;
2128	- }
2129	-
2130	- /* host must be present if there is a schema */
2131	- /* parsing http:///toto will fail */
2132	- if ((u->field_set & ((1 << UF_SCHEMA) \| (1 << UF_HOST))) != 0) {
2133	- if (http_parse_host(buf, u, found_at) != 0) {
2134	- return 1;
2135	- }
2136	- }
2137	-
2138	- /* CONNECT requests can only contain "hostname:port" */
2139	- if (is_connect && u->field_set != ((1 << UF_HOST)\|(1 << UF_PORT))) {
2140	- return 1;
2141	- }
2142	-
2143	- if (u->field_set & (1 << UF_PORT)) {
2144	- /* Don't bother with endp; we've already validated the string */
2145	- unsigned long v = strtoul(buf + u->field_data[UF_PORT].off, NULL, 10);
2146	-
2147	- /* Ports have a max value of 2^16 */
2148	- if (v > 0xffff) {
2149	- return 1;
2150	- }
2151	-
2152	- u->port = (uint16_t) v;
2153	- }
2154	-
2155	- return 0;
2156	-}
2157	-
2158	-void
2159	-http_parser_pause(http_parser *parser, int paused) {
2160	- /* Users should only be pausing/unpausing a parser that is not in an error
2161	- * state. In non-debug builds, there's not much that we can do about this
2162	- * other than ignore it.
2163	- */
2164	- if (HTTP_PARSER_ERRNO(parser) == HPE_OK \|\|
2165	- HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) {
2166	- SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK);
2167	- } else {
2168	- assert(0 && "Attempting to pause parser in error state");
2169	- }
2170	-}
2171	-
2172	-int
2173	-http_body_is_final(const struct http_parser *parser) {
2174	- return parser->state == s_message_done;
2175	-}

3rdparty/http-parser-2.1/http_parser.gyp deleted

View file @2d6ccbf

1	-# This file is used with the GYP meta build system.
2	-# http://code.google.com/p/gyp/
3	-# To build try this:
4	-# svn co http://gyp.googlecode.com/svn/trunk gyp
5	-# ./gyp/gyp -f make --depth=`pwd` http_parser.gyp
6	-# ./out/Debug/test
7	-{
8	- 'target_defaults': {
9	- 'default_configuration': 'Debug',
10	- 'configurations': {
11	- # TODO: hoist these out and put them somewhere common, because
12	- # RuntimeLibrary MUST MATCH across the entire project
13	- 'Debug': {
14	- 'defines': [ 'DEBUG', '_DEBUG' ],
15	- 'cflags': [ '-Wall', '-Wextra', '-O0', '-g', '-ftrapv' ],
16	- 'msvs_settings': {
17	- 'VCCLCompilerTool': {
18	- 'RuntimeLibrary': 1, # static debug
19	- },
20	- },
21	- },
22	- 'Release': {
23	- 'defines': [ 'NDEBUG' ],
24	- 'cflags': [ '-Wall', '-Wextra', '-O3' ],
25	- 'msvs_settings': {
26	- 'VCCLCompilerTool': {
27	- 'RuntimeLibrary': 0, # static release
28	- },
29	- },
30	- }
31	- },
32	- 'msvs_settings': {
33	- 'VCCLCompilerTool': {
34	- },
35	- 'VCLibrarianTool': {
36	- },
37	- 'VCLinkerTool': {
38	- 'GenerateDebugInformation': 'true',
39	- },
40	- },
41	- 'conditions': [
42	- ['OS == "win"', {
43	- 'defines': [
44	- 'WIN32'
45	- ],
46	- }]
47	- ],
48	- },
49	-
50	- 'targets': [
51	- {
52	- 'target_name': 'http_parser',
53	- 'type': 'static_library',
54	- 'include_dirs': [ '.' ],
55	- 'direct_dependent_settings': {
56	- 'defines': [ 'HTTP_PARSER_STRICT=0' ],
57	- 'include_dirs': [ '.' ],
58	- },
59	- 'defines': [ 'HTTP_PARSER_STRICT=0' ],
60	- 'sources': [ './http_parser.c', ],
61	- 'conditions': [
62	- ['OS=="win"', {
63	- 'msvs_settings': {
64	- 'VCCLCompilerTool': {
65	- # Compile as C++. http_parser.c is actually C99, but C++ is
66	- # close enough in this case.
67	- 'CompileAs': 2,
68	- },
69	- },
70	- }]
71	- ],
72	- },
73	-
74	- {
75	- 'target_name': 'http_parser_strict',
76	- 'type': 'static_library',
77	- 'include_dirs': [ '.' ],
78	- 'direct_dependent_settings': {
79	- 'defines': [ 'HTTP_PARSER_STRICT=1' ],
80	- 'include_dirs': [ '.' ],
81	- },
82	- 'defines': [ 'HTTP_PARSER_STRICT=1' ],
83	- 'sources': [ './http_parser.c', ],
84	- 'conditions': [
85	- ['OS=="win"', {
86	- 'msvs_settings': {
87	- 'VCCLCompilerTool': {
88	- # Compile as C++. http_parser.c is actually C99, but C++ is
89	- # close enough in this case.
90	- 'CompileAs': 2,
91	- },
92	- },
93	- }]
94	- ],
95	- },
96	-
97	- {
98	- 'target_name': 'test-nonstrict',
99	- 'type': 'executable',
100	- 'dependencies': [ 'http_parser' ],
101	- 'sources': [ 'test.c' ]
102	- },
103	-
104	- {
105	- 'target_name': 'test-strict',
106	- 'type': 'executable',
107	- 'dependencies': [ 'http_parser_strict' ],
108	- 'sources': [ 'test.c' ]
109	- }
110	- ]
111	-}

3rdparty/http-parser-2.1/http_parser.h deleted

View file @2d6ccbf

1	-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2	- *
3	- * Permission is hereby granted, free of charge, to any person obtaining a copy
4	- * of this software and associated documentation files (the "Software"), to
5	- * deal in the Software without restriction, including without limitation the
6	- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7	- * sell copies of the Software, and to permit persons to whom the Software is
8	- * furnished to do so, subject to the following conditions:
9	- *
10	- * The above copyright notice and this permission notice shall be included in
11	- * all copies or substantial portions of the Software.
12	- *
13	- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18	- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19	- * IN THE SOFTWARE.
20	- */
21	-#ifndef http_parser_h
22	-#define http_parser_h
23	-#ifdef __cplusplus
24	-extern "C" {
25	-#endif
26	-
27	-#define HTTP_PARSER_VERSION_MAJOR 2
28	-#define HTTP_PARSER_VERSION_MINOR 1
29	-
30	-#include <sys/types.h>
31	-#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) \|\| _MSC_VER<1600)
32	-#include <BaseTsd.h>
33	-#include <stddef.h>
34	-typedef __int8 int8_t;
35	-typedef unsigned __int8 uint8_t;
36	-typedef __int16 int16_t;
37	-typedef unsigned __int16 uint16_t;
38	-typedef __int32 int32_t;
39	-typedef unsigned __int32 uint32_t;
40	-typedef __int64 int64_t;
41	-typedef unsigned __int64 uint64_t;
42	-#else
43	-#include <stdint.h>
44	-#endif
45	-
46	-/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
47	- * faster
48	- */
49	-#ifndef HTTP_PARSER_STRICT
50	-# define HTTP_PARSER_STRICT 1
51	-#endif
52	-
53	-/* Maximium header size allowed */
54	-#define HTTP_MAX_HEADER_SIZE (80*1024)
55	-
56	-
57	-typedef struct http_parser http_parser;
58	-typedef struct http_parser_settings http_parser_settings;
59	-
60	-
61	-/* Callbacks should return non-zero to indicate an error. The parser will
62	- * then halt execution.
63	- *
64	- * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
65	- * returning '1' from on_headers_complete will tell the parser that it
66	- * should not expect a body. This is used when receiving a response to a
67	- * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
68	- * chunked' headers that indicate the presence of a body.
69	- *
70	- * http_data_cb does not return data chunks. It will be call arbitrarally
71	- * many times for each string. E.G. you might get 10 callbacks for "on_url"
72	- * each providing just a few characters more data.
73	- */
74	-typedef int (http_data_cb) (http_parser, const char *at, size_t length);
75	-typedef int (http_cb) (http_parser);
76	-
77	-
78	-/* Request Methods */
79	-#define HTTP_METHOD_MAP(XX) \
80	- XX(0, DELETE, DELETE) \
81	- XX(1, GET, GET) \
82	- XX(2, HEAD, HEAD) \
83	- XX(3, POST, POST) \
84	- XX(4, PUT, PUT) \
85	- /* pathological */ \
86	- XX(5, CONNECT, CONNECT) \
87	- XX(6, OPTIONS, OPTIONS) \
88	- XX(7, TRACE, TRACE) \
89	- /* webdav */ \
90	- XX(8, COPY, COPY) \
91	- XX(9, LOCK, LOCK) \
92	- XX(10, MKCOL, MKCOL) \
93	- XX(11, MOVE, MOVE) \
94	- XX(12, PROPFIND, PROPFIND) \
95	- XX(13, PROPPATCH, PROPPATCH) \
96	- XX(14, SEARCH, SEARCH) \
97	- XX(15, UNLOCK, UNLOCK) \
98	- /* subversion */ \
99	- XX(16, REPORT, REPORT) \
100	- XX(17, MKACTIVITY, MKACTIVITY) \
101	- XX(18, CHECKOUT, CHECKOUT) \
102	- XX(19, MERGE, MERGE) \
103	- /* upnp */ \
104	- XX(20, MSEARCH, M-SEARCH) \
105	- XX(21, NOTIFY, NOTIFY) \
106	- XX(22, SUBSCRIBE, SUBSCRIBE) \
107	- XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \
108	- /* RFC-5789 */ \
109	- XX(24, PATCH, PATCH) \
110	- XX(25, PURGE, PURGE) \
111	-
112	-enum http_method
113	- {
114	-#define XX(num, name, string) HTTP_##name = num,
115	- HTTP_METHOD_MAP(XX)
116	-#undef XX
117	- };
118	-
119	-
120	-enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
121	-
122	-
123	-/* Flag values for http_parser.flags field */
124	-enum flags
125	- { F_CHUNKED = 1 << 0
126	- , F_CONNECTION_KEEP_ALIVE = 1 << 1
127	- , F_CONNECTION_CLOSE = 1 << 2
128	- , F_TRAILING = 1 << 3
129	- , F_UPGRADE = 1 << 4
130	- , F_SKIPBODY = 1 << 5
131	- };
132	-
133	-
134	-/* Map for errno-related constants
135	- *
136	- * The provided argument should be a macro that takes 2 arguments.
137	- */
138	-#define HTTP_ERRNO_MAP(XX) \
139	- /* No error */ \
140	- XX(OK, "success") \
141	- \
142	- /* Callback-related errors */ \
143	- XX(CB_message_begin, "the on_message_begin callback failed") \
144	- XX(CB_status_complete, "the on_status_complete callback failed") \
145	- XX(CB_url, "the on_url callback failed") \
146	- XX(CB_header_field, "the on_header_field callback failed") \
147	- XX(CB_header_value, "the on_header_value callback failed") \
148	- XX(CB_headers_complete, "the on_headers_complete callback failed") \
149	- XX(CB_body, "the on_body callback failed") \
150	- XX(CB_message_complete, "the on_message_complete callback failed") \
151	- \
152	- /* Parsing-related errors */ \
153	- XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
154	- XX(HEADER_OVERFLOW, \
155	- "too many header bytes seen; overflow detected") \
156	- XX(CLOSED_CONNECTION, \
157	- "data received after completed connection: close message") \
158	- XX(INVALID_VERSION, "invalid HTTP version") \
159	- XX(INVALID_STATUS, "invalid HTTP status code") \
160	- XX(INVALID_METHOD, "invalid HTTP method") \
161	- XX(INVALID_URL, "invalid URL") \
162	- XX(INVALID_HOST, "invalid host") \
163	- XX(INVALID_PORT, "invalid port") \
164	- XX(INVALID_PATH, "invalid path") \
165	- XX(INVALID_QUERY_STRING, "invalid query string") \
166	- XX(INVALID_FRAGMENT, "invalid fragment") \
167	- XX(LF_EXPECTED, "LF character expected") \
168	- XX(INVALID_HEADER_TOKEN, "invalid character in header") \
169	- XX(INVALID_CONTENT_LENGTH, \
170	- "invalid character in content-length header") \
171	- XX(INVALID_CHUNK_SIZE, \
172	- "invalid character in chunk size header") \
173	- XX(INVALID_CONSTANT, "invalid constant string") \
174	- XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
175	- XX(STRICT, "strict mode assertion failed") \
176	- XX(PAUSED, "parser is paused") \
177	- XX(UNKNOWN, "an unknown error occurred")
178	-
179	-
180	-/* Define HPE_* values for each errno value above */
181	-#define HTTP_ERRNO_GEN(n, s) HPE_##n,
182	-enum http_errno {
183	- HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
184	-};
185	-#undef HTTP_ERRNO_GEN
186	-
187	-
188	-/* Get an http_errno value from an http_parser */
189	-#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno)
190	-
191	-
192	-struct http_parser {
193	- / PRIVATE /
194	- unsigned char type : 2; /* enum http_parser_type */
195	- unsigned char flags : 6; /* F_* values from 'flags' enum; semi-public */
196	- unsigned char state; /* enum state from http_parser.c */
197	- unsigned char header_state; /* enum header_state from http_parser.c */
198	- unsigned char index; /* index into current matcher */
199	-
200	- uint32_t nread; /* # bytes read in various scenarios */
201	- uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
202	-
203	- / READ-ONLY /
204	- unsigned short http_major;
205	- unsigned short http_minor;
206	- unsigned short status_code; /* responses only */
207	- unsigned char method; /* requests only */
208	- unsigned char http_errno : 7;
209	-
210	- /* 1 = Upgrade header was present and the parser has exited because of that.
211	- * 0 = No upgrade header present.
212	- * Should be checked when http_parser_execute() returns in addition to
213	- * error checking.
214	- */
215	- unsigned char upgrade : 1;
216	-
217	- / PUBLIC /
218	- void data; / A pointer to get hook to the "connection" or "socket" object */
219	-};
220	-
221	-
222	-struct http_parser_settings {
223	- http_cb on_message_begin;
224	- http_data_cb on_url;
225	- http_cb on_status_complete;
226	- http_data_cb on_header_field;
227	- http_data_cb on_header_value;
228	- http_cb on_headers_complete;
229	- http_data_cb on_body;
230	- http_cb on_message_complete;
231	-};
232	-
233	-
234	-enum http_parser_url_fields
235	- { UF_SCHEMA = 0
236	- , UF_HOST = 1
237	- , UF_PORT = 2
238	- , UF_PATH = 3
239	- , UF_QUERY = 4
240	- , UF_FRAGMENT = 5
241	- , UF_USERINFO = 6
242	- , UF_MAX = 7
243	- };
244	-
245	-
246	-/* Result structure for http_parser_parse_url().
247	- *
248	- * Callers should index into field_data[] with UF_* values iff field_set
249	- * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
250	- * because we probably have padding left over), we convert any port to
251	- * a uint16_t.
252	- */
253	-struct http_parser_url {
254	- uint16_t field_set; /* Bitmask of (1 << UF_) values /
255	- uint16_t port; /* Converted UF_PORT string */
256	-
257	- struct {
258	- uint16_t off; /* Offset into buffer in which field starts */
259	- uint16_t len; /* Length of run in buffer */
260	- } field_data[UF_MAX];
261	-};
262	-
263	-
264	-void http_parser_init(http_parser *parser, enum http_parser_type type);
265	-
266	-
267	-size_t http_parser_execute(http_parser *parser,
268	- const http_parser_settings *settings,
269	- const char *data,
270	- size_t len);
271	-
272	-
273	-/* If http_should_keep_alive() in the on_headers_complete or
274	- * on_message_complete callback returns 0, then this should be
275	- * the last message on the connection.
276	- * If you are the server, respond with the "Connection: close" header.
277	- * If you are the client, close the connection.
278	- */
279	-int http_should_keep_alive(const http_parser *parser);
280	-
281	-/* Returns a string version of the HTTP method. */
282	-const char *http_method_str(enum http_method m);
283	-
284	-/* Return a string name of the given error */
285	-const char *http_errno_name(enum http_errno err);
286	-
287	-/* Return a string description of the given error */
288	-const char *http_errno_description(enum http_errno err);
289	-
290	-/* Parse a URL; return nonzero on failure */
291	-int http_parser_parse_url(const char *buf, size_t buflen,
292	- int is_connect,
293	- struct http_parser_url *u);
294	-
295	-/* Pause or un-pause the parser; a nonzero value pauses */
296	-void http_parser_pause(http_parser *parser, int paused);
297	-
298	-/* Checks if this is the final chunk of the body. */
299	-int http_body_is_final(const http_parser *parser);
300	-
301	-#ifdef __cplusplus
302	-}
303	-#endif
304	-#endif

3rdparty/http-parser-2.1/test.c deleted

View file @2d6ccbf

1	-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2	- *
3	- * Permission is hereby granted, free of charge, to any person obtaining a copy
4	- * of this software and associated documentation files (the "Software"), to
5	- * deal in the Software without restriction, including without limitation the
6	- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7	- * sell copies of the Software, and to permit persons to whom the Software is
8	- * furnished to do so, subject to the following conditions:
9	- *
10	- * The above copyright notice and this permission notice shall be included in
11	- * all copies or substantial portions of the Software.
12	- *
13	- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18	- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19	- * IN THE SOFTWARE.
20	- */
21	-#include "http_parser.h"
22	-#include <stdlib.h>
23	-#include <assert.h>
24	-#include <stdio.h>
25	-#include <stdlib.h> /* rand */
26	-#include <string.h>
27	-#include <stdarg.h>
28	-
29	-#undef TRUE
30	-#define TRUE 1
31	-#undef FALSE
32	-#define FALSE 0
33	-
34	-#define MAX_HEADERS 13
35	-#define MAX_ELEMENT_SIZE 2048
36	-
37	-#define MIN(a,b) ((a) < (b) ? (a) : (b))
38	-
39	-static http_parser *parser;
40	-
41	-struct message {
42	- const char *name; // for debugging purposes
43	- const char *raw;
44	- enum http_parser_type type;
45	- enum http_method method;
46	- int status_code;
47	- char request_path[MAX_ELEMENT_SIZE];
48	- char request_url[MAX_ELEMENT_SIZE];
49	- char fragment[MAX_ELEMENT_SIZE];
50	- char query_string[MAX_ELEMENT_SIZE];
51	- char body[MAX_ELEMENT_SIZE];
52	- size_t body_size;
53	- const char *host;
54	- const char *userinfo;
55	- uint16_t port;
56	- int num_headers;
57	- enum { NONE=0, FIELD, VALUE } last_header_element;
58	- char headers [MAX_HEADERS][2][MAX_ELEMENT_SIZE];
59	- int should_keep_alive;
60	-
61	- const char *upgrade; // upgraded body
62	-
63	- unsigned short http_major;
64	- unsigned short http_minor;
65	-
66	- int message_begin_cb_called;
67	- int headers_complete_cb_called;
68	- int message_complete_cb_called;
69	- int message_complete_on_eof;
70	- int body_is_final;
71	-};
72	-
73	-static int currently_parsing_eof;
74	-
75	-static struct message messages[5];
76	-static int num_messages;
77	-static http_parser_settings *current_pause_parser;
78	-
79	-/* * R E Q U E S T S * */
80	-const struct message requests[] =
81	-#define CURL_GET 0
82	-{ {.name= "curl get"
83	- ,.type= HTTP_REQUEST
84	- ,.raw= "GET /test HTTP/1.1\r\n"
85	- "User-Agent: curl/7.18.0 (i486-pc-linux-gnu) libcurl/7.18.0 OpenSSL/0.9.8g zlib/1.2.3.3 libidn/1.1\r\n"
86	- "Host: 0.0.0.0=5000\r\n"
87	- "Accept: /\r\n"
88	- "\r\n"
89	- ,.should_keep_alive= TRUE
90	- ,.message_complete_on_eof= FALSE
91	- ,.http_major= 1
92	- ,.http_minor= 1
93	- ,.method= HTTP_GET
94	- ,.query_string= ""
95	- ,.fragment= ""
96	- ,.request_path= "/test"
97	- ,.request_url= "/test"
98	- ,.num_headers= 3
99	- ,.headers=
100	- { { "User-Agent", "curl/7.18.0 (i486-pc-linux-gnu) libcurl/7.18.0 OpenSSL/0.9.8g zlib/1.2.3.3 libidn/1.1" }
101	- , { "Host", "0.0.0.0=5000" }
102	- , { "Accept", "/" }
103	- }
104	- ,.body= ""
105	- }
106	-
107	-#define FIREFOX_GET 1
108	-, {.name= "firefox get"
109	- ,.type= HTTP_REQUEST
110	- ,.raw= "GET /favicon.ico HTTP/1.1\r\n"
111	- "Host: 0.0.0.0=5000\r\n"
112	- "User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0\r\n"
113	- "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8\r\n"
114	- "Accept-Language: en-us,en;q=0.5\r\n"
115	- "Accept-Encoding: gzip,deflate\r\n"
116	- "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
117	- "Keep-Alive: 300\r\n"
118	- "Connection: keep-alive\r\n"
119	- "\r\n"
120	- ,.should_keep_alive= TRUE
121	- ,.message_complete_on_eof= FALSE
122	- ,.http_major= 1
123	- ,.http_minor= 1
124	- ,.method= HTTP_GET
125	- ,.query_string= ""
126	- ,.fragment= ""
127	- ,.request_path= "/favicon.ico"
128	- ,.request_url= "/favicon.ico"
129	- ,.num_headers= 8
130	- ,.headers=
131	- { { "Host", "0.0.0.0=5000" }
132	- , { "User-Agent", "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0" }
133	- , { "Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8" }
134	- , { "Accept-Language", "en-us,en;q=0.5" }
135	- , { "Accept-Encoding", "gzip,deflate" }
136	- , { "Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7" }
137	- , { "Keep-Alive", "300" }
138	- , { "Connection", "keep-alive" }
139	- }
140	- ,.body= ""
141	- }
142	-
143	-#define DUMBFUCK 2
144	-, {.name= "dumbfuck"
145	- ,.type= HTTP_REQUEST
146	- ,.raw= "GET /dumbfuck HTTP/1.1\r\n"
147	- "aaaaaaaaaaaaa:++++++++++\r\n"
148	- "\r\n"
149	- ,.should_keep_alive= TRUE
150	- ,.message_complete_on_eof= FALSE
151	- ,.http_major= 1
152	- ,.http_minor= 1
153	- ,.method= HTTP_GET
154	- ,.query_string= ""
155	- ,.fragment= ""
156	- ,.request_path= "/dumbfuck"
157	- ,.request_url= "/dumbfuck"
158	- ,.num_headers= 1
159	- ,.headers=
160	- { { "aaaaaaaaaaaaa", "++++++++++" }
161	- }
162	- ,.body= ""
163	- }
164	-
165	-#define FRAGMENT_IN_URI 3
166	-, {.name= "fragment in url"
167	- ,.type= HTTP_REQUEST
168	- ,.raw= "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n"
169	- "\r\n"
170	- ,.should_keep_alive= TRUE
171	- ,.message_complete_on_eof= FALSE
172	- ,.http_major= 1
173	- ,.http_minor= 1
174	- ,.method= HTTP_GET
175	- ,.query_string= "page=1"
176	- ,.fragment= "posts-17408"
177	- ,.request_path= "/forums/1/topics/2375"
178	- /* XXX request url does include fragment? */
179	- ,.request_url= "/forums/1/topics/2375?page=1#posts-17408"
180	- ,.num_headers= 0
181	- ,.body= ""
182	- }
183	-
184	-#define GET_NO_HEADERS_NO_BODY 4
185	-, {.name= "get no headers no body"
186	- ,.type= HTTP_REQUEST
187	- ,.raw= "GET /get_no_headers_no_body/world HTTP/1.1\r\n"
188	- "\r\n"
189	- ,.should_keep_alive= TRUE
190	- ,.message_complete_on_eof= FALSE /* would need Connection: close */
191	- ,.http_major= 1
192	- ,.http_minor= 1
193	- ,.method= HTTP_GET
194	- ,.query_string= ""
195	- ,.fragment= ""
196	- ,.request_path= "/get_no_headers_no_body/world"
197	- ,.request_url= "/get_no_headers_no_body/world"
198	- ,.num_headers= 0
199	- ,.body= ""
200	- }
201	-
202	-#define GET_ONE_HEADER_NO_BODY 5
203	-, {.name= "get one header no body"
204	- ,.type= HTTP_REQUEST
205	- ,.raw= "GET /get_one_header_no_body HTTP/1.1\r\n"
206	- "Accept: /\r\n"
207	- "\r\n"
208	- ,.should_keep_alive= TRUE
209	- ,.message_complete_on_eof= FALSE /* would need Connection: close */
210	- ,.http_major= 1
211	- ,.http_minor= 1
212	- ,.method= HTTP_GET
213	- ,.query_string= ""
214	- ,.fragment= ""
215	- ,.request_path= "/get_one_header_no_body"
216	- ,.request_url= "/get_one_header_no_body"
217	- ,.num_headers= 1
218	- ,.headers=
219	- { { "Accept" , "/" }
220	- }
221	- ,.body= ""
222	- }
223	-
224	-#define GET_FUNKY_CONTENT_LENGTH 6
225	-, {.name= "get funky content length body hello"
226	- ,.type= HTTP_REQUEST
227	- ,.raw= "GET /get_funky_content_length_body_hello HTTP/1.0\r\n"
228	- "conTENT-Length: 5\r\n"
229	- "\r\n"
230	- "HELLO"
231	- ,.should_keep_alive= FALSE
232	- ,.message_complete_on_eof= FALSE
233	- ,.http_major= 1
234	- ,.http_minor= 0
235	- ,.method= HTTP_GET
236	- ,.query_string= ""
237	- ,.fragment= ""
238	- ,.request_path= "/get_funky_content_length_body_hello"
239	- ,.request_url= "/get_funky_content_length_body_hello"
240	- ,.num_headers= 1
241	- ,.headers=
242	- { { "conTENT-Length" , "5" }
243	- }
244	- ,.body= "HELLO"
245	- }
246	-
247	-#define POST_IDENTITY_BODY_WORLD 7
248	-, {.name= "post identity body world"
249	- ,.type= HTTP_REQUEST
250	- ,.raw= "POST /post_identity_body_world?q=search#hey HTTP/1.1\r\n"
251	- "Accept: /\r\n"
252	- "Transfer-Encoding: identity\r\n"
253	- "Content-Length: 5\r\n"
254	- "\r\n"
255	- "World"
256	- ,.should_keep_alive= TRUE
257	- ,.message_complete_on_eof= FALSE
258	- ,.http_major= 1
259	- ,.http_minor= 1
260	- ,.method= HTTP_POST
261	- ,.query_string= "q=search"
262	- ,.fragment= "hey"
263	- ,.request_path= "/post_identity_body_world"
264	- ,.request_url= "/post_identity_body_world?q=search#hey"
265	- ,.num_headers= 3
266	- ,.headers=
267	- { { "Accept", "/" }
268	- , { "Transfer-Encoding", "identity" }
269	- , { "Content-Length", "5" }
270	- }
271	- ,.body= "World"
272	- }
273	-
274	-#define POST_CHUNKED_ALL_YOUR_BASE 8
275	-, {.name= "post - chunked body: all your base are belong to us"
276	- ,.type= HTTP_REQUEST
277	- ,.raw= "POST /post_chunked_all_your_base HTTP/1.1\r\n"
278	- "Transfer-Encoding: chunked\r\n"
279	- "\r\n"
280	- "1e\r\nall your base are belong to us\r\n"
281	- "0\r\n"
282	- "\r\n"
283	- ,.should_keep_alive= TRUE
284	- ,.message_complete_on_eof= FALSE
285	- ,.http_major= 1
286	- ,.http_minor= 1
287	- ,.method= HTTP_POST
288	- ,.query_string= ""
289	- ,.fragment= ""
290	- ,.request_path= "/post_chunked_all_your_base"
291	- ,.request_url= "/post_chunked_all_your_base"
292	- ,.num_headers= 1
293	- ,.headers=
294	- { { "Transfer-Encoding" , "chunked" }
295	- }
296	- ,.body= "all your base are belong to us"
297	- }
298	-
299	-#define TWO_CHUNKS_MULT_ZERO_END 9
300	-, {.name= "two chunks ; triple zero ending"
301	- ,.type= HTTP_REQUEST
302	- ,.raw= "POST /two_chunks_mult_zero_end HTTP/1.1\r\n"
303	- "Transfer-Encoding: chunked\r\n"
304	- "\r\n"
305	- "5\r\nhello\r\n"
306	- "6\r\n world\r\n"
307	- "000\r\n"
308	- "\r\n"
309	- ,.should_keep_alive= TRUE
310	- ,.message_complete_on_eof= FALSE
311	- ,.http_major= 1
312	- ,.http_minor= 1
313	- ,.method= HTTP_POST
314	- ,.query_string= ""
315	- ,.fragment= ""
316	- ,.request_path= "/two_chunks_mult_zero_end"
317	- ,.request_url= "/two_chunks_mult_zero_end"
318	- ,.num_headers= 1
319	- ,.headers=
320	- { { "Transfer-Encoding", "chunked" }
321	- }
322	- ,.body= "hello world"
323	- }
324	-
325	-#define CHUNKED_W_TRAILING_HEADERS 10
326	-, {.name= "chunked with trailing headers. blech."
327	- ,.type= HTTP_REQUEST
328	- ,.raw= "POST /chunked_w_trailing_headers HTTP/1.1\r\n"
329	- "Transfer-Encoding: chunked\r\n"
330	- "\r\n"
331	- "5\r\nhello\r\n"
332	- "6\r\n world\r\n"
333	- "0\r\n"
334	- "Vary: *\r\n"
335	- "Content-Type: text/plain\r\n"
336	- "\r\n"
337	- ,.should_keep_alive= TRUE
338	- ,.message_complete_on_eof= FALSE
339	- ,.http_major= 1
340	- ,.http_minor= 1
341	- ,.method= HTTP_POST
342	- ,.query_string= ""
343	- ,.fragment= ""
344	- ,.request_path= "/chunked_w_trailing_headers"
345	- ,.request_url= "/chunked_w_trailing_headers"
346	- ,.num_headers= 3
347	- ,.headers=
348	- { { "Transfer-Encoding", "chunked" }
349	- , { "Vary", "*" }
350	- , { "Content-Type", "text/plain" }
351	- }
352	- ,.body= "hello world"
353	- }
354	-
355	-#define CHUNKED_W_BULLSHIT_AFTER_LENGTH 11
356	-, {.name= "with bullshit after the length"
357	- ,.type= HTTP_REQUEST
358	- ,.raw= "POST /chunked_w_bullshit_after_length HTTP/1.1\r\n"
359	- "Transfer-Encoding: chunked\r\n"
360	- "\r\n"
361	- "5; ihatew3;whatthefuck=aretheseparametersfor\r\nhello\r\n"
362	- "6; blahblah; blah\r\n world\r\n"
363	- "0\r\n"
364	- "\r\n"
365	- ,.should_keep_alive= TRUE
366	- ,.message_complete_on_eof= FALSE
367	- ,.http_major= 1
368	- ,.http_minor= 1
369	- ,.method= HTTP_POST
370	- ,.query_string= ""
371	- ,.fragment= ""
372	- ,.request_path= "/chunked_w_bullshit_after_length"
373	- ,.request_url= "/chunked_w_bullshit_after_length"
374	- ,.num_headers= 1
375	- ,.headers=
376	- { { "Transfer-Encoding", "chunked" }
377	- }
378	- ,.body= "hello world"
379	- }
380	-
381	-#define WITH_QUOTES 12
382	-, {.name= "with quotes"
383	- ,.type= HTTP_REQUEST
384	- ,.raw= "GET /with_\"stupid\"_quotes?foo=\"bar\" HTTP/1.1\r\n\r\n"
385	- ,.should_keep_alive= TRUE
386	- ,.message_complete_on_eof= FALSE
387	- ,.http_major= 1
388	- ,.http_minor= 1
389	- ,.method= HTTP_GET
390	- ,.query_string= "foo=\"bar\""
391	- ,.fragment= ""
392	- ,.request_path= "/with_\"stupid\"_quotes"
393	- ,.request_url= "/with_\"stupid\"_quotes?foo=\"bar\""
394	- ,.num_headers= 0
395	- ,.headers= { }
396	- ,.body= ""
397	- }
398	-
399	-#define APACHEBENCH_GET 13
400	-/* The server receiving this request SHOULD NOT wait for EOF
401	- * to know that content-length == 0.
402	- * How to represent this in a unit test? message_complete_on_eof
403	- * Compare with NO_CONTENT_LENGTH_RESPONSE.
404	- */
405	-, {.name = "apachebench get"
406	- ,.type= HTTP_REQUEST
407	- ,.raw= "GET /test HTTP/1.0\r\n"
408	- "Host: 0.0.0.0:5000\r\n"
409	- "User-Agent: ApacheBench/2.3\r\n"
410	- "Accept: /\r\n\r\n"
411	- ,.should_keep_alive= FALSE
412	- ,.message_complete_on_eof= FALSE
413	- ,.http_major= 1
414	- ,.http_minor= 0
415	- ,.method= HTTP_GET
416	- ,.query_string= ""
417	- ,.fragment= ""
418	- ,.request_path= "/test"
419	- ,.request_url= "/test"
420	- ,.num_headers= 3
421	- ,.headers= { { "Host", "0.0.0.0:5000" }
422	- , { "User-Agent", "ApacheBench/2.3" }
423	- , { "Accept", "/" }
424	- }
425	- ,.body= ""
426	- }
427	-
428	-#define QUERY_URL_WITH_QUESTION_MARK_GET 14
429	-/* Some clients include '?' characters in query strings.
430	- */
431	-, {.name = "query url with question mark"
432	- ,.type= HTTP_REQUEST
433	- ,.raw= "GET /test.cgi?foo=bar?baz HTTP/1.1\r\n\r\n"
434	- ,.should_keep_alive= TRUE
435	- ,.message_complete_on_eof= FALSE
436	- ,.http_major= 1
437	- ,.http_minor= 1
438	- ,.method= HTTP_GET
439	- ,.query_string= "foo=bar?baz"
440	- ,.fragment= ""
441	- ,.request_path= "/test.cgi"
442	- ,.request_url= "/test.cgi?foo=bar?baz"
443	- ,.num_headers= 0
444	- ,.headers= {}
445	- ,.body= ""
446	- }
447	-
448	-#define PREFIX_NEWLINE_GET 15
449	-/* Some clients, especially after a POST in a keep-alive connection,
450	- * will send an extra CRLF before the next request
451	- */
452	-, {.name = "newline prefix get"
453	- ,.type= HTTP_REQUEST
454	- ,.raw= "\r\nGET /test HTTP/1.1\r\n\r\n"
455	- ,.should_keep_alive= TRUE
456	- ,.message_complete_on_eof= FALSE
457	- ,.http_major= 1
458	- ,.http_minor= 1
459	- ,.method= HTTP_GET
460	- ,.query_string= ""
461	- ,.fragment= ""
462	- ,.request_path= "/test"
463	- ,.request_url= "/test"
464	- ,.num_headers= 0
465	- ,.headers= { }
466	- ,.body= ""
467	- }
468	-
469	-#define UPGRADE_REQUEST 16
470	-, {.name = "upgrade request"
471	- ,.type= HTTP_REQUEST
472	- ,.raw= "GET /demo HTTP/1.1\r\n"
473	- "Host: example.com\r\n"
474	- "Connection: Upgrade\r\n"
475	- "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\n"
476	- "Sec-WebSocket-Protocol: sample\r\n"
477	- "Upgrade: WebSocket\r\n"
478	- "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\n"
479	- "Origin: http://example.com\r\n"
480	- "\r\n"
481	- "Hot diggity dogg"
482	- ,.should_keep_alive= TRUE
483	- ,.message_complete_on_eof= FALSE
484	- ,.http_major= 1
485	- ,.http_minor= 1
486	- ,.method= HTTP_GET
487	- ,.query_string= ""
488	- ,.fragment= ""
489	- ,.request_path= "/demo"
490	- ,.request_url= "/demo"
491	- ,.num_headers= 7
492	- ,.upgrade="Hot diggity dogg"
493	- ,.headers= { { "Host", "example.com" }
494	- , { "Connection", "Upgrade" }
495	- , { "Sec-WebSocket-Key2", "12998 5 Y3 1 .P00" }
496	- , { "Sec-WebSocket-Protocol", "sample" }
497	- , { "Upgrade", "WebSocket" }
498	- , { "Sec-WebSocket-Key1", "4 @1 46546xW%0l 1 5" }
499	- , { "Origin", "http://example.com" }
500	- }
501	- ,.body= ""
502	- }
503	-
504	-#define CONNECT_REQUEST 17
505	-, {.name = "connect request"
506	- ,.type= HTTP_REQUEST
507	- ,.raw= "CONNECT 0-home0.netscape.com:443 HTTP/1.0\r\n"
508	- "User-agent: Mozilla/1.1N\r\n"
509	- "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
510	- "\r\n"
511	- "some data\r\n"
512	- "and yet even more data"
513	- ,.should_keep_alive= FALSE
514	- ,.message_complete_on_eof= FALSE
515	- ,.http_major= 1
516	- ,.http_minor= 0
517	- ,.method= HTTP_CONNECT
518	- ,.query_string= ""
519	- ,.fragment= ""
520	- ,.request_path= ""
521	- ,.request_url= "0-home0.netscape.com:443"
522	- ,.num_headers= 2
523	- ,.upgrade="some data\r\nand yet even more data"
524	- ,.headers= { { "User-agent", "Mozilla/1.1N" }
525	- , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
526	- }
527	- ,.body= ""
528	- }
529	-
530	-#define REPORT_REQ 18
531	-, {.name= "report request"
532	- ,.type= HTTP_REQUEST
533	- ,.raw= "REPORT /test HTTP/1.1\r\n"
534	- "\r\n"
535	- ,.should_keep_alive= TRUE
536	- ,.message_complete_on_eof= FALSE
537	- ,.http_major= 1
538	- ,.http_minor= 1
539	- ,.method= HTTP_REPORT
540	- ,.query_string= ""
541	- ,.fragment= ""
542	- ,.request_path= "/test"
543	- ,.request_url= "/test"
544	- ,.num_headers= 0
545	- ,.headers= {}
546	- ,.body= ""
547	- }
548	-
549	-#define NO_HTTP_VERSION 19
550	-, {.name= "request with no http version"
551	- ,.type= HTTP_REQUEST
552	- ,.raw= "GET /\r\n"
553	- "\r\n"
554	- ,.should_keep_alive= FALSE
555	- ,.message_complete_on_eof= FALSE
556	- ,.http_major= 0
557	- ,.http_minor= 9
558	- ,.method= HTTP_GET
559	- ,.query_string= ""
560	- ,.fragment= ""
561	- ,.request_path= "/"
562	- ,.request_url= "/"
563	- ,.num_headers= 0
564	- ,.headers= {}
565	- ,.body= ""
566	- }
567	-
568	-#define MSEARCH_REQ 20
569	-, {.name= "m-search request"
570	- ,.type= HTTP_REQUEST
571	- ,.raw= "M-SEARCH * HTTP/1.1\r\n"
572	- "HOST: 239.255.255.250:1900\r\n"
573	- "MAN: \"ssdp:discover\"\r\n"
574	- "ST: \"ssdp:all\"\r\n"
575	- "\r\n"
576	- ,.should_keep_alive= TRUE
577	- ,.message_complete_on_eof= FALSE
578	- ,.http_major= 1
579	- ,.http_minor= 1
580	- ,.method= HTTP_MSEARCH
581	- ,.query_string= ""
582	- ,.fragment= ""
583	- ,.request_path= "*"
584	- ,.request_url= "*"
585	- ,.num_headers= 3
586	- ,.headers= { { "HOST", "239.255.255.250:1900" }
587	- , { "MAN", "\"ssdp:discover\"" }
588	- , { "ST", "\"ssdp:all\"" }
589	- }
590	- ,.body= ""
591	- }
592	-
593	-#define LINE_FOLDING_IN_HEADER 21
594	-, {.name= "line folding in header value"
595	- ,.type= HTTP_REQUEST
596	- ,.raw= "GET / HTTP/1.1\r\n"
597	- "Line1: abc\r\n"
598	- "\tdef\r\n"
599	- " ghi\r\n"
600	- "\t\tjkl\r\n"
601	- " mno \r\n"
602	- "\t \tqrs\r\n"
603	- "Line2: \t line2\t\r\n"
604	- "\r\n"
605	- ,.should_keep_alive= TRUE
606	- ,.message_complete_on_eof= FALSE
607	- ,.http_major= 1
608	- ,.http_minor= 1
609	- ,.method= HTTP_GET
610	- ,.query_string= ""
611	- ,.fragment= ""
612	- ,.request_path= "/"
613	- ,.request_url= "/"
614	- ,.num_headers= 2
615	- ,.headers= { { "Line1", "abcdefghijklmno qrs" }
616	- , { "Line2", "line2\t" }
617	- }
618	- ,.body= ""
619	- }
620	-
621	-
622	-#define QUERY_TERMINATED_HOST 22
623	-, {.name= "host terminated by a query string"
624	- ,.type= HTTP_REQUEST
625	- ,.raw= "GET http://hypnotoad.org?hail=all HTTP/1.1\r\n"
626	- "\r\n"
627	- ,.should_keep_alive= TRUE
628	- ,.message_complete_on_eof= FALSE
629	- ,.http_major= 1
630	- ,.http_minor= 1
631	- ,.method= HTTP_GET
632	- ,.query_string= "hail=all"
633	- ,.fragment= ""
634	- ,.request_path= ""
635	- ,.request_url= "http://hypnotoad.org?hail=all"
636	- ,.host= "hypnotoad.org"
637	- ,.num_headers= 0
638	- ,.headers= { }
639	- ,.body= ""
640	- }
641	-
642	-#define QUERY_TERMINATED_HOSTPORT 23
643	-, {.name= "host:port terminated by a query string"
644	- ,.type= HTTP_REQUEST
645	- ,.raw= "GET http://hypnotoad.org:1234?hail=all HTTP/1.1\r\n"
646	- "\r\n"
647	- ,.should_keep_alive= TRUE
648	- ,.message_complete_on_eof= FALSE
649	- ,.http_major= 1
650	- ,.http_minor= 1
651	- ,.method= HTTP_GET
652	- ,.query_string= "hail=all"
653	- ,.fragment= ""
654	- ,.request_path= ""
655	- ,.request_url= "http://hypnotoad.org:1234?hail=all"
656	- ,.host= "hypnotoad.org"
657	- ,.port= 1234
658	- ,.num_headers= 0
659	- ,.headers= { }
660	- ,.body= ""
661	- }
662	-
663	-#define SPACE_TERMINATED_HOSTPORT 24
664	-, {.name= "host:port terminated by a space"
665	- ,.type= HTTP_REQUEST
666	- ,.raw= "GET http://hypnotoad.org:1234 HTTP/1.1\r\n"
667	- "\r\n"
668	- ,.should_keep_alive= TRUE
669	- ,.message_complete_on_eof= FALSE
670	- ,.http_major= 1
671	- ,.http_minor= 1
672	- ,.method= HTTP_GET
673	- ,.query_string= ""
674	- ,.fragment= ""
675	- ,.request_path= ""
676	- ,.request_url= "http://hypnotoad.org:1234"
677	- ,.host= "hypnotoad.org"
678	- ,.port= 1234
679	- ,.num_headers= 0
680	- ,.headers= { }
681	- ,.body= ""
682	- }
683	-
684	-#define PATCH_REQ 25
685	-, {.name = "PATCH request"
686	- ,.type= HTTP_REQUEST
687	- ,.raw= "PATCH /file.txt HTTP/1.1\r\n"
688	- "Host: www.example.com\r\n"
689	- "Content-Type: application/example\r\n"
690	- "If-Match: \"e0023aa4e\"\r\n"
691	- "Content-Length: 10\r\n"
692	- "\r\n"
693	- "cccccccccc"
694	- ,.should_keep_alive= TRUE
695	- ,.message_complete_on_eof= FALSE
696	- ,.http_major= 1
697	- ,.http_minor= 1
698	- ,.method= HTTP_PATCH
699	- ,.query_string= ""
700	- ,.fragment= ""
701	- ,.request_path= "/file.txt"
702	- ,.request_url= "/file.txt"
703	- ,.num_headers= 4
704	- ,.headers= { { "Host", "www.example.com" }
705	- , { "Content-Type", "application/example" }
706	- , { "If-Match", "\"e0023aa4e\"" }
707	- , { "Content-Length", "10" }
708	- }
709	- ,.body= "cccccccccc"
710	- }
711	-
712	-#define CONNECT_CAPS_REQUEST 26
713	-, {.name = "connect caps request"
714	- ,.type= HTTP_REQUEST
715	- ,.raw= "CONNECT HOME0.NETSCAPE.COM:443 HTTP/1.0\r\n"
716	- "User-agent: Mozilla/1.1N\r\n"
717	- "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
718	- "\r\n"
719	- ,.should_keep_alive= FALSE
720	- ,.message_complete_on_eof= FALSE
721	- ,.http_major= 1
722	- ,.http_minor= 0
723	- ,.method= HTTP_CONNECT
724	- ,.query_string= ""
725	- ,.fragment= ""
726	- ,.request_path= ""
727	- ,.request_url= "HOME0.NETSCAPE.COM:443"
728	- ,.num_headers= 2
729	- ,.upgrade=""
730	- ,.headers= { { "User-agent", "Mozilla/1.1N" }
731	- , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
732	- }
733	- ,.body= ""
734	- }
735	-
736	-#if !HTTP_PARSER_STRICT
737	-#define UTF8_PATH_REQ 27
738	-, {.name= "utf-8 path request"
739	- ,.type= HTTP_REQUEST
740	- ,.raw= "GET /δ¶/δt/pope?q=1#narf HTTP/1.1\r\n"
741	- "Host: github.com\r\n"
742	- "\r\n"
743	- ,.should_keep_alive= TRUE
744	- ,.message_complete_on_eof= FALSE
745	- ,.http_major= 1
746	- ,.http_minor= 1
747	- ,.method= HTTP_GET
748	- ,.query_string= "q=1"
749	- ,.fragment= "narf"
750	- ,.request_path= "/δ¶/δt/pope"
751	- ,.request_url= "/δ¶/δt/pope?q=1#narf"
752	- ,.num_headers= 1
753	- ,.headers= { {"Host", "github.com" }
754	- }
755	- ,.body= ""
756	- }
757	-
758	-#define HOSTNAME_UNDERSCORE 28
759	-, {.name = "hostname underscore"
760	- ,.type= HTTP_REQUEST
761	- ,.raw= "CONNECT home_0.netscape.com:443 HTTP/1.0\r\n"
762	- "User-agent: Mozilla/1.1N\r\n"
763	- "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
764	- "\r\n"
765	- ,.should_keep_alive= FALSE
766	- ,.message_complete_on_eof= FALSE
767	- ,.http_major= 1
768	- ,.http_minor= 0
769	- ,.method= HTTP_CONNECT
770	- ,.query_string= ""
771	- ,.fragment= ""
772	- ,.request_path= ""
773	- ,.request_url= "home_0.netscape.com:443"
774	- ,.num_headers= 2
775	- ,.upgrade=""
776	- ,.headers= { { "User-agent", "Mozilla/1.1N" }
777	- , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
778	- }
779	- ,.body= ""
780	- }
781	-#endif /* !HTTP_PARSER_STRICT */
782	-
783	-/* see https://github.com/ry/http-parser/issues/47 */
784	-#define EAT_TRAILING_CRLF_NO_CONNECTION_CLOSE 29
785	-, {.name = "eat CRLF between requests, no \"Connection: close\" header"
786	- ,.raw= "POST / HTTP/1.1\r\n"
787	- "Host: www.example.com\r\n"
788	- "Content-Type: application/x-www-form-urlencoded\r\n"
789	- "Content-Length: 4\r\n"
790	- "\r\n"
791	- "q=42\r\n" /* note the trailing CRLF */
792	- ,.should_keep_alive= TRUE
793	- ,.message_complete_on_eof= FALSE
794	- ,.http_major= 1
795	- ,.http_minor= 1
796	- ,.method= HTTP_POST
797	- ,.query_string= ""
798	- ,.fragment= ""
799	- ,.request_path= "/"
800	- ,.request_url= "/"
801	- ,.num_headers= 3
802	- ,.upgrade= 0
803	- ,.headers= { { "Host", "www.example.com" }
804	- , { "Content-Type", "application/x-www-form-urlencoded" }
805	- , { "Content-Length", "4" }
806	- }
807	- ,.body= "q=42"
808	- }
809	-
810	-/* see https://github.com/ry/http-parser/issues/47 */
811	-#define EAT_TRAILING_CRLF_WITH_CONNECTION_CLOSE 30
812	-, {.name = "eat CRLF between requests even if \"Connection: close\" is set"
813	- ,.raw= "POST / HTTP/1.1\r\n"
814	- "Host: www.example.com\r\n"
815	- "Content-Type: application/x-www-form-urlencoded\r\n"
816	- "Content-Length: 4\r\n"
817	- "Connection: close\r\n"
818	- "\r\n"
819	- "q=42\r\n" /* note the trailing CRLF */
820	- ,.should_keep_alive= FALSE
821	- ,.message_complete_on_eof= FALSE /* input buffer isn't empty when on_message_complete is called */
822	- ,.http_major= 1
823	- ,.http_minor= 1
824	- ,.method= HTTP_POST
825	- ,.query_string= ""
826	- ,.fragment= ""
827	- ,.request_path= "/"
828	- ,.request_url= "/"
829	- ,.num_headers= 4
830	- ,.upgrade= 0
831	- ,.headers= { { "Host", "www.example.com" }
832	- , { "Content-Type", "application/x-www-form-urlencoded" }
833	- , { "Content-Length", "4" }
834	- , { "Connection", "close" }
835	- }
836	- ,.body= "q=42"
837	- }
838	-
839	-#define PURGE_REQ 31
840	-, {.name = "PURGE request"
841	- ,.type= HTTP_REQUEST
842	- ,.raw= "PURGE /file.txt HTTP/1.1\r\n"
843	- "Host: www.example.com\r\n"
844	- "\r\n"
845	- ,.should_keep_alive= TRUE
846	- ,.message_complete_on_eof= FALSE
847	- ,.http_major= 1
848	- ,.http_minor= 1
849	- ,.method= HTTP_PURGE
850	- ,.query_string= ""
851	- ,.fragment= ""
852	- ,.request_path= "/file.txt"
853	- ,.request_url= "/file.txt"
854	- ,.num_headers= 1
855	- ,.headers= { { "Host", "www.example.com" } }
856	- ,.body= ""
857	- }
858	-
859	-#define SEARCH_REQ 32
860	-, {.name = "SEARCH request"
861	- ,.type= HTTP_REQUEST
862	- ,.raw= "SEARCH / HTTP/1.1\r\n"
863	- "Host: www.example.com\r\n"
864	- "\r\n"
865	- ,.should_keep_alive= TRUE
866	- ,.message_complete_on_eof= FALSE
867	- ,.http_major= 1
868	- ,.http_minor= 1
869	- ,.method= HTTP_SEARCH
870	- ,.query_string= ""
871	- ,.fragment= ""
872	- ,.request_path= "/"
873	- ,.request_url= "/"
874	- ,.num_headers= 1
875	- ,.headers= { { "Host", "www.example.com" } }
876	- ,.body= ""
877	- }
878	-
879	-#define PROXY_WITH_BASIC_AUTH 33
880	-, {.name= "host:port and basic_auth"
881	- ,.type= HTTP_REQUEST
882	- ,.raw= "GET http://a%12:b!&*$@hypnotoad.org:1234/toto HTTP/1.1\r\n"
883	- "\r\n"
884	- ,.should_keep_alive= TRUE
885	- ,.message_complete_on_eof= FALSE
886	- ,.http_major= 1
887	- ,.http_minor= 1
888	- ,.method= HTTP_GET
889	- ,.fragment= ""
890	- ,.request_path= "/toto"
891	- ,.request_url= "http://a%12:b!&*$@hypnotoad.org:1234/toto"
892	- ,.host= "hypnotoad.org"
893	- ,.userinfo= "a%12:b!&*$"
894	- ,.port= 1234
895	- ,.num_headers= 0
896	- ,.headers= { }
897	- ,.body= ""
898	- }
899	-
900	-
901	-, {.name= NULL } /* sentinel */
902	-};
903	-
904	-/* * R E S P O N S E S * */
905	-const struct message responses[] =
906	-#define GOOGLE_301 0
907	-{ {.name= "google 301"
908	- ,.type= HTTP_RESPONSE
909	- ,.raw= "HTTP/1.1 301 Moved Permanently\r\n"
910	- "Location: http://www.google.com/\r\n"
911	- "Content-Type: text/html; charset=UTF-8\r\n"
912	- "Date: Sun, 26 Apr 2009 11:11:49 GMT\r\n"
913	- "Expires: Tue, 26 May 2009 11:11:49 GMT\r\n"
914	- "X-$PrototypeBI-Version: 1.6.0.3\r\n" /* $ char in header field */
915	- "Cache-Control: public, max-age=2592000\r\n"
916	- "Server: gws\r\n"
917	- "Content-Length: 219 \r\n"
918	- "\r\n"
919	- "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
920	- "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
921	- "<H1>301 Moved</H1>\n"
922	- "The document has moved\n"
923	- "<A HREF=\"http://www.google.com/\">here</A>.\r\n"
924	- "</BODY></HTML>\r\n"
925	- ,.should_keep_alive= TRUE
926	- ,.message_complete_on_eof= FALSE
927	- ,.http_major= 1
928	- ,.http_minor= 1
929	- ,.status_code= 301
930	- ,.num_headers= 8
931	- ,.headers=
932	- { { "Location", "http://www.google.com/" }
933	- , { "Content-Type", "text/html; charset=UTF-8" }
934	- , { "Date", "Sun, 26 Apr 2009 11:11:49 GMT" }
935	- , { "Expires", "Tue, 26 May 2009 11:11:49 GMT" }
936	- , { "X-$PrototypeBI-Version", "1.6.0.3" }
937	- , { "Cache-Control", "public, max-age=2592000" }
938	- , { "Server", "gws" }
939	- , { "Content-Length", "219 " }
940	- }
941	- ,.body= "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
942	- "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
943	- "<H1>301 Moved</H1>\n"
944	- "The document has moved\n"
945	- "<A HREF=\"http://www.google.com/\">here</A>.\r\n"
946	- "</BODY></HTML>\r\n"
947	- }
948	-
949	-#define NO_CONTENT_LENGTH_RESPONSE 1
950	-/* The client should wait for the server's EOF. That is, when content-length
951	- * is not specified, and "Connection: close", the end of body is specified
952	- * by the EOF.
953	- * Compare with APACHEBENCH_GET
954	- */
955	-, {.name= "no content-length response"
956	- ,.type= HTTP_RESPONSE
957	- ,.raw= "HTTP/1.1 200 OK\r\n"
958	- "Date: Tue, 04 Aug 2009 07:59:32 GMT\r\n"
959	- "Server: Apache\r\n"
960	- "X-Powered-By: Servlet/2.5 JSP/2.1\r\n"
961	- "Content-Type: text/xml; charset=utf-8\r\n"
962	- "Connection: close\r\n"
963	- "\r\n"
964	- "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
965	- "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
966	- " <SOAP-ENV:Body>\n"
967	- " <SOAP-ENV:Fault>\n"
968	- " <faultcode>SOAP-ENV:Client</faultcode>\n"
969	- " <faultstring>Client Error</faultstring>\n"
970	- " </SOAP-ENV:Fault>\n"
971	- " </SOAP-ENV:Body>\n"
972	- "</SOAP-ENV:Envelope>"
973	- ,.should_keep_alive= FALSE
974	- ,.message_complete_on_eof= TRUE
975	- ,.http_major= 1
976	- ,.http_minor= 1
977	- ,.status_code= 200
978	- ,.num_headers= 5
979	- ,.headers=
980	- { { "Date", "Tue, 04 Aug 2009 07:59:32 GMT" }
981	- , { "Server", "Apache" }
982	- , { "X-Powered-By", "Servlet/2.5 JSP/2.1" }
983	- , { "Content-Type", "text/xml; charset=utf-8" }
984	- , { "Connection", "close" }
985	- }
986	- ,.body= "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
987	- "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
988	- " <SOAP-ENV:Body>\n"
989	- " <SOAP-ENV:Fault>\n"
990	- " <faultcode>SOAP-ENV:Client</faultcode>\n"
991	- " <faultstring>Client Error</faultstring>\n"
992	- " </SOAP-ENV:Fault>\n"
993	- " </SOAP-ENV:Body>\n"
994	- "</SOAP-ENV:Envelope>"
995	- }
996	-
997	-#define NO_HEADERS_NO_BODY_404 2
998	-, {.name= "404 no headers no body"
999	- ,.type= HTTP_RESPONSE
1000	- ,.raw= "HTTP/1.1 404 Not Found\r\n\r\n"
1001	- ,.should_keep_alive= FALSE
1002	- ,.message_complete_on_eof= TRUE
1003	- ,.http_major= 1
1004	- ,.http_minor= 1
1005	- ,.status_code= 404
1006	- ,.num_headers= 0
1007	- ,.headers= {}
1008	- ,.body_size= 0
1009	- ,.body= ""
1010	- }
1011	-
1012	-#define NO_REASON_PHRASE 3
1013	-, {.name= "301 no response phrase"
1014	- ,.type= HTTP_RESPONSE
1015	- ,.raw= "HTTP/1.1 301\r\n\r\n"
1016	- ,.should_keep_alive = FALSE
1017	- ,.message_complete_on_eof= TRUE
1018	- ,.http_major= 1
1019	- ,.http_minor= 1
1020	- ,.status_code= 301
1021	- ,.num_headers= 0
1022	- ,.headers= {}
1023	- ,.body= ""
1024	- }
1025	-
1026	-#define TRAILING_SPACE_ON_CHUNKED_BODY 4
1027	-, {.name="200 trailing space on chunked body"
1028	- ,.type= HTTP_RESPONSE
1029	- ,.raw= "HTTP/1.1 200 OK\r\n"
1030	- "Content-Type: text/plain\r\n"
1031	- "Transfer-Encoding: chunked\r\n"
1032	- "\r\n"
1033	- "25 \r\n"
1034	- "This is the data in the first chunk\r\n"
1035	- "\r\n"
1036	- "1C\r\n"
1037	- "and this is the second one\r\n"
1038	- "\r\n"
1039	- "0 \r\n"
1040	- "\r\n"
1041	- ,.should_keep_alive= TRUE
1042	- ,.message_complete_on_eof= FALSE
1043	- ,.http_major= 1
1044	- ,.http_minor= 1
1045	- ,.status_code= 200
1046	- ,.num_headers= 2
1047	- ,.headers=
1048	- { {"Content-Type", "text/plain" }
1049	- , {"Transfer-Encoding", "chunked" }
1050	- }
1051	- ,.body_size = 37+28
1052	- ,.body =
1053	- "This is the data in the first chunk\r\n"
1054	- "and this is the second one\r\n"
1055	-
1056	- }
1057	-
1058	-#define NO_CARRIAGE_RET 5
1059	-, {.name="no carriage ret"
1060	- ,.type= HTTP_RESPONSE
1061	- ,.raw= "HTTP/1.1 200 OK\n"
1062	- "Content-Type: text/html; charset=utf-8\n"
1063	- "Connection: close\n"
1064	- "\n"
1065	- "these headers are from http://news.ycombinator.com/"
1066	- ,.should_keep_alive= FALSE
1067	- ,.message_complete_on_eof= TRUE
1068	- ,.http_major= 1
1069	- ,.http_minor= 1
1070	- ,.status_code= 200
1071	- ,.num_headers= 2
1072	- ,.headers=
1073	- { {"Content-Type", "text/html; charset=utf-8" }
1074	- , {"Connection", "close" }
1075	- }
1076	- ,.body= "these headers are from http://news.ycombinator.com/"
1077	- }
1078	-
1079	-#define PROXY_CONNECTION 6
1080	-, {.name="proxy connection"
1081	- ,.type= HTTP_RESPONSE
1082	- ,.raw= "HTTP/1.1 200 OK\r\n"
1083	- "Content-Type: text/html; charset=UTF-8\r\n"
1084	- "Content-Length: 11\r\n"
1085	- "Proxy-Connection: close\r\n"
1086	- "Date: Thu, 31 Dec 2009 20:55:48 +0000\r\n"
1087	- "\r\n"
1088	- "hello world"
1089	- ,.should_keep_alive= FALSE
1090	- ,.message_complete_on_eof= FALSE
1091	- ,.http_major= 1
1092	- ,.http_minor= 1
1093	- ,.status_code= 200
1094	- ,.num_headers= 4
1095	- ,.headers=
1096	- { {"Content-Type", "text/html; charset=UTF-8" }
1097	- , {"Content-Length", "11" }
1098	- , {"Proxy-Connection", "close" }
1099	- , {"Date", "Thu, 31 Dec 2009 20:55:48 +0000"}
1100	- }
1101	- ,.body= "hello world"
1102	- }
1103	-
1104	-#define UNDERSTORE_HEADER_KEY 7
1105	- // shown by
1106	- // curl -o /dev/null -v "http://ad.doubleclick.net/pfadx/DARTSHELLCONFIGXML;dcmt=text/xml;"
1107	-, {.name="underscore header key"
1108	- ,.type= HTTP_RESPONSE
1109	- ,.raw= "HTTP/1.1 200 OK\r\n"
1110	- "Server: DCLK-AdSvr\r\n"
1111	- "Content-Type: text/xml\r\n"
1112	- "Content-Length: 0\r\n"
1113	- "DCLK_imp: v7;x;114750856;0-0;0;17820020;0/0;21603567/21621457/1;;~okv=;dcmt=text/xml;;~cs=o\r\n\r\n"
1114	- ,.should_keep_alive= TRUE
1115	- ,.message_complete_on_eof= FALSE
1116	- ,.http_major= 1
1117	- ,.http_minor= 1
1118	- ,.status_code= 200
1119	- ,.num_headers= 4
1120	- ,.headers=
1121	- { {"Server", "DCLK-AdSvr" }
1122	- , {"Content-Type", "text/xml" }
1123	- , {"Content-Length", "0" }
1124	- , {"DCLK_imp", "v7;x;114750856;0-0;0;17820020;0/0;21603567/21621457/1;;~okv=;dcmt=text/xml;;~cs=o" }
1125	- }
1126	- ,.body= ""
1127	- }
1128	-
1129	-#define BONJOUR_MADAME_FR 8
1130	-/* The client should not merge two headers fields when the first one doesn't
1131	- * have a value.
1132	- */
1133	-, {.name= "bonjourmadame.fr"
1134	- ,.type= HTTP_RESPONSE
1135	- ,.raw= "HTTP/1.0 301 Moved Permanently\r\n"
1136	- "Date: Thu, 03 Jun 2010 09:56:32 GMT\r\n"
1137	- "Server: Apache/2.2.3 (Red Hat)\r\n"
1138	- "Cache-Control: public\r\n"
1139	- "Pragma: \r\n"
1140	- "Location: http://www.bonjourmadame.fr/\r\n"
1141	- "Vary: Accept-Encoding\r\n"
1142	- "Content-Length: 0\r\n"
1143	- "Content-Type: text/html; charset=UTF-8\r\n"
1144	- "Connection: keep-alive\r\n"
1145	- "\r\n"
1146	- ,.should_keep_alive= TRUE
1147	- ,.message_complete_on_eof= FALSE
1148	- ,.http_major= 1
1149	- ,.http_minor= 0
1150	- ,.status_code= 301
1151	- ,.num_headers= 9
1152	- ,.headers=
1153	- { { "Date", "Thu, 03 Jun 2010 09:56:32 GMT" }
1154	- , { "Server", "Apache/2.2.3 (Red Hat)" }
1155	- , { "Cache-Control", "public" }
1156	- , { "Pragma", "" }
1157	- , { "Location", "http://www.bonjourmadame.fr/" }
1158	- , { "Vary", "Accept-Encoding" }
1159	- , { "Content-Length", "0" }
1160	- , { "Content-Type", "text/html; charset=UTF-8" }
1161	- , { "Connection", "keep-alive" }
1162	- }
1163	- ,.body= ""
1164	- }
1165	-
1166	-#define RES_FIELD_UNDERSCORE 9
1167	-/* Should handle spaces in header fields */
1168	-, {.name= "field underscore"
1169	- ,.type= HTTP_RESPONSE
1170	- ,.raw= "HTTP/1.1 200 OK\r\n"
1171	- "Date: Tue, 28 Sep 2010 01:14:13 GMT\r\n"
1172	- "Server: Apache\r\n"
1173	- "Cache-Control: no-cache, must-revalidate\r\n"
1174	- "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
1175	- ".et-Cookie: PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com\r\n"
1176	- "Vary: Accept-Encoding\r\n"
1177	- "_eep-Alive: timeout=45\r\n" /* semantic value ignored */
1178	- "_onnection: Keep-Alive\r\n" /* semantic value ignored */
1179	- "Transfer-Encoding: chunked\r\n"
1180	- "Content-Type: text/html\r\n"
1181	- "Connection: close\r\n"
1182	- "\r\n"
1183	- "0\r\n\r\n"
1184	- ,.should_keep_alive= FALSE
1185	- ,.message_complete_on_eof= FALSE
1186	- ,.http_major= 1
1187	- ,.http_minor= 1
1188	- ,.status_code= 200
1189	- ,.num_headers= 11
1190	- ,.headers=
1191	- { { "Date", "Tue, 28 Sep 2010 01:14:13 GMT" }
1192	- , { "Server", "Apache" }
1193	- , { "Cache-Control", "no-cache, must-revalidate" }
1194	- , { "Expires", "Mon, 26 Jul 1997 05:00:00 GMT" }
1195	- , { ".et-Cookie", "PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com" }
1196	- , { "Vary", "Accept-Encoding" }
1197	- , { "_eep-Alive", "timeout=45" }
1198	- , { "_onnection", "Keep-Alive" }
1199	- , { "Transfer-Encoding", "chunked" }
1200	- , { "Content-Type", "text/html" }
1201	- , { "Connection", "close" }
1202	- }
1203	- ,.body= ""
1204	- }
1205	-
1206	-#define NON_ASCII_IN_STATUS_LINE 10
1207	-/* Should handle non-ASCII in status line */
1208	-, {.name= "non-ASCII in status line"
1209	- ,.type= HTTP_RESPONSE
1210	- ,.raw= "HTTP/1.1 500 Oriëntatieprobleem\r\n"
1211	- "Date: Fri, 5 Nov 2010 23:07:12 GMT+2\r\n"
1212	- "Content-Length: 0\r\n"
1213	- "Connection: close\r\n"
1214	- "\r\n"
1215	- ,.should_keep_alive= FALSE
1216	- ,.message_complete_on_eof= FALSE
1217	- ,.http_major= 1
1218	- ,.http_minor= 1
1219	- ,.status_code= 500
1220	- ,.num_headers= 3
1221	- ,.headers=
1222	- { { "Date", "Fri, 5 Nov 2010 23:07:12 GMT+2" }
1223	- , { "Content-Length", "0" }
1224	- , { "Connection", "close" }
1225	- }
1226	- ,.body= ""
1227	- }
1228	-
1229	-#define HTTP_VERSION_0_9 11
1230	-/* Should handle HTTP/0.9 */
1231	-, {.name= "http version 0.9"
1232	- ,.type= HTTP_RESPONSE
1233	- ,.raw= "HTTP/0.9 200 OK\r\n"
1234	- "\r\n"
1235	- ,.should_keep_alive= FALSE
1236	- ,.message_complete_on_eof= TRUE
1237	- ,.http_major= 0
1238	- ,.http_minor= 9
1239	- ,.status_code= 200
1240	- ,.num_headers= 0
1241	- ,.headers=
1242	- {}
1243	- ,.body= ""
1244	- }
1245	-
1246	-#define NO_CONTENT_LENGTH_NO_TRANSFER_ENCODING_RESPONSE 12
1247	-/* The client should wait for the server's EOF. That is, when neither
1248	- * content-length nor transfer-encoding is specified, the end of body
1249	- * is specified by the EOF.
1250	- */
1251	-, {.name= "neither content-length nor transfer-encoding response"
1252	- ,.type= HTTP_RESPONSE
1253	- ,.raw= "HTTP/1.1 200 OK\r\n"
1254	- "Content-Type: text/plain\r\n"
1255	- "\r\n"
1256	- "hello world"
1257	- ,.should_keep_alive= FALSE
1258	- ,.message_complete_on_eof= TRUE
1259	- ,.http_major= 1
1260	- ,.http_minor= 1
1261	- ,.status_code= 200
1262	- ,.num_headers= 1
1263	- ,.headers=
1264	- { { "Content-Type", "text/plain" }
1265	- }
1266	- ,.body= "hello world"
1267	- }
1268	-
1269	-#define NO_BODY_HTTP10_KA_200 13
1270	-, {.name= "HTTP/1.0 with keep-alive and EOF-terminated 200 status"
1271	- ,.type= HTTP_RESPONSE
1272	- ,.raw= "HTTP/1.0 200 OK\r\n"
1273	- "Connection: keep-alive\r\n"
1274	- "\r\n"
1275	- ,.should_keep_alive= FALSE
1276	- ,.message_complete_on_eof= TRUE
1277	- ,.http_major= 1
1278	- ,.http_minor= 0
1279	- ,.status_code= 200
1280	- ,.num_headers= 1
1281	- ,.headers=
1282	- { { "Connection", "keep-alive" }
1283	- }
1284	- ,.body_size= 0
1285	- ,.body= ""
1286	- }
1287	-
1288	-#define NO_BODY_HTTP10_KA_204 14
1289	-, {.name= "HTTP/1.0 with keep-alive and a 204 status"
1290	- ,.type= HTTP_RESPONSE
1291	- ,.raw= "HTTP/1.0 204 No content\r\n"
1292	- "Connection: keep-alive\r\n"
1293	- "\r\n"
1294	- ,.should_keep_alive= TRUE
1295	- ,.message_complete_on_eof= FALSE
1296	- ,.http_major= 1
1297	- ,.http_minor= 0
1298	- ,.status_code= 204
1299	- ,.num_headers= 1
1300	- ,.headers=
1301	- { { "Connection", "keep-alive" }
1302	- }
1303	- ,.body_size= 0
1304	- ,.body= ""
1305	- }
1306	-
1307	-#define NO_BODY_HTTP11_KA_200 15
1308	-, {.name= "HTTP/1.1 with an EOF-terminated 200 status"
1309	- ,.type= HTTP_RESPONSE
1310	- ,.raw= "HTTP/1.1 200 OK\r\n"
1311	- "\r\n"
1312	- ,.should_keep_alive= FALSE
1313	- ,.message_complete_on_eof= TRUE
1314	- ,.http_major= 1
1315	- ,.http_minor= 1
1316	- ,.status_code= 200
1317	- ,.num_headers= 0
1318	- ,.headers={}
1319	- ,.body_size= 0
1320	- ,.body= ""
1321	- }
1322	-
1323	-#define NO_BODY_HTTP11_KA_204 16
1324	-, {.name= "HTTP/1.1 with a 204 status"
1325	- ,.type= HTTP_RESPONSE
1326	- ,.raw= "HTTP/1.1 204 No content\r\n"
1327	- "\r\n"
1328	- ,.should_keep_alive= TRUE
1329	- ,.message_complete_on_eof= FALSE
1330	- ,.http_major= 1
1331	- ,.http_minor= 1
1332	- ,.status_code= 204
1333	- ,.num_headers= 0
1334	- ,.headers={}
1335	- ,.body_size= 0
1336	- ,.body= ""
1337	- }
1338	-
1339	-#define NO_BODY_HTTP11_NOKA_204 17
1340	-, {.name= "HTTP/1.1 with a 204 status and keep-alive disabled"
1341	- ,.type= HTTP_RESPONSE
1342	- ,.raw= "HTTP/1.1 204 No content\r\n"
1343	- "Connection: close\r\n"
1344	- "\r\n"
1345	- ,.should_keep_alive= FALSE
1346	- ,.message_complete_on_eof= FALSE
1347	- ,.http_major= 1
1348	- ,.http_minor= 1
1349	- ,.status_code= 204
1350	- ,.num_headers= 1
1351	- ,.headers=
1352	- { { "Connection", "close" }
1353	- }
1354	- ,.body_size= 0
1355	- ,.body= ""
1356	- }
1357	-
1358	-#define NO_BODY_HTTP11_KA_CHUNKED_200 18
1359	-, {.name= "HTTP/1.1 with chunked endocing and a 200 response"
1360	- ,.type= HTTP_RESPONSE
1361	- ,.raw= "HTTP/1.1 200 OK\r\n"
1362	- "Transfer-Encoding: chunked\r\n"
1363	- "\r\n"
1364	- "0\r\n"
1365	- "\r\n"
1366	- ,.should_keep_alive= TRUE
1367	- ,.message_complete_on_eof= FALSE
1368	- ,.http_major= 1
1369	- ,.http_minor= 1
1370	- ,.status_code= 200
1371	- ,.num_headers= 1
1372	- ,.headers=
1373	- { { "Transfer-Encoding", "chunked" }
1374	- }
1375	- ,.body_size= 0
1376	- ,.body= ""
1377	- }
1378	-
1379	-#if !HTTP_PARSER_STRICT
1380	-#define SPACE_IN_FIELD_RES 19
1381	-/* Should handle spaces in header fields */
1382	-, {.name= "field space"
1383	- ,.type= HTTP_RESPONSE
1384	- ,.raw= "HTTP/1.1 200 OK\r\n"
1385	- "Server: Microsoft-IIS/6.0\r\n"
1386	- "X-Powered-By: ASP.NET\r\n"
1387	- "en-US Content-Type: text/xml\r\n" /* this is the problem */
1388	- "Content-Type: text/xml\r\n"
1389	- "Content-Length: 16\r\n"
1390	- "Date: Fri, 23 Jul 2010 18:45:38 GMT\r\n"
1391	- "Connection: keep-alive\r\n"
1392	- "\r\n"
1393	- "<xml>hello</xml>" /* fake body */
1394	- ,.should_keep_alive= TRUE
1395	- ,.message_complete_on_eof= FALSE
1396	- ,.http_major= 1
1397	- ,.http_minor= 1
1398	- ,.status_code= 200
1399	- ,.num_headers= 7
1400	- ,.headers=
1401	- { { "Server", "Microsoft-IIS/6.0" }
1402	- , { "X-Powered-By", "ASP.NET" }
1403	- , { "en-US Content-Type", "text/xml" }
1404	- , { "Content-Type", "text/xml" }
1405	- , { "Content-Length", "16" }
1406	- , { "Date", "Fri, 23 Jul 2010 18:45:38 GMT" }
1407	- , { "Connection", "keep-alive" }
1408	- }
1409	- ,.body= "<xml>hello</xml>"
1410	- }
1411	-#endif /* !HTTP_PARSER_STRICT */
1412	-
1413	-, {.name= NULL } /* sentinel */
1414	-};
1415	-
1416	-/* strnlen() is a POSIX.2008 addition. Can't rely on it being available so
1417	- * define it ourselves.
1418	- */
1419	-size_t
1420	-strnlen(const char *s, size_t maxlen)
1421	-{
1422	- const char *p;
1423	-
1424	- p = memchr(s, '\0', maxlen);
1425	- if (p == NULL)
1426	- return maxlen;
1427	-
1428	- return p - s;
1429	-}
1430	-
1431	-size_t
1432	-strlncat(char dst, size_t len, const char src, size_t n)
1433	-{
1434	- size_t slen;
1435	- size_t dlen;
1436	- size_t rlen;
1437	- size_t ncpy;
1438	-
1439	- slen = strnlen(src, n);
1440	- dlen = strnlen(dst, len);
1441	-
1442	- if (dlen < len) {
1443	- rlen = len - dlen;
1444	- ncpy = slen < rlen ? slen : (rlen - 1);
1445	- memcpy(dst + dlen, src, ncpy);
1446	- dst[dlen + ncpy] = '\0';
1447	- }
1448	-
1449	- assert(len > slen + dlen);
1450	- return slen + dlen;
1451	-}
1452	-
1453	-size_t
1454	-strlcat(char dst, const char src, size_t len)
1455	-{
1456	- return strlncat(dst, len, src, (size_t) -1);
1457	-}
1458	-
1459	-size_t
1460	-strlncpy(char dst, size_t len, const char src, size_t n)
1461	-{
1462	- size_t slen;
1463	- size_t ncpy;
1464	-
1465	- slen = strnlen(src, n);
1466	-
1467	- if (len > 0) {
1468	- ncpy = slen < len ? slen : (len - 1);
1469	- memcpy(dst, src, ncpy);
1470	- dst[ncpy] = '\0';
1471	- }
1472	-
1473	- assert(len > slen);
1474	- return slen;
1475	-}
1476	-
1477	-size_t
1478	-strlcpy(char dst, const char src, size_t len)
1479	-{
1480	- return strlncpy(dst, len, src, (size_t) -1);
1481	-}
1482	-
1483	-int
1484	-request_url_cb (http_parser p, const char buf, size_t len)
1485	-{
1486	- assert(p == parser);
1487	- strlncat(messages[num_messages].request_url,
1488	- sizeof(messages[num_messages].request_url),
1489	- buf,
1490	- len);
1491	- return 0;
1492	-}
1493	-
1494	-int
1495	-status_complete_cb (http_parser *p) {
1496	- assert(p == parser);
1497	- p->data++;
1498	- return 0;
1499	-}
1500	-
1501	-int
1502	-header_field_cb (http_parser p, const char buf, size_t len)
1503	-{
1504	- assert(p == parser);
1505	- struct message *m = &messages[num_messages];
1506	-
1507	- if (m->last_header_element != FIELD)
1508	- m->num_headers++;
1509	-
1510	- strlncat(m->headers[m->num_headers-1][0],
1511	- sizeof(m->headers[m->num_headers-1][0]),
1512	- buf,
1513	- len);
1514	-
1515	- m->last_header_element = FIELD;
1516	-
1517	- return 0;
1518	-}
1519	-
1520	-int
1521	-header_value_cb (http_parser p, const char buf, size_t len)
1522	-{
1523	- assert(p == parser);
1524	- struct message *m = &messages[num_messages];
1525	-
1526	- strlncat(m->headers[m->num_headers-1][1],
1527	- sizeof(m->headers[m->num_headers-1][1]),
1528	- buf,
1529	- len);
1530	-
1531	- m->last_header_element = VALUE;
1532	-
1533	- return 0;
1534	-}
1535	-
1536	-void
1537	-check_body_is_final (const http_parser *p)
1538	-{
1539	- if (messages[num_messages].body_is_final) {
1540	- fprintf(stderr, "\n\n *** Error http_body_is_final() should return 1 "
1541	- "on last on_body callback call "
1542	- "but it doesn't! ***\n\n");
1543	- assert(0);
1544	- abort();
1545	- }
1546	- messages[num_messages].body_is_final = http_body_is_final(p);
1547	-}
1548	-
1549	-int
1550	-body_cb (http_parser p, const char buf, size_t len)
1551	-{
1552	- assert(p == parser);
1553	- strlncat(messages[num_messages].body,
1554	- sizeof(messages[num_messages].body),
1555	- buf,
1556	- len);
1557	- messages[num_messages].body_size += len;
1558	- check_body_is_final(p);
1559	- // printf("body_cb: '%s'\n", requests[num_messages].body);
1560	- return 0;
1561	-}
1562	-
1563	-int
1564	-count_body_cb (http_parser p, const char buf, size_t len)
1565	-{
1566	- assert(p == parser);
1567	- assert(buf);
1568	- messages[num_messages].body_size += len;
1569	- check_body_is_final(p);
1570	- return 0;
1571	-}
1572	-
1573	-int
1574	-message_begin_cb (http_parser *p)
1575	-{
1576	- assert(p == parser);
1577	- messages[num_messages].message_begin_cb_called = TRUE;
1578	- return 0;
1579	-}
1580	-
1581	-int
1582	-headers_complete_cb (http_parser *p)
1583	-{
1584	- assert(p == parser);
1585	- messages[num_messages].method = parser->method;
1586	- messages[num_messages].status_code = parser->status_code;
1587	- messages[num_messages].http_major = parser->http_major;
1588	- messages[num_messages].http_minor = parser->http_minor;
1589	- messages[num_messages].headers_complete_cb_called = TRUE;
1590	- messages[num_messages].should_keep_alive = http_should_keep_alive(parser);
1591	- return 0;
1592	-}
1593	-
1594	-int
1595	-message_complete_cb (http_parser *p)
1596	-{
1597	- assert(p == parser);
1598	- if (messages[num_messages].should_keep_alive != http_should_keep_alive(parser))
1599	- {
1600	- fprintf(stderr, "\n\n *** Error http_should_keep_alive() should have same "
1601	- "value in both on_message_complete and on_headers_complete "
1602	- "but it doesn't! ***\n\n");
1603	- assert(0);
1604	- abort();
1605	- }
1606	-
1607	- if (messages[num_messages].body_size &&
1608	- http_body_is_final(p) &&
1609	- !messages[num_messages].body_is_final)
1610	- {
1611	- fprintf(stderr, "\n\n *** Error http_body_is_final() should return 1 "
1612	- "on last on_body callback call "
1613	- "but it doesn't! ***\n\n");
1614	- assert(0);
1615	- abort();
1616	- }
1617	-
1618	- messages[num_messages].message_complete_cb_called = TRUE;
1619	-
1620	- messages[num_messages].message_complete_on_eof = currently_parsing_eof;
1621	-
1622	- num_messages++;
1623	- return 0;
1624	-}
1625	-
1626	-/* These dontcall_* callbacks exist so that we can verify that when we're
1627	- * paused, no additional callbacks are invoked */
1628	-int
1629	-dontcall_message_begin_cb (http_parser *p)
1630	-{
1631	- if (p) { } // gcc
1632	- fprintf(stderr, "\n\n* on_message_begin() called on paused parser *\n\n");
1633	- abort();
1634	-}
1635	-
1636	-int
1637	-dontcall_header_field_cb (http_parser p, const char buf, size_t len)
1638	-{
1639	- if (p \|\| buf \|\| len) { } // gcc
1640	- fprintf(stderr, "\n\n* on_header_field() called on paused parser *\n\n");
1641	- abort();
1642	-}
1643	-
1644	-int
1645	-dontcall_header_value_cb (http_parser p, const char buf, size_t len)
1646	-{
1647	- if (p \|\| buf \|\| len) { } // gcc
1648	- fprintf(stderr, "\n\n* on_header_value() called on paused parser *\n\n");
1649	- abort();
1650	-}
1651	-
1652	-int
1653	-dontcall_request_url_cb (http_parser p, const char buf, size_t len)
1654	-{
1655	- if (p \|\| buf \|\| len) { } // gcc
1656	- fprintf(stderr, "\n\n* on_request_url() called on paused parser *\n\n");
1657	- abort();
1658	-}
1659	-
1660	-int
1661	-dontcall_body_cb (http_parser p, const char buf, size_t len)
1662	-{
1663	- if (p \|\| buf \|\| len) { } // gcc
1664	- fprintf(stderr, "\n\n* on_body_cb() called on paused parser *\n\n");
1665	- abort();
1666	-}
1667	-
1668	-int
1669	-dontcall_headers_complete_cb (http_parser *p)
1670	-{
1671	- if (p) { } // gcc
1672	- fprintf(stderr, "\n\n*** on_headers_complete() called on paused "
1673	- "parser ***\n\n");
1674	- abort();
1675	-}
1676	-
1677	-int
1678	-dontcall_message_complete_cb (http_parser *p)
1679	-{
1680	- if (p) { } // gcc
1681	- fprintf(stderr, "\n\n*** on_message_complete() called on paused "
1682	- "parser ***\n\n");
1683	- abort();
1684	-}
1685	-
1686	-static http_parser_settings settings_dontcall =
1687	- {.on_message_begin = dontcall_message_begin_cb
1688	- ,.on_header_field = dontcall_header_field_cb
1689	- ,.on_header_value = dontcall_header_value_cb
1690	- ,.on_url = dontcall_request_url_cb
1691	- ,.on_body = dontcall_body_cb
1692	- ,.on_headers_complete = dontcall_headers_complete_cb
1693	- ,.on_message_complete = dontcall_message_complete_cb
1694	- };
1695	-
1696	-/* These pause_* callbacks always pause the parser and just invoke the regular
1697	- * callback that tracks content. Before returning, we overwrite the parser
1698	- * settings to point to the _dontcall variety so that we can verify that
1699	- * the pause actually did, you know, pause. */
1700	-int
1701	-pause_message_begin_cb (http_parser *p)
1702	-{
1703	- http_parser_pause(p, 1);
1704	- *current_pause_parser = settings_dontcall;
1705	- return message_begin_cb(p);
1706	-}
1707	-
1708	-int
1709	-pause_header_field_cb (http_parser p, const char buf, size_t len)
1710	-{
1711	- http_parser_pause(p, 1);
1712	- *current_pause_parser = settings_dontcall;
1713	- return header_field_cb(p, buf, len);
1714	-}
1715	-
1716	-int
1717	-pause_header_value_cb (http_parser p, const char buf, size_t len)
1718	-{
1719	- http_parser_pause(p, 1);
1720	- *current_pause_parser = settings_dontcall;
1721	- return header_value_cb(p, buf, len);
1722	-}
1723	-
1724	-int
1725	-pause_request_url_cb (http_parser p, const char buf, size_t len)
1726	-{
1727	- http_parser_pause(p, 1);
1728	- *current_pause_parser = settings_dontcall;
1729	- return request_url_cb(p, buf, len);
1730	-}
1731	-
1732	-int
1733	-pause_body_cb (http_parser p, const char buf, size_t len)
1734	-{
1735	- http_parser_pause(p, 1);
1736	- *current_pause_parser = settings_dontcall;
1737	- return body_cb(p, buf, len);
1738	-}
1739	-
1740	-int
1741	-pause_headers_complete_cb (http_parser *p)
1742	-{
1743	- http_parser_pause(p, 1);
1744	- *current_pause_parser = settings_dontcall;
1745	- return headers_complete_cb(p);
1746	-}
1747	-
1748	-int
1749	-pause_message_complete_cb (http_parser *p)
1750	-{
1751	- http_parser_pause(p, 1);
1752	- *current_pause_parser = settings_dontcall;
1753	- return message_complete_cb(p);
1754	-}
1755	-
1756	-static http_parser_settings settings_pause =
1757	- {.on_message_begin = pause_message_begin_cb
1758	- ,.on_header_field = pause_header_field_cb
1759	- ,.on_header_value = pause_header_value_cb
1760	- ,.on_url = pause_request_url_cb
1761	- ,.on_body = pause_body_cb
1762	- ,.on_headers_complete = pause_headers_complete_cb
1763	- ,.on_message_complete = pause_message_complete_cb
1764	- };
1765	-
1766	-static http_parser_settings settings =
1767	- {.on_message_begin = message_begin_cb
1768	- ,.on_header_field = header_field_cb
1769	- ,.on_header_value = header_value_cb
1770	- ,.on_url = request_url_cb
1771	- ,.on_body = body_cb
1772	- ,.on_headers_complete = headers_complete_cb
1773	- ,.on_message_complete = message_complete_cb
1774	- };
1775	-
1776	-static http_parser_settings settings_count_body =
1777	- {.on_message_begin = message_begin_cb
1778	- ,.on_header_field = header_field_cb
1779	- ,.on_header_value = header_value_cb
1780	- ,.on_url = request_url_cb
1781	- ,.on_body = count_body_cb
1782	- ,.on_headers_complete = headers_complete_cb
1783	- ,.on_message_complete = message_complete_cb
1784	- };
1785	-
1786	-static http_parser_settings settings_null =
1787	- {.on_message_begin = 0
1788	- ,.on_header_field = 0
1789	- ,.on_header_value = 0
1790	- ,.on_url = 0
1791	- ,.on_body = 0
1792	- ,.on_headers_complete = 0
1793	- ,.on_message_complete = 0
1794	- };
1795	-
1796	-void
1797	-parser_init (enum http_parser_type type)
1798	-{
1799	- num_messages = 0;
1800	-
1801	- assert(parser == NULL);
1802	-
1803	- parser = malloc(sizeof(http_parser));
1804	-
1805	- http_parser_init(parser, type);
1806	-
1807	- memset(&messages, 0, sizeof messages);
1808	-
1809	-}
1810	-
1811	-void
1812	-parser_free ()
1813	-{
1814	- assert(parser);
1815	- free(parser);
1816	- parser = NULL;
1817	-}
1818	-
1819	-size_t parse (const char *buf, size_t len)
1820	-{
1821	- size_t nparsed;
1822	- currently_parsing_eof = (len == 0);
1823	- nparsed = http_parser_execute(parser, &settings, buf, len);
1824	- return nparsed;
1825	-}
1826	-
1827	-size_t parse_count_body (const char *buf, size_t len)
1828	-{
1829	- size_t nparsed;
1830	- currently_parsing_eof = (len == 0);
1831	- nparsed = http_parser_execute(parser, &settings_count_body, buf, len);
1832	- return nparsed;
1833	-}
1834	-
1835	-size_t parse_pause (const char *buf, size_t len)
1836	-{
1837	- size_t nparsed;
1838	- http_parser_settings s = settings_pause;
1839	-
1840	- currently_parsing_eof = (len == 0);
1841	- current_pause_parser = &s;
1842	- nparsed = http_parser_execute(parser, current_pause_parser, buf, len);
1843	- return nparsed;
1844	-}
1845	-
1846	-static inline int
1847	-check_str_eq (const struct message *m,
1848	- const char *prop,
1849	- const char *expected,
1850	- const char *found) {
1851	- if ((expected == NULL) != (found == NULL)) {
1852	- printf("\n* Error: %s in '%s' *\n\n", prop, m->name);
1853	- printf("expected %s\n", (expected == NULL) ? "NULL" : expected);
1854	- printf(" found %s\n", (found == NULL) ? "NULL" : found);
1855	- return 0;
1856	- }
1857	- if (expected != NULL && 0 != strcmp(expected, found)) {
1858	- printf("\n* Error: %s in '%s' *\n\n", prop, m->name);
1859	- printf("expected '%s'\n", expected);
1860	- printf(" found '%s'\n", found);
1861	- return 0;
1862	- }
1863	- return 1;
1864	-}
1865	-
1866	-static inline int
1867	-check_num_eq (const struct message *m,
1868	- const char *prop,
1869	- int expected,
1870	- int found) {
1871	- if (expected != found) {
1872	- printf("\n* Error: %s in '%s' *\n\n", prop, m->name);
1873	- printf("expected %d\n", expected);
1874	- printf(" found %d\n", found);
1875	- return 0;
1876	- }
1877	- return 1;
1878	-}
1879	-
1880	-#define MESSAGE_CHECK_STR_EQ(expected, found, prop) \
1881	- if (!check_str_eq(expected, #prop, expected->prop, found->prop)) return 0
1882	-
1883	-#define MESSAGE_CHECK_NUM_EQ(expected, found, prop) \
1884	- if (!check_num_eq(expected, #prop, expected->prop, found->prop)) return 0
1885	-
1886	-#define MESSAGE_CHECK_URL_EQ(u, expected, found, prop, fn) \
1887	-do { \
1888	- char ubuf[256]; \
1889	- \
1890	- if ((u)->field_set & (1 << (fn))) { \
1891	- memcpy(ubuf, (found)->request_url + (u)->field_data[(fn)].off, \
1892	- (u)->field_data[(fn)].len); \
1893	- ubuf[(u)->field_data[(fn)].len] = '\0'; \
1894	- } else { \
1895	- ubuf[0] = '\0'; \
1896	- } \
1897	- \
1898	- check_str_eq(expected, #prop, expected->prop, ubuf); \
1899	-} while(0)
1900	-
1901	-int
1902	-message_eq (int index, const struct message *expected)
1903	-{
1904	- int i;
1905	- struct message *m = &messages[index];
1906	-
1907	- MESSAGE_CHECK_NUM_EQ(expected, m, http_major);
1908	- MESSAGE_CHECK_NUM_EQ(expected, m, http_minor);
1909	-
1910	- if (expected->type == HTTP_REQUEST) {
1911	- MESSAGE_CHECK_NUM_EQ(expected, m, method);
1912	- } else {
1913	- MESSAGE_CHECK_NUM_EQ(expected, m, status_code);
1914	- }
1915	-
1916	- MESSAGE_CHECK_NUM_EQ(expected, m, should_keep_alive);
1917	- MESSAGE_CHECK_NUM_EQ(expected, m, message_complete_on_eof);
1918	-
1919	- assert(m->message_begin_cb_called);
1920	- assert(m->headers_complete_cb_called);
1921	- assert(m->message_complete_cb_called);
1922	-
1923	-
1924	- MESSAGE_CHECK_STR_EQ(expected, m, request_url);
1925	-
1926	- /* Check URL components; we can't do this w/ CONNECT since it doesn't
1927	- * send us a well-formed URL.
1928	- */
1929	- if (*m->request_url && m->method != HTTP_CONNECT) {
1930	- struct http_parser_url u;
1931	-
1932	- if (http_parser_parse_url(m->request_url, strlen(m->request_url), 0, &u)) {
1933	- fprintf(stderr, "\n\n* failed to parse URL %s *\n\n",
1934	- m->request_url);
1935	- abort();
1936	- }
1937	-
1938	- if (expected->host) {
1939	- MESSAGE_CHECK_URL_EQ(&u, expected, m, host, UF_HOST);
1940	- }
1941	-
1942	- if (expected->userinfo) {
1943	- MESSAGE_CHECK_URL_EQ(&u, expected, m, userinfo, UF_USERINFO);
1944	- }
1945	-
1946	- m->port = (u.field_set & (1 << UF_PORT)) ?
1947	- u.port : 0;
1948	-
1949	- MESSAGE_CHECK_URL_EQ(&u, expected, m, query_string, UF_QUERY);
1950	- MESSAGE_CHECK_URL_EQ(&u, expected, m, fragment, UF_FRAGMENT);
1951	- MESSAGE_CHECK_URL_EQ(&u, expected, m, request_path, UF_PATH);
1952	- MESSAGE_CHECK_NUM_EQ(expected, m, port);
1953	- }
1954	-
1955	- if (expected->body_size) {
1956	- MESSAGE_CHECK_NUM_EQ(expected, m, body_size);
1957	- } else {
1958	- MESSAGE_CHECK_STR_EQ(expected, m, body);
1959	- }
1960	-
1961	- MESSAGE_CHECK_NUM_EQ(expected, m, num_headers);
1962	-
1963	- int r;
1964	- for (i = 0; i < m->num_headers; i++) {
1965	- r = check_str_eq(expected, "header field", expected->headers[i][0], m->headers[i][0]);
1966	- if (!r) return 0;
1967	- r = check_str_eq(expected, "header value", expected->headers[i][1], m->headers[i][1]);
1968	- if (!r) return 0;
1969	- }
1970	-
1971	- MESSAGE_CHECK_STR_EQ(expected, m, upgrade);
1972	-
1973	- return 1;
1974	-}
1975	-
1976	-/* Given a sequence of varargs messages, return the number of them that the
1977	- * parser should successfully parse, taking into account that upgraded
1978	- * messages prevent all subsequent messages from being parsed.
1979	- */
1980	-size_t
1981	-count_parsed_messages(const size_t nmsgs, ...) {
1982	- size_t i;
1983	- va_list ap;
1984	-
1985	- va_start(ap, nmsgs);
1986	-
1987	- for (i = 0; i < nmsgs; i++) {
1988	- struct message m = va_arg(ap, struct message );
1989	-
1990	- if (m->upgrade) {
1991	- va_end(ap);
1992	- return i + 1;
1993	- }
1994	- }
1995	-
1996	- va_end(ap);
1997	- return nmsgs;
1998	-}
1999	-
2000	-/* Given a sequence of bytes and the number of these that we were able to
2001	- * parse, verify that upgrade bodies are correct.
2002	- */
2003	-void
2004	-upgrade_message_fix(char *body, const size_t nread, const size_t nmsgs, ...) {
2005	- va_list ap;
2006	- size_t i;
2007	- size_t off = 0;
2008	-
2009	- va_start(ap, nmsgs);
2010	-
2011	- for (i = 0; i < nmsgs; i++) {
2012	- struct message m = va_arg(ap, struct message );
2013	-
2014	- off += strlen(m->raw);
2015	-
2016	- if (m->upgrade) {
2017	- off -= strlen(m->upgrade);
2018	-
2019	- /* Check the portion of the response after its specified upgrade */
2020	- if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
2021	- abort();
2022	- }
2023	-
2024	- /* Fix up the response so that message_eq() will verify the beginning
2025	- * of the upgrade */
2026	- *(body + nread + strlen(m->upgrade)) = '\0';
2027	- messages[num_messages -1 ].upgrade = body + nread;
2028	-
2029	- va_end(ap);
2030	- return;
2031	- }
2032	- }
2033	-
2034	- va_end(ap);
2035	- printf("\n\n* Error: expected a message with upgrade *\n");
2036	-
2037	- abort();
2038	-}
2039	-
2040	-static void
2041	-print_error (const char *raw, size_t error_location)
2042	-{
2043	- fprintf(stderr, "\n* %s *\n\n",
2044	- http_errno_description(HTTP_PARSER_ERRNO(parser)));
2045	-
2046	- int this_line = 0, char_len = 0;
2047	- size_t i, j, len = strlen(raw), error_location_line = 0;
2048	- for (i = 0; i < len; i++) {
2049	- if (i == error_location) this_line = 1;
2050	- switch (raw[i]) {
2051	- case '\r':
2052	- char_len = 2;
2053	- fprintf(stderr, "\\r");
2054	- break;
2055	-
2056	- case '\n':
2057	- char_len = 2;
2058	- fprintf(stderr, "\\n\n");
2059	-
2060	- if (this_line) goto print;
2061	-
2062	- error_location_line = 0;
2063	- continue;
2064	-
2065	- default:
2066	- char_len = 1;
2067	- fputc(raw[i], stderr);
2068	- break;
2069	- }
2070	- if (!this_line) error_location_line += char_len;
2071	- }
2072	-
2073	- fprintf(stderr, "[eof]\n");
2074	-
2075	- print:
2076	- for (j = 0; j < error_location_line; j++) {
2077	- fputc(' ', stderr);
2078	- }
2079	- fprintf(stderr, "^\n\nerror location: %u\n", (unsigned int)error_location);
2080	-}
2081	-
2082	-void
2083	-test_preserve_data (void)
2084	-{
2085	- char my_data[] = "application-specific data";
2086	- http_parser parser;
2087	- parser.data = my_data;
2088	- http_parser_init(&parser, HTTP_REQUEST);
2089	- if (parser.data != my_data) {
2090	- printf("\n* parser.data not preserved accross http_parser_init *\n\n");
2091	- abort();
2092	- }
2093	-}
2094	-
2095	-struct url_test {
2096	- const char *name;
2097	- const char *url;
2098	- int is_connect;
2099	- struct http_parser_url u;
2100	- int rv;
2101	-};
2102	-
2103	-const struct url_test url_tests[] =
2104	-{ {.name="proxy request"
2105	- ,.url="http://hostname/"
2106	- ,.is_connect=0
2107	- ,.u=
2108	- {.field_set=(1 << UF_SCHEMA) \| (1 << UF_HOST) \| (1 << UF_PATH)
2109	- ,.port=0
2110	- ,.field_data=
2111	- {{ 0, 4 } /* UF_SCHEMA */
2112	- ,{ 7, 8 } /* UF_HOST */
2113	- ,{ 0, 0 } /* UF_PORT */
2114	- ,{ 15, 1 } /* UF_PATH */
2115	- ,{ 0, 0 } /* UF_QUERY */
2116	- ,{ 0, 0 } /* UF_FRAGMENT */
2117	- ,{ 0, 0 } /* UF_USERINFO */
2118	- }
2119	- }
2120	- ,.rv=0
2121	- }
2122	-
2123	-, {.name="proxy request with port"
2124	- ,.url="http://hostname:444/"
2125	- ,.is_connect=0
2126	- ,.u=
2127	- {.field_set=(1 << UF_SCHEMA) \| (1 << UF_HOST) \| (1 << UF_PORT) \| (1 << UF_PATH)
2128	- ,.port=444
2129	- ,.field_data=
2130	- {{ 0, 4 } /* UF_SCHEMA */
2131	- ,{ 7, 8 } /* UF_HOST */
2132	- ,{ 16, 3 } /* UF_PORT */
2133	- ,{ 19, 1 } /* UF_PATH */
2134	- ,{ 0, 0 } /* UF_QUERY */
2135	- ,{ 0, 0 } /* UF_FRAGMENT */
2136	- ,{ 0, 0 } /* UF_USERINFO */
2137	- }
2138	- }
2139	- ,.rv=0
2140	- }
2141	-
2142	-, {.name="CONNECT request"
2143	- ,.url="hostname:443"
2144	- ,.is_connect=1
2145	- ,.u=
2146	- {.field_set=(1 << UF_HOST) \| (1 << UF_PORT)
2147	- ,.port=443
2148	- ,.field_data=
2149	- {{ 0, 0 } /* UF_SCHEMA */
2150	- ,{ 0, 8 } /* UF_HOST */
2151	- ,{ 9, 3 } /* UF_PORT */
2152	- ,{ 0, 0 } /* UF_PATH */
2153	- ,{ 0, 0 } /* UF_QUERY */
2154	- ,{ 0, 0 } /* UF_FRAGMENT */
2155	- ,{ 0, 0 } /* UF_USERINFO */
2156	- }
2157	- }
2158	- ,.rv=0
2159	- }
2160	-
2161	-, {.name="CONNECT request but not connect"
2162	- ,.url="hostname:443"
2163	- ,.is_connect=0
2164	- ,.rv=1
2165	- }
2166	-
2167	-, {.name="proxy ipv6 request"
2168	- ,.url="http://[1:2::3:4]/"
2169	- ,.is_connect=0
2170	- ,.u=
2171	- {.field_set=(1 << UF_SCHEMA) \| (1 << UF_HOST) \| (1 << UF_PATH)
2172	- ,.port=0
2173	- ,.field_data=
2174	- {{ 0, 4 } /* UF_SCHEMA */
2175	- ,{ 8, 8 } /* UF_HOST */
2176	- ,{ 0, 0 } /* UF_PORT */
2177	- ,{ 17, 1 } /* UF_PATH */
2178	- ,{ 0, 0 } /* UF_QUERY */
2179	- ,{ 0, 0 } /* UF_FRAGMENT */
2180	- ,{ 0, 0 } /* UF_USERINFO */
2181	- }
2182	- }
2183	- ,.rv=0
2184	- }
2185	-
2186	-, {.name="proxy ipv6 request with port"
2187	- ,.url="http://[1:2::3:4]:67/"
2188	- ,.is_connect=0
2189	- ,.u=
2190	- {.field_set=(1 << UF_SCHEMA) \| (1 << UF_HOST) \| (1 << UF_PORT) \| (1 << UF_PATH)
2191	- ,.port=67
2192	- ,.field_data=
2193	- {{ 0, 4 } /* UF_SCHEMA */
2194	- ,{ 8, 8 } /* UF_HOST */
2195	- ,{ 18, 2 } /* UF_PORT */
2196	- ,{ 20, 1 } /* UF_PATH */
2197	- ,{ 0, 0 } /* UF_QUERY */
2198	- ,{ 0, 0 } /* UF_FRAGMENT */
2199	- ,{ 0, 0 } /* UF_USERINFO */
2200	- }
2201	- }
2202	- ,.rv=0
2203	- }
2204	-
2205	-, {.name="CONNECT ipv6 address"
2206	- ,.url="[1:2::3:4]:443"
2207	- ,.is_connect=1
2208	- ,.u=
2209	- {.field_set=(1 << UF_HOST) \| (1 << UF_PORT)
2210	- ,.port=443
2211	- ,.field_data=
2212	- {{ 0, 0 } /* UF_SCHEMA */
2213	- ,{ 1, 8 } /* UF_HOST */
2214	- ,{ 11, 3 } /* UF_PORT */
2215	- ,{ 0, 0 } /* UF_PATH */
2216	- ,{ 0, 0 } /* UF_QUERY */
2217	- ,{ 0, 0 } /* UF_FRAGMENT */
2218	- ,{ 0, 0 } /* UF_USERINFO */
2219	- }
2220	- }
2221	- ,.rv=0
2222	- }
2223	-
2224	-, {.name="ipv4 in ipv6 address"
2225	- ,.url="http://[2001:0000:0000:0000:0000:0000:1.9.1.1]/"
2226	- ,.is_connect=0
2227	- ,.u=
2228	- {.field_set=(1 << UF_SCHEMA) \| (1 << UF_HOST) \| (1 << UF_PATH)
2229	- ,.port=0
2230	- ,.field_data=
2231	- {{ 0, 4 } /* UF_SCHEMA */
2232	- ,{ 8, 37 } /* UF_HOST */
2233	- ,{ 0, 0 } /* UF_PORT */
2234	- ,{ 46, 1 } /* UF_PATH */
2235	- ,{ 0, 0 } /* UF_QUERY */
2236	- ,{ 0, 0 } /* UF_FRAGMENT */
2237	- ,{ 0, 0 } /* UF_USERINFO */
2238	- }
2239	- }
2240	- ,.rv=0
2241	- }
2242	-
2243	-, {.name="extra ? in query string"
2244	- ,.url="http://a.tbcdn.cn/p/fp/2010c/??fp-header-min.css,fp-base-min.css,"
2245	- "fp-channel-min.css,fp-product-min.css,fp-mall-min.css,fp-category-min.css,"
2246	- "fp-sub-min.css,fp-gdp4p-min.css,fp-css3-min.css,fp-misc-min.css?t=20101022.css"
2247	- ,.is_connect=0
2248	- ,.u=
2249	- {.field_set=(1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH) \| (1<<UF_QUERY)
2250	- ,.port=0
2251	- ,.field_data=
2252	- {{ 0, 4 } /* UF_SCHEMA */
2253	- ,{ 7, 10 } /* UF_HOST */
2254	- ,{ 0, 0 } /* UF_PORT */
2255	- ,{ 17, 12 } /* UF_PATH */
2256	- ,{ 30,187 } /* UF_QUERY */
2257	- ,{ 0, 0 } /* UF_FRAGMENT */
2258	- ,{ 0, 0 } /* UF_USERINFO */
2259	- }
2260	- }
2261	- ,.rv=0
2262	- }
2263	-
2264	-, {.name="space URL encoded"
2265	- ,.url="/toto.html?toto=a%20b"
2266	- ,.is_connect=0
2267	- ,.u=
2268	- {.field_set= (1<<UF_PATH) \| (1<<UF_QUERY)
2269	- ,.port=0
2270	- ,.field_data=
2271	- {{ 0, 0 } /* UF_SCHEMA */
2272	- ,{ 0, 0 } /* UF_HOST */
2273	- ,{ 0, 0 } /* UF_PORT */
2274	- ,{ 0, 10 } /* UF_PATH */
2275	- ,{ 11, 10 } /* UF_QUERY */
2276	- ,{ 0, 0 } /* UF_FRAGMENT */
2277	- ,{ 0, 0 } /* UF_USERINFO */
2278	- }
2279	- }
2280	- ,.rv=0
2281	- }
2282	-
2283	-
2284	-, {.name="URL fragment"
2285	- ,.url="/toto.html#titi"
2286	- ,.is_connect=0
2287	- ,.u=
2288	- {.field_set= (1<<UF_PATH) \| (1<<UF_FRAGMENT)
2289	- ,.port=0
2290	- ,.field_data=
2291	- {{ 0, 0 } /* UF_SCHEMA */
2292	- ,{ 0, 0 } /* UF_HOST */
2293	- ,{ 0, 0 } /* UF_PORT */
2294	- ,{ 0, 10 } /* UF_PATH */
2295	- ,{ 0, 0 } /* UF_QUERY */
2296	- ,{ 11, 4 } /* UF_FRAGMENT */
2297	- ,{ 0, 0 } /* UF_USERINFO */
2298	- }
2299	- }
2300	- ,.rv=0
2301	- }
2302	-
2303	-, {.name="complex URL fragment"
2304	- ,.url="http://www.webmasterworld.com/r.cgi?f=21&d=8405&url="
2305	- "http://www.example.com/index.html?foo=bar&hello=world#midpage"
2306	- ,.is_connect=0
2307	- ,.u=
2308	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH) \| (1<<UF_QUERY) \|\
2309	- (1<<UF_FRAGMENT)
2310	- ,.port=0
2311	- ,.field_data=
2312	- {{ 0, 4 } /* UF_SCHEMA */
2313	- ,{ 7, 22 } /* UF_HOST */
2314	- ,{ 0, 0 } /* UF_PORT */
2315	- ,{ 29, 6 } /* UF_PATH */
2316	- ,{ 36, 69 } /* UF_QUERY */
2317	- ,{106, 7 } /* UF_FRAGMENT */
2318	- ,{ 0, 0 } /* UF_USERINFO */
2319	- }
2320	- }
2321	- ,.rv=0
2322	- }
2323	-
2324	-, {.name="complex URL from node js url parser doc"
2325	- ,.url="http://host.com:8080/p/a/t/h?query=string#hash"
2326	- ,.is_connect=0
2327	- ,.u=
2328	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PORT) \| (1<<UF_PATH) \|\
2329	- (1<<UF_QUERY) \| (1<<UF_FRAGMENT)
2330	- ,.port=8080
2331	- ,.field_data=
2332	- {{ 0, 4 } /* UF_SCHEMA */
2333	- ,{ 7, 8 } /* UF_HOST */
2334	- ,{ 16, 4 } /* UF_PORT */
2335	- ,{ 20, 8 } /* UF_PATH */
2336	- ,{ 29, 12 } /* UF_QUERY */
2337	- ,{ 42, 4 } /* UF_FRAGMENT */
2338	- ,{ 0, 0 } /* UF_USERINFO */
2339	- }
2340	- }
2341	- ,.rv=0
2342	- }
2343	-
2344	-, {.name="complex URL with basic auth from node js url parser doc"
2345	- ,.url="http://a:b@host.com:8080/p/a/t/h?query=string#hash"
2346	- ,.is_connect=0
2347	- ,.u=
2348	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PORT) \| (1<<UF_PATH) \|\
2349	- (1<<UF_QUERY) \| (1<<UF_FRAGMENT) \| (1<<UF_USERINFO)
2350	- ,.port=8080
2351	- ,.field_data=
2352	- {{ 0, 4 } /* UF_SCHEMA */
2353	- ,{ 11, 8 } /* UF_HOST */
2354	- ,{ 20, 4 } /* UF_PORT */
2355	- ,{ 24, 8 } /* UF_PATH */
2356	- ,{ 33, 12 } /* UF_QUERY */
2357	- ,{ 46, 4 } /* UF_FRAGMENT */
2358	- ,{ 7, 3 } /* UF_USERINFO */
2359	- }
2360	- }
2361	- ,.rv=0
2362	- }
2363	-
2364	-, {.name="double @"
2365	- ,.url="http://a:b@@hostname:443/"
2366	- ,.is_connect=0
2367	- ,.rv=1
2368	- }
2369	-
2370	-, {.name="proxy empty host"
2371	- ,.url="http://:443/"
2372	- ,.is_connect=0
2373	- ,.rv=1
2374	- }
2375	-
2376	-, {.name="proxy empty port"
2377	- ,.url="http://hostname:/"
2378	- ,.is_connect=0
2379	- ,.rv=1
2380	- }
2381	-
2382	-, {.name="CONNECT with basic auth"
2383	- ,.url="a:b@hostname:443"
2384	- ,.is_connect=1
2385	- ,.rv=1
2386	- }
2387	-
2388	-, {.name="CONNECT empty host"
2389	- ,.url=":443"
2390	- ,.is_connect=1
2391	- ,.rv=1
2392	- }
2393	-
2394	-, {.name="CONNECT empty port"
2395	- ,.url="hostname:"
2396	- ,.is_connect=1
2397	- ,.rv=1
2398	- }
2399	-
2400	-, {.name="CONNECT with extra bits"
2401	- ,.url="hostname:443/"
2402	- ,.is_connect=1
2403	- ,.rv=1
2404	- }
2405	-
2406	-, {.name="space in URL"
2407	- ,.url="/foo bar/"
2408	- ,.rv=1 /* s_dead */
2409	- }
2410	-
2411	-, {.name="proxy basic auth with space url encoded"
2412	- ,.url="http://a%20:b@host.com/"
2413	- ,.is_connect=0
2414	- ,.u=
2415	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH) \| (1<<UF_USERINFO)
2416	- ,.port=0
2417	- ,.field_data=
2418	- {{ 0, 4 } /* UF_SCHEMA */
2419	- ,{ 14, 8 } /* UF_HOST */
2420	- ,{ 0, 0 } /* UF_PORT */
2421	- ,{ 22, 1 } /* UF_PATH */
2422	- ,{ 0, 0 } /* UF_QUERY */
2423	- ,{ 0, 0 } /* UF_FRAGMENT */
2424	- ,{ 7, 6 } /* UF_USERINFO */
2425	- }
2426	- }
2427	- ,.rv=0
2428	- }
2429	-
2430	-, {.name="carriage return in URL"
2431	- ,.url="/foo\rbar/"
2432	- ,.rv=1 /* s_dead */
2433	- }
2434	-
2435	-, {.name="proxy double : in URL"
2436	- ,.url="http://hostname::443/"
2437	- ,.rv=1 /* s_dead */
2438	- }
2439	-
2440	-, {.name="proxy basic auth with double :"
2441	- ,.url="http://a::b@host.com/"
2442	- ,.is_connect=0
2443	- ,.u=
2444	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH) \| (1<<UF_USERINFO)
2445	- ,.port=0
2446	- ,.field_data=
2447	- {{ 0, 4 } /* UF_SCHEMA */
2448	- ,{ 12, 8 } /* UF_HOST */
2449	- ,{ 0, 0 } /* UF_PORT */
2450	- ,{ 20, 1 } /* UF_PATH */
2451	- ,{ 0, 0 } /* UF_QUERY */
2452	- ,{ 0, 0 } /* UF_FRAGMENT */
2453	- ,{ 7, 4 } /* UF_USERINFO */
2454	- }
2455	- }
2456	- ,.rv=0
2457	- }
2458	-
2459	-, {.name="line feed in URL"
2460	- ,.url="/foo\nbar/"
2461	- ,.rv=1 /* s_dead */
2462	- }
2463	-
2464	-, {.name="proxy empty basic auth"
2465	- ,.url="http://@hostname/fo"
2466	- ,.u=
2467	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH)
2468	- ,.port=0
2469	- ,.field_data=
2470	- {{ 0, 4 } /* UF_SCHEMA */
2471	- ,{ 8, 8 } /* UF_HOST */
2472	- ,{ 0, 0 } /* UF_PORT */
2473	- ,{ 16, 3 } /* UF_PATH */
2474	- ,{ 0, 0 } /* UF_QUERY */
2475	- ,{ 0, 0 } /* UF_FRAGMENT */
2476	- ,{ 0, 0 } /* UF_USERINFO */
2477	- }
2478	- }
2479	- ,.rv=0
2480	- }
2481	-, {.name="proxy line feed in hostname"
2482	- ,.url="http://host\name/fo"
2483	- ,.rv=1 /* s_dead */
2484	- }
2485	-
2486	-, {.name="proxy % in hostname"
2487	- ,.url="http://host%name/fo"
2488	- ,.rv=1 /* s_dead */
2489	- }
2490	-
2491	-, {.name="proxy ; in hostname"
2492	- ,.url="http://host;ame/fo"
2493	- ,.rv=1 /* s_dead */
2494	- }
2495	-
2496	-, {.name="proxy basic auth with unreservedchars"
2497	- ,.url="http://a!;-_!=+$@host.com/"
2498	- ,.is_connect=0
2499	- ,.u=
2500	- {.field_set= (1<<UF_SCHEMA) \| (1<<UF_HOST) \| (1<<UF_PATH) \| (1<<UF_USERINFO)
2501	- ,.port=0
2502	- ,.field_data=
2503	- {{ 0, 4 } /* UF_SCHEMA */
2504	- ,{ 17, 8 } /* UF_HOST */
2505	- ,{ 0, 0 } /* UF_PORT */
2506	- ,{ 25, 1 } /* UF_PATH */
2507	- ,{ 0, 0 } /* UF_QUERY */
2508	- ,{ 0, 0 } /* UF_FRAGMENT */
2509	- ,{ 7, 9 } /* UF_USERINFO */
2510	- }
2511	- }
2512	- ,.rv=0
2513	- }
2514	-
2515	-, {.name="proxy only empty basic auth"
2516	- ,.url="http://@/fo"
2517	- ,.rv=1 /* s_dead */
2518	- }
2519	-
2520	-, {.name="proxy only basic auth"
2521	- ,.url="http://toto@/fo"
2522	- ,.rv=1 /* s_dead */
2523	- }
2524	-
2525	-, {.name="proxy emtpy hostname"
2526	- ,.url="http:///fo"
2527	- ,.rv=1 /* s_dead */
2528	- }
2529	-
2530	-, {.name="proxy = in URL"
2531	- ,.url="http://host=ame/fo"
2532	- ,.rv=1 /* s_dead */
2533	- }
2534	-
2535	-#if HTTP_PARSER_STRICT
2536	-
2537	-, {.name="tab in URL"
2538	- ,.url="/foo\tbar/"
2539	- ,.rv=1 /* s_dead */
2540	- }
2541	-
2542	-, {.name="form feed in URL"
2543	- ,.url="/foo\fbar/"
2544	- ,.rv=1 /* s_dead */
2545	- }
2546	-
2547	-#else /* !HTTP_PARSER_STRICT */
2548	-
2549	-, {.name="tab in URL"
2550	- ,.url="/foo\tbar/"
2551	- ,.u=
2552	- {.field_set=(1 << UF_PATH)
2553	- ,.field_data=
2554	- {{ 0, 0 } /* UF_SCHEMA */
2555	- ,{ 0, 0 } /* UF_HOST */
2556	- ,{ 0, 0 } /* UF_PORT */
2557	- ,{ 0, 9 } /* UF_PATH */
2558	- ,{ 0, 0 } /* UF_QUERY */
2559	- ,{ 0, 0 } /* UF_FRAGMENT */
2560	- ,{ 0, 0 } /* UF_USERINFO */
2561	- }
2562	- }
2563	- ,.rv=0
2564	- }
2565	-
2566	-, {.name="form feed in URL"
2567	- ,.url="/foo\fbar/"
2568	- ,.u=
2569	- {.field_set=(1 << UF_PATH)
2570	- ,.field_data=
2571	- {{ 0, 0 } /* UF_SCHEMA */
2572	- ,{ 0, 0 } /* UF_HOST */
2573	- ,{ 0, 0 } /* UF_PORT */
2574	- ,{ 0, 9 } /* UF_PATH */
2575	- ,{ 0, 0 } /* UF_QUERY */
2576	- ,{ 0, 0 } /* UF_FRAGMENT */
2577	- ,{ 0, 0 } /* UF_USERINFO */
2578	- }
2579	- }
2580	- ,.rv=0
2581	- }
2582	-#endif
2583	-};
2584	-
2585	-void
2586	-dump_url (const char url, const struct http_parser_url u)
2587	-{
2588	- unsigned int i;
2589	-
2590	- printf("\tfield_set: 0x%x, port: %u\n", u->field_set, u->port);
2591	- for (i = 0; i < UF_MAX; i++) {
2592	- if ((u->field_set & (1 << i)) == 0) {
2593	- printf("\tfield_data[%u]: unset\n", i);
2594	- continue;
2595	- }
2596	-
2597	- printf("\tfield_data[%u]: off: %u len: %u part: \"%.*s\n\"",
2598	- i,
2599	- u->field_data[i].off,
2600	- u->field_data[i].len,
2601	- u->field_data[i].len,
2602	- url + u->field_data[i].off);
2603	- }
2604	-}
2605	-
2606	-void
2607	-test_parse_url (void)
2608	-{
2609	- struct http_parser_url u;
2610	- const struct url_test *test;
2611	- unsigned int i;
2612	- int rv;
2613	-
2614	- for (i = 0; i < (sizeof(url_tests) / sizeof(url_tests[0])); i++) {
2615	- test = &url_tests[i];
2616	- memset(&u, 0, sizeof(u));
2617	-
2618	- rv = http_parser_parse_url(test->url,
2619	- strlen(test->url),
2620	- test->is_connect,
2621	- &u);
2622	-
2623	- if (test->rv == 0) {
2624	- if (rv != 0) {
2625	- printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
2626	- "unexpected rv %d ***\n\n", test->url, test->name, rv);
2627	- abort();
2628	- }
2629	-
2630	- if (memcmp(&u, &test->u, sizeof(u)) != 0) {
2631	- printf("\n* http_parser_parse_url(\"%s\") \"%s\" failed *\n",
2632	- test->url, test->name);
2633	-
2634	- printf("target http_parser_url:\n");
2635	- dump_url(test->url, &test->u);
2636	- printf("result http_parser_url:\n");
2637	- dump_url(test->url, &u);
2638	-
2639	- abort();
2640	- }
2641	- } else {
2642	- /* test->rv != 0 */
2643	- if (rv == 0) {
2644	- printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
2645	- "unexpected rv %d ***\n\n", test->url, test->name, rv);
2646	- abort();
2647	- }
2648	- }
2649	- }
2650	-}
2651	-
2652	-void
2653	-test_method_str (void)
2654	-{
2655	- assert(0 == strcmp("GET", http_method_str(HTTP_GET)));
2656	- assert(0 == strcmp("<unknown>", http_method_str(1337)));
2657	-}
2658	-
2659	-void
2660	-test_message (const struct message *message)
2661	-{
2662	- size_t raw_len = strlen(message->raw);
2663	- size_t msg1len;
2664	- for (msg1len = 0; msg1len < raw_len; msg1len++) {
2665	- parser_init(message->type);
2666	-
2667	- size_t read;
2668	- const char *msg1 = message->raw;
2669	- const char *msg2 = msg1 + msg1len;
2670	- size_t msg2len = raw_len - msg1len;
2671	-
2672	- if (msg1len) {
2673	- read = parse(msg1, msg1len);
2674	-
2675	- if (message->upgrade && parser->upgrade) {
2676	- messages[num_messages - 1].upgrade = msg1 + read;
2677	- goto test;
2678	- }
2679	-
2680	- if (read != msg1len) {
2681	- print_error(msg1, read);
2682	- abort();
2683	- }
2684	- }
2685	-
2686	-
2687	- read = parse(msg2, msg2len);
2688	-
2689	- if (message->upgrade && parser->upgrade) {
2690	- messages[num_messages - 1].upgrade = msg2 + read;
2691	- goto test;
2692	- }
2693	-
2694	- if (read != msg2len) {
2695	- print_error(msg2, read);
2696	- abort();
2697	- }
2698	-
2699	- read = parse(NULL, 0);
2700	-
2701	- if (read != 0) {
2702	- print_error(message->raw, read);
2703	- abort();
2704	- }
2705	-
2706	- test:
2707	-
2708	- if (num_messages != 1) {
2709	- printf("\n* num_messages != 1 after testing '%s' *\n\n", message->name);
2710	- abort();
2711	- }
2712	-
2713	- if(!message_eq(0, message)) abort();
2714	-
2715	- parser_free();
2716	- }
2717	-}
2718	-
2719	-void
2720	-test_message_count_body (const struct message *message)
2721	-{
2722	- parser_init(message->type);
2723	-
2724	- size_t read;
2725	- size_t l = strlen(message->raw);
2726	- size_t i, toread;
2727	- size_t chunk = 4024;
2728	-
2729	- for (i = 0; i < l; i+= chunk) {
2730	- toread = MIN(l-i, chunk);
2731	- read = parse_count_body(message->raw + i, toread);
2732	- if (read != toread) {
2733	- print_error(message->raw, read);
2734	- abort();
2735	- }
2736	- }
2737	-
2738	-
2739	- read = parse_count_body(NULL, 0);
2740	- if (read != 0) {
2741	- print_error(message->raw, read);
2742	- abort();
2743	- }
2744	-
2745	- if (num_messages != 1) {
2746	- printf("\n* num_messages != 1 after testing '%s' *\n\n", message->name);
2747	- abort();
2748	- }
2749	-
2750	- if(!message_eq(0, message)) abort();
2751	-
2752	- parser_free();
2753	-}
2754	-
2755	-void
2756	-test_simple (const char *buf, enum http_errno err_expected)
2757	-{
2758	- parser_init(HTTP_REQUEST);
2759	-
2760	- size_t parsed;
2761	- int pass;
2762	- enum http_errno err;
2763	-
2764	- parsed = parse(buf, strlen(buf));
2765	- pass = (parsed == strlen(buf));
2766	- err = HTTP_PARSER_ERRNO(parser);
2767	- parsed = parse(NULL, 0);
2768	- pass &= (parsed == 0);
2769	-
2770	- parser_free();
2771	-
2772	- /* In strict mode, allow us to pass with an unexpected HPE_STRICT as
2773	- * long as the caller isn't expecting success.
2774	- */
2775	-#if HTTP_PARSER_STRICT
2776	- if (err_expected != err && err_expected != HPE_OK && err != HPE_STRICT) {
2777	-#else
2778	- if (err_expected != err) {
2779	-#endif
2780	- fprintf(stderr, "\n* test_simple expected %s, but saw %s *\n\n%s\n",
2781	- http_errno_name(err_expected), http_errno_name(err), buf);
2782	- abort();
2783	- }
2784	-}
2785	-
2786	-void
2787	-test_header_overflow_error (int req)
2788	-{
2789	- http_parser parser;
2790	- http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
2791	- size_t parsed;
2792	- const char *buf;
2793	- buf = req ? "GET / HTTP/1.1\r\n" : "HTTP/1.0 200 OK\r\n";
2794	- parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
2795	- assert(parsed == strlen(buf));
2796	-
2797	- buf = "header-key: header-value\r\n";
2798	- size_t buflen = strlen(buf);
2799	-
2800	- int i;
2801	- for (i = 0; i < 10000; i++) {
2802	- parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
2803	- if (parsed != buflen) {
2804	- //fprintf(stderr, "error found on iter %d\n", i);
2805	- assert(HTTP_PARSER_ERRNO(&parser) == HPE_HEADER_OVERFLOW);
2806	- return;
2807	- }
2808	- }
2809	-
2810	- fprintf(stderr, "\n* Error expected but none in header overflow test *\n");
2811	- abort();
2812	-}
2813	-
2814	-static void
2815	-test_content_length_overflow (const char *buf, size_t buflen, int expect_ok)
2816	-{
2817	- http_parser parser;
2818	- http_parser_init(&parser, HTTP_RESPONSE);
2819	- http_parser_execute(&parser, &settings_null, buf, buflen);
2820	-
2821	- if (expect_ok)
2822	- assert(HTTP_PARSER_ERRNO(&parser) == HPE_OK);
2823	- else
2824	- assert(HTTP_PARSER_ERRNO(&parser) == HPE_INVALID_CONTENT_LENGTH);
2825	-}
2826	-
2827	-void
2828	-test_header_content_length_overflow_error (void)
2829	-{
2830	-#define X(size) \
2831	- "HTTP/1.1 200 OK\r\n" \
2832	- "Content-Length: " #size "\r\n" \
2833	- "\r\n"
2834	- const char a[] = X(18446744073709551614); /* 2^64-2 */
2835	- const char b[] = X(18446744073709551615); /* 2^64-1 */
2836	- const char c[] = X(18446744073709551616); /* 2^64 */
2837	-#undef X
2838	- test_content_length_overflow(a, sizeof(a) - 1, 1); /* expect ok */
2839	- test_content_length_overflow(b, sizeof(b) - 1, 0); /* expect failure */
2840	- test_content_length_overflow(c, sizeof(c) - 1, 0); /* expect failure */
2841	-}
2842	-
2843	-void
2844	-test_chunk_content_length_overflow_error (void)
2845	-{
2846	-#define X(size) \
2847	- "HTTP/1.1 200 OK\r\n" \
2848	- "Transfer-Encoding: chunked\r\n" \
2849	- "\r\n" \
2850	- #size "\r\n" \
2851	- "..."
2852	- const char a[] = X(FFFFFFFFFFFFFFFE); /* 2^64-2 */
2853	- const char b[] = X(FFFFFFFFFFFFFFFF); /* 2^64-1 */
2854	- const char c[] = X(10000000000000000); /* 2^64 */
2855	-#undef X
2856	- test_content_length_overflow(a, sizeof(a) - 1, 1); /* expect ok */
2857	- test_content_length_overflow(b, sizeof(b) - 1, 0); /* expect failure */
2858	- test_content_length_overflow(c, sizeof(c) - 1, 0); /* expect failure */
2859	-}
2860	-
2861	-void
2862	-test_no_overflow_long_body (int req, size_t length)
2863	-{
2864	- http_parser parser;
2865	- http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
2866	- size_t parsed;
2867	- size_t i;
2868	- char buf1[3000];
2869	- size_t buf1len = sprintf(buf1, "%s\r\nConnection: Keep-Alive\r\nContent-Length: %lu\r\n\r\n",
2870	- req ? "POST / HTTP/1.0" : "HTTP/1.0 200 OK", (unsigned long)length);
2871	- parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
2872	- if (parsed != buf1len)
2873	- goto err;
2874	-
2875	- for (i = 0; i < length; i++) {
2876	- char foo = 'a';
2877	- parsed = http_parser_execute(&parser, &settings_null, &foo, 1);
2878	- if (parsed != 1)
2879	- goto err;
2880	- }
2881	-
2882	- parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
2883	- if (parsed != buf1len) goto err;
2884	- return;
2885	-
2886	- err:
2887	- fprintf(stderr,
2888	- "\n* error in test_no_overflow_long_body %s of length %lu *\n",
2889	- req ? "REQUEST" : "RESPONSE",
2890	- (unsigned long)length);
2891	- abort();
2892	-}
2893	-
2894	-void
2895	-test_multiple3 (const struct message r1, const struct message r2, const struct message *r3)
2896	-{
2897	- int message_count = count_parsed_messages(3, r1, r2, r3);
2898	-
2899	- char total[ strlen(r1->raw)
2900	- + strlen(r2->raw)
2901	- + strlen(r3->raw)
2902	- + 1
2903	- ];
2904	- total[0] = '\0';
2905	-
2906	- strcat(total, r1->raw);
2907	- strcat(total, r2->raw);
2908	- strcat(total, r3->raw);
2909	-
2910	- parser_init(r1->type);
2911	-
2912	- size_t read;
2913	-
2914	- read = parse(total, strlen(total));
2915	-
2916	- if (parser->upgrade) {
2917	- upgrade_message_fix(total, read, 3, r1, r2, r3);
2918	- goto test;
2919	- }
2920	-
2921	- if (read != strlen(total)) {
2922	- print_error(total, read);
2923	- abort();
2924	- }
2925	-
2926	- read = parse(NULL, 0);
2927	-
2928	- if (read != 0) {
2929	- print_error(total, read);
2930	- abort();
2931	- }
2932	-
2933	-test:
2934	-
2935	- if (message_count != num_messages) {
2936	- fprintf(stderr, "\n\n* Parser didn't see 3 messages only %d * \n", num_messages);
2937	- abort();
2938	- }
2939	-
2940	- if (!message_eq(0, r1)) abort();
2941	- if (message_count > 1 && !message_eq(1, r2)) abort();
2942	- if (message_count > 2 && !message_eq(2, r3)) abort();
2943	-
2944	- parser_free();
2945	-}
2946	-
2947	-/* SCAN through every possible breaking to make sure the
2948	- * parser can handle getting the content in any chunks that
2949	- * might come from the socket
2950	- */
2951	-void
2952	-test_scan (const struct message r1, const struct message r2, const struct message *r3)
2953	-{
2954	- char total[80*1024] = "\0";
2955	- char buf1[80*1024] = "\0";
2956	- char buf2[80*1024] = "\0";
2957	- char buf3[80*1024] = "\0";
2958	-
2959	- strcat(total, r1->raw);
2960	- strcat(total, r2->raw);
2961	- strcat(total, r3->raw);
2962	-
2963	- size_t read;
2964	-
2965	- int total_len = strlen(total);
2966	-
2967	- int total_ops = 2 * (total_len - 1) * (total_len - 2) / 2;
2968	- int ops = 0 ;
2969	-
2970	- size_t buf1_len, buf2_len, buf3_len;
2971	- int message_count = count_parsed_messages(3, r1, r2, r3);
2972	-
2973	- int i,j,type_both;
2974	- for (type_both = 0; type_both < 2; type_both ++ ) {
2975	- for (j = 2; j < total_len; j ++ ) {
2976	- for (i = 1; i < j; i ++ ) {
2977	-
2978	- if (ops % 1000 == 0) {
2979	- printf("\b\b\b\b%3.0f%%", 100 * (float)ops /(float)total_ops);
2980	- fflush(stdout);
2981	- }
2982	- ops += 1;
2983	-
2984	- parser_init(type_both ? HTTP_BOTH : r1->type);
2985	-
2986	- buf1_len = i;
2987	- strlncpy(buf1, sizeof(buf1), total, buf1_len);
2988	- buf1[buf1_len] = 0;
2989	-
2990	- buf2_len = j - i;
2991	- strlncpy(buf2, sizeof(buf1), total+i, buf2_len);
2992	- buf2[buf2_len] = 0;
2993	-
2994	- buf3_len = total_len - j;
2995	- strlncpy(buf3, sizeof(buf1), total+j, buf3_len);
2996	- buf3[buf3_len] = 0;
2997	-
2998	- read = parse(buf1, buf1_len);
2999	-
3000	- if (parser->upgrade) goto test;
3001	-
3002	- if (read != buf1_len) {
3003	- print_error(buf1, read);
3004	- goto error;
3005	- }
3006	-
3007	- read += parse(buf2, buf2_len);
3008	-
3009	- if (parser->upgrade) goto test;
3010	-
3011	- if (read != buf1_len + buf2_len) {
3012	- print_error(buf2, read);
3013	- goto error;
3014	- }
3015	-
3016	- read += parse(buf3, buf3_len);
3017	-
3018	- if (parser->upgrade) goto test;
3019	-
3020	- if (read != buf1_len + buf2_len + buf3_len) {
3021	- print_error(buf3, read);
3022	- goto error;
3023	- }
3024	-
3025	- parse(NULL, 0);
3026	-
3027	-test:
3028	- if (parser->upgrade) {
3029	- upgrade_message_fix(total, read, 3, r1, r2, r3);
3030	- }
3031	-
3032	- if (message_count != num_messages) {
3033	- fprintf(stderr, "\n\nParser didn't see %d messages only %d\n",
3034	- message_count, num_messages);
3035	- goto error;
3036	- }
3037	-
3038	- if (!message_eq(0, r1)) {
3039	- fprintf(stderr, "\n\nError matching messages[0] in test_scan.\n");
3040	- goto error;
3041	- }
3042	-
3043	- if (message_count > 1 && !message_eq(1, r2)) {
3044	- fprintf(stderr, "\n\nError matching messages[1] in test_scan.\n");
3045	- goto error;
3046	- }
3047	-
3048	- if (message_count > 2 && !message_eq(2, r3)) {
3049	- fprintf(stderr, "\n\nError matching messages[2] in test_scan.\n");
3050	- goto error;
3051	- }
3052	-
3053	- parser_free();
3054	- }
3055	- }
3056	- }
3057	- puts("\b\b\b\b100%");
3058	- return;
3059	-
3060	- error:
3061	- fprintf(stderr, "i=%d j=%d\n", i, j);
3062	- fprintf(stderr, "buf1 (%u) %s\n\n", (unsigned int)buf1_len, buf1);
3063	- fprintf(stderr, "buf2 (%u) %s\n\n", (unsigned int)buf2_len , buf2);
3064	- fprintf(stderr, "buf3 (%u) %s\n", (unsigned int)buf3_len, buf3);
3065	- abort();
3066	-}
3067	-
3068	-// user required to free the result
3069	-// string terminated by \0
3070	-char *
3071	-create_large_chunked_message (int body_size_in_kb, const char* headers)
3072	-{
3073	- int i;
3074	- size_t wrote = 0;
3075	- size_t headers_len = strlen(headers);
3076	- size_t bufsize = headers_len + (5+1024+2)*body_size_in_kb + 6;
3077	- char * buf = malloc(bufsize);
3078	-
3079	- memcpy(buf, headers, headers_len);
3080	- wrote += headers_len;
3081	-
3082	- for (i = 0; i < body_size_in_kb; i++) {
3083	- // write 1kb chunk into the body.
3084	- memcpy(buf + wrote, "400\r\n", 5);
3085	- wrote += 5;
3086	- memset(buf + wrote, 'C', 1024);
3087	- wrote += 1024;
3088	- strcpy(buf + wrote, "\r\n");
3089	- wrote += 2;
3090	- }
3091	-
3092	- memcpy(buf + wrote, "0\r\n\r\n", 6);
3093	- wrote += 6;
3094	- assert(wrote == bufsize);
3095	-
3096	- return buf;
3097	-}
3098	-
3099	-void
3100	-test_status_complete (void)
3101	-{
3102	- parser_init(HTTP_RESPONSE);
3103	- parser->data = 0;
3104	- http_parser_settings settings = settings_null;
3105	- settings.on_status_complete = status_complete_cb;
3106	-
3107	- char *response = "don't mind me, just a simple response";
3108	- http_parser_execute(parser, &settings, response, strlen(response));
3109	- assert(parser->data == (void*)0); // the status_complete callback was never called
3110	- assert(parser->http_errno == HPE_INVALID_CONSTANT); // the errno for an invalid status line
3111	-}
3112	-
3113	-/* Verify that we can pause parsing at any of the bytes in the
3114	- * message and still get the result that we're expecting. */
3115	-void
3116	-test_message_pause (const struct message *msg)
3117	-{
3118	- char buf = (char) msg->raw;
3119	- size_t buflen = strlen(msg->raw);
3120	- size_t nread;
3121	-
3122	- parser_init(msg->type);
3123	-
3124	- do {
3125	- nread = parse_pause(buf, buflen);
3126	-
3127	- // We can only set the upgrade buffer once we've gotten our message
3128	- // completion callback.
3129	- if (messages[0].message_complete_cb_called &&
3130	- msg->upgrade &&
3131	- parser->upgrade) {
3132	- messages[0].upgrade = buf + nread;
3133	- goto test;
3134	- }
3135	-
3136	- if (nread < buflen) {
3137	-
3138	- // Not much do to if we failed a strict-mode check
3139	- if (HTTP_PARSER_ERRNO(parser) == HPE_STRICT) {
3140	- parser_free();
3141	- return;
3142	- }
3143	-
3144	- assert (HTTP_PARSER_ERRNO(parser) == HPE_PAUSED);
3145	- }
3146	-
3147	- buf += nread;
3148	- buflen -= nread;
3149	- http_parser_pause(parser, 0);
3150	- } while (buflen > 0);
3151	-
3152	- nread = parse_pause(NULL, 0);
3153	- assert (nread == 0);
3154	-
3155	-test:
3156	- if (num_messages != 1) {
3157	- printf("\n* num_messages != 1 after testing '%s' *\n\n", msg->name);
3158	- abort();
3159	- }
3160	-
3161	- if(!message_eq(0, msg)) abort();
3162	-
3163	- parser_free();
3164	-}
3165	-
3166	-int
3167	-main (void)
3168	-{
3169	- parser = NULL;
3170	- int i, j, k;
3171	- int request_count;
3172	- int response_count;
3173	-
3174	- printf("sizeof(http_parser) = %u\n", (unsigned int)sizeof(http_parser));
3175	-
3176	- for (request_count = 0; requests[request_count].name; request_count++);
3177	- for (response_count = 0; responses[response_count].name; response_count++);
3178	-
3179	- //// API
3180	- test_preserve_data();
3181	- test_parse_url();
3182	- test_method_str();
3183	-
3184	- //// OVERFLOW CONDITIONS
3185	-
3186	- test_header_overflow_error(HTTP_REQUEST);
3187	- test_no_overflow_long_body(HTTP_REQUEST, 1000);
3188	- test_no_overflow_long_body(HTTP_REQUEST, 100000);
3189	-
3190	- test_header_overflow_error(HTTP_RESPONSE);
3191	- test_no_overflow_long_body(HTTP_RESPONSE, 1000);
3192	- test_no_overflow_long_body(HTTP_RESPONSE, 100000);
3193	-
3194	- test_header_content_length_overflow_error();
3195	- test_chunk_content_length_overflow_error();
3196	-
3197	- //// RESPONSES
3198	-
3199	- for (i = 0; i < response_count; i++) {
3200	- test_message(&responses[i]);
3201	- }
3202	-
3203	- for (i = 0; i < response_count; i++) {
3204	- test_message_pause(&responses[i]);
3205	- }
3206	-
3207	- for (i = 0; i < response_count; i++) {
3208	- if (!responses[i].should_keep_alive) continue;
3209	- for (j = 0; j < response_count; j++) {
3210	- if (!responses[j].should_keep_alive) continue;
3211	- for (k = 0; k < response_count; k++) {
3212	- test_multiple3(&responses[i], &responses[j], &responses[k]);
3213	- }
3214	- }
3215	- }
3216	-
3217	- test_message_count_body(&responses[NO_HEADERS_NO_BODY_404]);
3218	- test_message_count_body(&responses[TRAILING_SPACE_ON_CHUNKED_BODY]);
3219	-
3220	- // test very large chunked response
3221	- {
3222	- char * msg = create_large_chunked_message(31337,
3223	- "HTTP/1.0 200 OK\r\n"
3224	- "Transfer-Encoding: chunked\r\n"
3225	- "Content-Type: text/plain\r\n"
3226	- "\r\n");
3227	- struct message large_chunked =
3228	- {.name= "large chunked"
3229	- ,.type= HTTP_RESPONSE
3230	- ,.raw= msg
3231	- ,.should_keep_alive= FALSE
3232	- ,.message_complete_on_eof= FALSE
3233	- ,.http_major= 1
3234	- ,.http_minor= 0
3235	- ,.status_code= 200
3236	- ,.num_headers= 2
3237	- ,.headers=
3238	- { { "Transfer-Encoding", "chunked" }
3239	- , { "Content-Type", "text/plain" }
3240	- }
3241	- ,.body_size= 31337*1024
3242	- };
3243	- test_message_count_body(&large_chunked);
3244	- free(msg);
3245	- }
3246	-
3247	-
3248	-
3249	- printf("response scan 1/2 ");
3250	- test_scan( &responses[TRAILING_SPACE_ON_CHUNKED_BODY]
3251	- , &responses[NO_BODY_HTTP10_KA_204]
3252	- , &responses[NO_REASON_PHRASE]
3253	- );
3254	-
3255	- printf("response scan 2/2 ");
3256	- test_scan( &responses[BONJOUR_MADAME_FR]
3257	- , &responses[UNDERSTORE_HEADER_KEY]
3258	- , &responses[NO_CARRIAGE_RET]
3259	- );
3260	-
3261	- puts("responses okay");
3262	-
3263	-
3264	- /// REQUESTS
3265	-
3266	- test_simple("hello world", HPE_INVALID_METHOD);
3267	- test_simple("GET / HTP/1.1\r\n\r\n", HPE_INVALID_VERSION);
3268	-
3269	-
3270	- test_simple("ASDF / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
3271	- test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
3272	- test_simple("GETA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
3273	-
3274	- // Well-formed but incomplete
3275	- test_simple("GET / HTTP/1.1\r\n"
3276	- "Content-Type: text/plain\r\n"
3277	- "Content-Length: 6\r\n"
3278	- "\r\n"
3279	- "fooba",
3280	- HPE_OK);
3281	-
3282	- static const char *all_methods[] = {
3283	- "DELETE",
3284	- "GET",
3285	- "HEAD",
3286	- "POST",
3287	- "PUT",
3288	- //"CONNECT", //CONNECT can't be tested like other methods, it's a tunnel
3289	- "OPTIONS",
3290	- "TRACE",
3291	- "COPY",
3292	- "LOCK",
3293	- "MKCOL",
3294	- "MOVE",
3295	- "PROPFIND",
3296	- "PROPPATCH",
3297	- "UNLOCK",
3298	- "REPORT",
3299	- "MKACTIVITY",
3300	- "CHECKOUT",
3301	- "MERGE",
3302	- "M-SEARCH",
3303	- "NOTIFY",
3304	- "SUBSCRIBE",
3305	- "UNSUBSCRIBE",
3306	- "PATCH",
3307	- 0 };
3308	- const char **this_method;
3309	- for (this_method = all_methods; *this_method; this_method++) {
3310	- char buf[200];
3311	- sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
3312	- test_simple(buf, HPE_OK);
3313	- }
3314	-
3315	- static const char *bad_methods[] = {
3316	- "C******",
3317	- "M****",
3318	- 0 };
3319	- for (this_method = bad_methods; *this_method; this_method++) {
3320	- char buf[200];
3321	- sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
3322	- test_simple(buf, HPE_UNKNOWN);
3323	- }
3324	-
3325	- const char *dumbfuck2 =
3326	- "GET / HTTP/1.1\r\n"
3327	- "X-SSL-Bullshit: -----BEGIN CERTIFICATE-----\r\n"
3328	- "\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n"
3329	- "\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n"
3330	- "\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n"
3331	- "\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n"
3332	- "\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n"
3333	- "\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n"
3334	- "\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n"
3335	- "\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n"
3336	- "\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n"
3337	- "\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n"
3338	- "\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n"
3339	- "\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n"
3340	- "\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgHTTPAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n"
3341	- "\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n"
3342	- "\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n"
3343	- "\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n"
3344	- "\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n"
3345	- "\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n"
3346	- "\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n"
3347	- "\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n"
3348	- "\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n"
3349	- "\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n"
3350	- "\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n"
3351	- "\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n"
3352	- "\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n"
3353	- "\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n"
3354	- "\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n"
3355	- "\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n"
3356	- "\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n"
3357	- "\tRA==\r\n"
3358	- "\t-----END CERTIFICATE-----\r\n"
3359	- "\r\n";
3360	- test_simple(dumbfuck2, HPE_OK);
3361	-
3362	-#if 0
3363	- // NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body
3364	- // until EOF.
3365	- //
3366	- // no content-length
3367	- // error if there is a body without content length
3368	- const char *bad_get_no_headers_no_body = "GET /bad_get_no_headers_no_body/world HTTP/1.1\r\n"
3369	- "Accept: /\r\n"
3370	- "\r\n"
3371	- "HELLO";
3372	- test_simple(bad_get_no_headers_no_body, 0);
3373	-#endif
3374	- /* TODO sending junk and large headers gets rejected */
3375	-
3376	-
3377	- /* check to make sure our predefined requests are okay */
3378	- for (i = 0; requests[i].name; i++) {
3379	- test_message(&requests[i]);
3380	- }
3381	-
3382	- for (i = 0; i < request_count; i++) {
3383	- test_message_pause(&requests[i]);
3384	- }
3385	-
3386	- for (i = 0; i < request_count; i++) {
3387	- if (!requests[i].should_keep_alive) continue;
3388	- for (j = 0; j < request_count; j++) {
3389	- if (!requests[j].should_keep_alive) continue;
3390	- for (k = 0; k < request_count; k++) {
3391	- test_multiple3(&requests[i], &requests[j], &requests[k]);
3392	- }
3393	- }
3394	- }
3395	-
3396	- printf("request scan 1/4 ");
3397	- test_scan( &requests[GET_NO_HEADERS_NO_BODY]
3398	- , &requests[GET_ONE_HEADER_NO_BODY]
3399	- , &requests[GET_NO_HEADERS_NO_BODY]
3400	- );
3401	-
3402	- printf("request scan 2/4 ");
3403	- test_scan( &requests[POST_CHUNKED_ALL_YOUR_BASE]
3404	- , &requests[POST_IDENTITY_BODY_WORLD]
3405	- , &requests[GET_FUNKY_CONTENT_LENGTH]
3406	- );
3407	-
3408	- printf("request scan 3/4 ");
3409	- test_scan( &requests[TWO_CHUNKS_MULT_ZERO_END]
3410	- , &requests[CHUNKED_W_TRAILING_HEADERS]
3411	- , &requests[CHUNKED_W_BULLSHIT_AFTER_LENGTH]
3412	- );
3413	-
3414	- printf("request scan 4/4 ");
3415	- test_scan( &requests[QUERY_URL_WITH_QUESTION_MARK_GET]
3416	- , &requests[PREFIX_NEWLINE_GET ]
3417	- , &requests[CONNECT_REQUEST]
3418	- );
3419	-
3420	- test_status_complete();
3421	-
3422	- puts("requests okay");
3423	-
3424	- return 0;
3425	-}