-CPPFLAGS?=-Wall -Wextra -Werror -I.
-OPT_DEBUG=$(CPPFLAGS) -O0 -g -DHTTP_PARSER_STRICT=1
-OPT_FAST=$(CPPFLAGS) -O3 -DHTTP_PARSER_STRICT=0
-
CC?=gcc
AR?=ar
+CPPFLAGS += -I.
+CPPFLAGS_DEBUG = $(CPPFLAGS) -DHTTP_PARSER_STRICT=1 -DHTTP_PARSER_DEBUG=1
+CPPFLAGS_DEBUG += $(CPPFLAGS_DEBUG_EXTRA)
+CPPFLAGS_FAST = $(CPPFLAGS) -DHTTP_PARSER_STRICT=0 -DHTTP_PARSER_DEBUG=0
+CPPFLAGS_FAST += $(CPPFLAGS_FAST_EXTRA)
+
+CFLAGS += -Wall -Wextra -Werror
+CFLAGS_DEBUG = $(CFLAGS) -O0 -g $(CFLAGS_DEBUG_EXTRA)
+CFLAGS_FAST = $(CFLAGS) -O3 $(CFLAGS_FAST_EXTRA)
+
test: test_g test_fast
./test_g
./test_fast
test_g: http_parser_g.o test_g.o
- $(CC) $(OPT_DEBUG) http_parser_g.o test_g.o -o $@
+ $(CC) $(CFLAGS_DEBUG) $(LDFLAGS) http_parser_g.o test_g.o -o $@
test_g.o: test.c http_parser.h Makefile
- $(CC) $(OPT_DEBUG) -c test.c -o $@
-
-test.o: test.c http_parser.h Makefile
- $(CC) $(OPT_FAST) -c test.c -o $@
+ $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c test.c -o $@
http_parser_g.o: http_parser.c http_parser.h Makefile
- $(CC) $(OPT_DEBUG) -c http_parser.c -o $@
+ $(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c http_parser.c -o $@
-test-valgrind: test_g
- valgrind ./test_g
+test_fast: http_parser.o test.o http_parser.h
+ $(CC) $(CFLAGS_FAST) $(LDFLAGS) http_parser.o test.o -o $@
-http_parser.o: http_parser.c http_parser.h Makefile
- $(CC) $(OPT_FAST) -c http_parser.c
+test.o: test.c http_parser.h Makefile
+ $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c test.c -o $@
-test_fast: http_parser.o test.c http_parser.h
- $(CC) $(OPT_FAST) http_parser.o test.c -o $@
+http_parser.o: http_parser.c http_parser.h Makefile
+ $(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c http_parser.c
test-run-timed: test_fast
while(true) do time ./test_fast > /dev/null; done
+test-valgrind: test_g
+ valgrind ./test_g
+
package: http_parser.o
$(AR) rcs libhttp_parser.a http_parser.o
* Response status code
* Transfer-Encoding
* HTTP version
- * Request path, query string, fragment
+ * Request URL
* Message body
* notification `typedef int (*http_cb) (http_parser*);`
Callbacks: on_message_begin, on_headers_complete, on_message_complete.
* data `typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);`
- Callbacks: (requests only) on_path, on_query_string, on_uri, on_fragment,
+ Callbacks: (requests only) on_uri,
(common) on_header_field, on_header_value, on_body;
Callbacks must return 0 on success. Returning a non-zero value indicates
#endif
+#if HTTP_PARSER_DEBUG
+#define SET_ERRNO(e) \
+do { \
+ parser->http_errno = (e); \
+ parser->error_lineno = __LINE__; \
+} while (0)
+#else
+#define SET_ERRNO(e) \
+do { \
+ parser->http_errno = (e); \
+} while(0)
+#endif
+
+
#define CALLBACK2(FOR) \
do { \
if (settings->on_##FOR) { \
- if (0 != settings->on_##FOR(parser)) return (p - data); \
+ if (0 != settings->on_##FOR(parser)) { \
+ SET_ERRNO(HPE_CB_##FOR); \
+ return (p - data); \
+ } \
} \
} while (0)
FOR##_mark = p; \
} while (0)
-#define CALLBACK_NOCLEAR(FOR) \
+#define CALLBACK(FOR) \
do { \
if (FOR##_mark) { \
if (settings->on_##FOR) { \
FOR##_mark, \
p - FOR##_mark)) \
{ \
+ SET_ERRNO(HPE_CB_##FOR); \
return (p - data); \
} \
} \
+ FOR##_mark = NULL; \
} \
} while (0)
-#define CALLBACK(FOR) \
-do { \
- CALLBACK_NOCLEAR(FOR); \
- FOR##_mark = NULL; \
-} while (0)
-
-
#define PROXY_CONNECTION "proxy-connection"
#define CONNECTION "connection"
#define CONTENT_LENGTH "content-length"
, s_header_field
, s_header_value_start
, s_header_value
+ , s_header_value_lws
, s_header_almost_done
#define LF '\n'
#define LOWER(c) (unsigned char)(c | 0x20)
#define TOKEN(c) (tokens[(unsigned char)c])
-#define IS_ALPHA(c) ((c) >= 'a' && (c) <= 'z')
+#define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z')
#define IS_NUM(c) ((c) >= '0' && (c) <= '9')
#define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c))
#if HTTP_PARSER_STRICT
-# define STRICT_CHECK(cond) if (cond) goto error
+# define STRICT_CHECK(cond) \
+do { \
+ if (cond) { \
+ SET_ERRNO(HPE_STRICT); \
+ goto error; \
+ } \
+} while (0)
# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
#else
# define STRICT_CHECK(cond)
#endif
+/* Map errno values to strings for human-readable output */
+#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s },
+static struct {
+ const char *name;
+ const char *description;
+} http_strerror_tab[] = {
+ HTTP_ERRNO_MAP(HTTP_STRERROR_GEN)
+};
+#undef HTTP_STRERROR_GEN
+
+
size_t http_parser_execute (http_parser *parser,
const http_parser_settings *settings,
const char *data,
size_t len)
{
char c, ch;
+ int8_t unhex_val;
const char *p = data, *pe;
int64_t to_read;
-
- enum state state = (enum state) parser->state;
- enum header_states header_state = (enum header_states) parser->header_state;
+ enum state state;
+ enum header_states header_state;
uint64_t index = parser->index;
uint64_t nread = parser->nread;
+ /* We're in an error state. Don't bother doing anything. */
+ if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
+ return 0;
+ }
+
+ state = (enum state) parser->state;
+ header_state = (enum header_states) parser->header_state;
+
if (len == 0) {
switch (state) {
case s_body_identity_eof:
return 0;
default:
- return 1; // error
+ SET_ERRNO(HPE_INVALID_EOF_STATE);
+ return 1;
}
}
separated. */
const char *header_field_mark = 0;
const char *header_value_mark = 0;
- const char *fragment_mark = 0;
- const char *query_string_mark = 0;
- const char *path_mark = 0;
const char *url_mark = 0;
if (state == s_header_field)
header_field_mark = data;
if (state == s_header_value)
header_value_mark = data;
- if (state == s_req_fragment)
- fragment_mark = data;
- if (state == s_req_query_string)
- query_string_mark = data;
- if (state == s_req_path)
- path_mark = data;
if (state == s_req_path || state == s_req_schema || state == s_req_schema_slash
|| state == s_req_schema_slash_slash || state == s_req_port
|| state == s_req_query_string_start || state == s_req_query_string
if (PARSING_HEADER(state)) {
++nread;
/* Buffer overflow attack */
- if (nread > HTTP_MAX_HEADER_SIZE) goto error;
+ if (nread > HTTP_MAX_HEADER_SIZE) {
+ SET_ERRNO(HPE_HEADER_OVERFLOW);
+ goto error;
+ }
}
switch (state) {
/* this state is used after a 'Connection: close' message
* the parser will error out if it reads another message
*/
+ SET_ERRNO(HPE_CLOSED_CONNECTION);
goto error;
case s_start_req_or_res:
parser->type = HTTP_RESPONSE;
state = s_res_HT;
} else {
- if (ch != 'E') goto error;
+ if (ch != 'E') {
+ SET_ERRNO(HPE_INVALID_CONSTANT);
+ goto error;
+ }
+
parser->type = HTTP_REQUEST;
parser->method = HTTP_HEAD;
index = 2;
break;
default:
+ SET_ERRNO(HPE_INVALID_CONSTANT);
goto error;
}
break;
break;
case s_res_first_http_major:
- if (ch < '1' || ch > '9') goto error;
+ if (ch < '1' || ch > '9') {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
parser->http_major = ch - '0';
state = s_res_http_major;
break;
break;
}
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
parser->http_major *= 10;
parser->http_major += ch - '0';
- if (parser->http_major > 999) goto error;
+ if (parser->http_major > 999) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
break;
}
/* first digit of minor HTTP version */
case s_res_first_http_minor:
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
parser->http_minor = ch - '0';
state = s_res_http_minor;
break;
break;
}
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
parser->http_minor *= 10;
parser->http_minor += ch - '0';
- if (parser->http_minor > 999) goto error;
+ if (parser->http_minor > 999) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
break;
}
if (ch == ' ') {
break;
}
+
+ SET_ERRNO(HPE_INVALID_STATUS);
goto error;
}
parser->status_code = ch - '0';
state = s_header_field_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_STATUS);
goto error;
}
break;
parser->status_code *= 10;
parser->status_code += ch - '0';
- if (parser->status_code > 999) goto error;
+ if (parser->status_code > 999) {
+ SET_ERRNO(HPE_INVALID_STATUS);
+ goto error;
+ }
+
break;
}
CALLBACK2(message_begin);
- if (!IS_ALPHA(LOWER(ch))) goto error;
+ if (!IS_ALPHA(ch)) {
+ SET_ERRNO(HPE_INVALID_METHOD);
+ goto error;
+ }
start_req_method_assign:
parser->method = (enum http_method) 0;
case 'S': parser->method = HTTP_SUBSCRIBE; break;
case 'T': parser->method = HTTP_TRACE; break;
case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break;
- default: goto error;
+ default:
+ SET_ERRNO(HPE_INVALID_METHOD);
+ goto error;
}
state = s_req_method;
break;
case s_req_method:
{
- if (ch == '\0')
+ if (ch == '\0') {
+ SET_ERRNO(HPE_INVALID_METHOD);
goto error;
+ }
const char *matcher = method_strings[parser->method];
if (ch == ' ' && matcher[index] == '\0') {
parser->method = HTTP_CHECKOUT;
} else if (index == 2 && ch == 'P') {
parser->method = HTTP_COPY;
+ } else {
+ goto error;
}
} else if (parser->method == HTTP_MKCOL) {
if (index == 1 && ch == 'O') {
parser->method = HTTP_MSEARCH;
} else if (index == 2 && ch == 'A') {
parser->method = HTTP_MKACTIVITY;
+ } else {
+ goto error;
+ }
+ } else if (index == 1 && parser->method == HTTP_POST) {
+ if (ch == 'R') {
+ parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */
+ } else if (ch == 'U') {
+ parser->method = HTTP_PUT;
+ } else if (ch == 'A') {
+ parser->method = HTTP_PATCH;
+ } else {
+ goto error;
}
- } else if (index == 1 && parser->method == HTTP_POST && ch == 'R') {
- parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */
- } else if (index == 1 && parser->method == HTTP_POST && ch == 'U') {
- parser->method = HTTP_PUT;
- } else if (index == 1 && parser->method == HTTP_POST && ch == 'A') {
- parser->method = HTTP_PATCH;
} else if (index == 2 && parser->method == HTTP_UNLOCK && ch == 'S') {
parser->method = HTTP_UNSUBSCRIBE;
} else if (index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') {
parser->method = HTTP_PROPPATCH;
} else {
+ SET_ERRNO(HPE_INVALID_METHOD);
goto error;
}
if (ch == '/' || ch == '*') {
MARK(url);
- MARK(path);
state = s_req_path;
break;
}
- c = LOWER(ch);
-
/* Proxied requests are followed by scheme of an absolute URI (alpha).
* CONNECT is followed by a hostname, which begins with alphanum.
* All other methods are followed by '/' or '*' (handled above).
break;
}
+ SET_ERRNO(HPE_INVALID_URL);
goto error;
}
case s_req_schema:
{
- c = LOWER(ch);
-
- if (IS_ALPHA(c)) break;
+ if (IS_ALPHA(ch)) break;
if (ch == ':') {
state = s_req_schema_slash;
break;
}
+ SET_ERRNO(HPE_INVALID_URL);
goto error;
}
case s_req_host:
{
- c = LOWER(ch);
if (IS_HOST_CHAR(ch)) break;
switch (ch) {
case ':':
state = s_req_port;
break;
case '/':
- MARK(path);
state = s_req_path;
break;
case ' ':
state = s_req_query_string_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_HOST);
goto error;
}
break;
if (IS_NUM(ch)) break;
switch (ch) {
case '/':
- MARK(path);
state = s_req_path;
break;
case ' ':
state = s_req_query_string_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_PORT);
goto error;
}
break;
switch (ch) {
case ' ':
CALLBACK(url);
- CALLBACK(path);
state = s_req_http_start;
break;
case CR:
CALLBACK(url);
- CALLBACK(path);
parser->http_major = 0;
parser->http_minor = 9;
state = s_req_line_almost_done;
break;
case LF:
CALLBACK(url);
- CALLBACK(path);
parser->http_major = 0;
parser->http_minor = 9;
state = s_header_field_start;
break;
case '?':
- CALLBACK(path);
state = s_req_query_string_start;
break;
case '#':
- CALLBACK(path);
state = s_req_fragment_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_PATH);
goto error;
}
break;
case s_req_query_string_start:
{
if (IS_URL_CHAR(ch)) {
- MARK(query_string);
state = s_req_query_string;
break;
}
state = s_req_fragment_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_QUERY_STRING);
goto error;
}
break;
break;
case ' ':
CALLBACK(url);
- CALLBACK(query_string);
state = s_req_http_start;
break;
case CR:
CALLBACK(url);
- CALLBACK(query_string);
parser->http_major = 0;
parser->http_minor = 9;
state = s_req_line_almost_done;
break;
case LF:
CALLBACK(url);
- CALLBACK(query_string);
parser->http_major = 0;
parser->http_minor = 9;
state = s_header_field_start;
break;
case '#':
- CALLBACK(query_string);
state = s_req_fragment_start;
break;
default:
+ SET_ERRNO(HPE_INVALID_QUERY_STRING);
goto error;
}
break;
case s_req_fragment_start:
{
if (IS_URL_CHAR(ch)) {
- MARK(fragment);
state = s_req_fragment;
break;
}
state = s_header_field_start;
break;
case '?':
- MARK(fragment);
state = s_req_fragment;
break;
case '#':
break;
default:
+ SET_ERRNO(HPE_INVALID_FRAGMENT);
goto error;
}
break;
switch (ch) {
case ' ':
CALLBACK(url);
- CALLBACK(fragment);
state = s_req_http_start;
break;
case CR:
CALLBACK(url);
- CALLBACK(fragment);
parser->http_major = 0;
parser->http_minor = 9;
state = s_req_line_almost_done;
break;
case LF:
CALLBACK(url);
- CALLBACK(fragment);
parser->http_major = 0;
parser->http_minor = 9;
state = s_header_field_start;
case '#':
break;
default:
+ SET_ERRNO(HPE_INVALID_FRAGMENT);
goto error;
}
break;
case ' ':
break;
default:
+ SET_ERRNO(HPE_INVALID_CONSTANT);
goto error;
}
break;
/* first digit of major HTTP version */
case s_req_first_http_major:
- if (ch < '1' || ch > '9') goto error;
+ if (ch < '1' || ch > '9') {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
parser->http_major = ch - '0';
state = s_req_http_major;
break;
break;
}
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
parser->http_major *= 10;
parser->http_major += ch - '0';
- if (parser->http_major > 999) goto error;
+ if (parser->http_major > 999) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
break;
}
/* first digit of minor HTTP version */
case s_req_first_http_minor:
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
parser->http_minor = ch - '0';
state = s_req_http_minor;
break;
/* XXX allow spaces after digit? */
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
parser->http_minor *= 10;
parser->http_minor += ch - '0';
- if (parser->http_minor > 999) goto error;
+ if (parser->http_minor > 999) {
+ SET_ERRNO(HPE_INVALID_VERSION);
+ goto error;
+ }
+
break;
}
/* end of request line */
case s_req_line_almost_done:
{
- if (ch != LF) goto error;
+ if (ch != LF) {
+ SET_ERRNO(HPE_LF_EXPECTED);
+ goto error;
+ }
+
state = s_header_field_start;
break;
}
case s_header_field_start:
+ header_field_start:
{
if (ch == CR) {
state = s_headers_almost_done;
c = TOKEN(ch);
- if (!c) goto error;
+ if (!c) {
+ SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
+ goto error;
+ }
MARK(header_field);
break;
}
+ SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
goto error;
}
case s_header_value_start:
{
- if (ch == ' ') break;
+ if (ch == ' ' || ch == '\t') break;
MARK(header_value);
state = s_header_value;
index = 0;
- c = LOWER(ch);
-
if (ch == CR) {
CALLBACK(header_value);
header_state = h_general;
break;
}
+ c = LOWER(ch);
+
switch (header_state) {
case h_upgrade:
parser->flags |= F_UPGRADE;
break;
case h_content_length:
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
+ goto error;
+ }
+
parser->content_length = ch - '0';
break;
case s_header_value:
{
- c = LOWER(ch);
if (ch == CR) {
CALLBACK(header_value);
goto header_almost_done;
}
+ c = LOWER(ch);
+
switch (header_state) {
case h_general:
break;
case h_content_length:
if (ch == ' ') break;
- if (!IS_NUM(ch)) goto error;
+ if (!IS_NUM(ch)) {
+ SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
+ goto error;
+ }
+
parser->content_length *= 10;
parser->content_length += ch - '0';
break;
{
STRICT_CHECK(ch != LF);
- state = s_header_field_start;
+ state = s_header_value_lws;
switch (header_state) {
case h_connection_keep_alive:
break;
}
+ case s_header_value_lws:
+ {
+ if (ch == ' ' || ch == '\t')
+ state = s_header_value_start;
+ else
+ {
+ state = s_header_field_start;
+ goto header_field_start;
+ }
+ break;
+ }
+
case s_headers_almost_done:
headers_almost_done:
{
default:
parser->state = state;
+ SET_ERRNO(HPE_CB_headers_complete);
return p - data; /* Error */
}
}
/* Exit, the rest of the connect is in a different protocol. */
if (parser->upgrade) {
CALLBACK2(message_complete);
- return (p - data);
+ return (p - data) + 1;
}
if (parser->flags & F_SKIPBODY) {
assert(nread == 1);
assert(parser->flags & F_CHUNKED);
- c = unhex[(unsigned char)ch];
- if (c == -1) goto error;
- parser->content_length = c;
+ unhex_val = unhex[(unsigned char)ch];
+ if (unhex_val == -1) {
+ SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
+ goto error;
+ }
+
+ parser->content_length = unhex_val;
state = s_chunk_size;
break;
}
break;
}
- c = unhex[(unsigned char)ch];
+ unhex_val = unhex[(unsigned char)ch];
- if (c == -1) {
+ if (unhex_val == -1) {
if (ch == ';' || ch == ' ') {
state = s_chunk_parameters;
break;
}
+
+ SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
goto error;
}
parser->content_length *= 16;
- parser->content_length += c;
+ parser->content_length += unhex_val;
break;
}
default:
assert(0 && "unhandled state");
+ SET_ERRNO(HPE_INVALID_INTERNAL_STATE);
goto error;
}
}
- CALLBACK_NOCLEAR(header_field);
- CALLBACK_NOCLEAR(header_value);
- CALLBACK_NOCLEAR(fragment);
- CALLBACK_NOCLEAR(query_string);
- CALLBACK_NOCLEAR(path);
- CALLBACK_NOCLEAR(url);
+ CALLBACK(header_field);
+ CALLBACK(header_value);
+ CALLBACK(url);
parser->state = state;
parser->header_state = header_state;
return len;
error:
- parser->state = s_dead;
+ if (HTTP_PARSER_ERRNO(parser) == HPE_OK) {
+ SET_ERRNO(HPE_UNKNOWN);
+ }
+
return (p - data);
}
parser->upgrade = 0;
parser->flags = 0;
parser->method = 0;
+ parser->http_errno = 0;
+}
+
+const char *
+http_errno_name(enum http_errno err) {
+ assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0])));
+ return http_strerror_tab[err].name;
+}
+
+const char *
+http_errno_description(enum http_errno err) {
+ assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0])));
+ return http_strerror_tab[err].description;
}
--- /dev/null
+# This file is used with the GYP meta build system.
+# http://code.google.com/p/gyp/
+# To build try this:
+# svn co http://gyp.googlecode.com/svn/trunk gyp
+# ./gyp/gyp -f make --depth=`pwd` http_parser.gyp
+# ./out/Debug/test
+{
+ 'target_defaults': {
+ 'configurations': {
+ 'Debug': {
+ 'defines': [ 'DEBUG', '_DEBUG' ]
+ },
+ 'Release': {
+ 'defines': [ 'NDEBUG' ]
+ }
+ }
+ },
+
+ 'targets': [
+ {
+ 'target_name': 'http_parser',
+ 'type': 'static_library',
+ 'include_dirs': [ '.' ],
+ 'direct_dependent_settings': {
+ 'include_dirs': [ '.' ],
+ },
+ 'defines': [ 'HTTP_PARSER_STRICT=0' ],
+ 'sources': [ './http_parser.c', ],
+ 'conditions': [
+ ['OS=="win"', {
+ 'msvs_settings': {
+ 'VCCLCompilerTool': {
+ # Compile as C++. http_parser.c is actually C99, but C++ is
+ # close enough in this case.
+ 'CompileAs': 2,
+ },
+ },
+ }]
+ ],
+ },
+
+ {
+ 'target_name': 'test',
+ 'type': 'executable',
+ 'dependencies': [ 'http_parser' ],
+ 'sources': [ 'test.c' ]
+ }
+ ]
+}
+
#define HTTP_PARSER_VERSION_MINOR 0
#include <sys/types.h>
-#if defined(_WIN32) && !defined(__MINGW32__)
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(_MSC_VER)
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
# define HTTP_PARSER_STRICT 1
#endif
+/* Compile with -DHTTP_PARSER_DEBUG=1 to add extra debugging information to
+ * the error reporting facility.
+ */
+#ifndef HTTP_PARSER_DEBUG
+# define HTTP_PARSER_DEBUG 0
+#endif
+
/* Maximium header size allowed */
#define HTTP_MAX_HEADER_SIZE (80*1024)
typedef struct http_parser http_parser;
typedef struct http_parser_settings http_parser_settings;
+typedef struct http_parser_result http_parser_result;
/* Callbacks should return non-zero to indicate an error. The parser will
};
+/* Map for errno-related constants
+ *
+ * The provided argument should be a macro that takes 2 arguments.
+ */
+#define HTTP_ERRNO_MAP(XX) \
+ /* No error */ \
+ XX(OK, "success") \
+ \
+ /* Callback-related errors */ \
+ XX(CB_message_begin, "the on_message_begin callback failed") \
+ XX(CB_path, "the on_path callback failed") \
+ XX(CB_query_string, "the on_query_string callback failed") \
+ XX(CB_url, "the on_url callback failed") \
+ XX(CB_fragment, "the on_fragment callback failed") \
+ XX(CB_header_field, "the on_header_field callback failed") \
+ XX(CB_header_value, "the on_header_value callback failed") \
+ XX(CB_headers_complete, "the on_headers_complete callback failed") \
+ XX(CB_body, "the on_body callback failed") \
+ XX(CB_message_complete, "the on_message_complete callback failed") \
+ \
+ /* Parsing-related errors */ \
+ XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
+ XX(HEADER_OVERFLOW, \
+ "too many header bytes seen; overflow detected") \
+ XX(CLOSED_CONNECTION, \
+ "data received after completed connection: close message") \
+ XX(INVALID_VERSION, "invalid HTTP version") \
+ XX(INVALID_STATUS, "invalid HTTP status code") \
+ XX(INVALID_METHOD, "invalid HTTP method") \
+ XX(INVALID_URL, "invalid URL") \
+ XX(INVALID_HOST, "invalid host") \
+ XX(INVALID_PORT, "invalid port") \
+ XX(INVALID_PATH, "invalid path") \
+ XX(INVALID_QUERY_STRING, "invalid query string") \
+ XX(INVALID_FRAGMENT, "invalid fragment") \
+ XX(LF_EXPECTED, "LF character expected") \
+ XX(INVALID_HEADER_TOKEN, "invalid character in header") \
+ XX(INVALID_CONTENT_LENGTH, \
+ "invalid character in content-length header") \
+ XX(INVALID_CHUNK_SIZE, \
+ "invalid character in chunk size header") \
+ XX(INVALID_CONSTANT, "invalid constant string") \
+ XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
+ XX(STRICT, "strict mode assertion failed") \
+ XX(UNKNOWN, "an unknown error occurred")
+
+
+/* Define HPE_* values for each errno value above */
+#define HTTP_ERRNO_GEN(n, s) HPE_##n,
+enum http_errno {
+ HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
+};
+#undef HTTP_ERRNO_GEN
+
+
+/* Get an http_errno value from an http_parser */
+#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno)
+
+/* Get the line number that generated the current error */
+#if HTTP_PARSER_DEBUG
+#define HTTP_PARSER_ERRNO_LINE(p) ((p)->error_lineno)
+#else
+#define HTTP_PARSER_ERRNO_LINE(p) 0
+#endif
+
+
struct http_parser {
/** PRIVATE **/
unsigned char type : 2;
unsigned short http_minor;
unsigned short status_code; /* responses only */
unsigned char method; /* requests only */
+ unsigned char http_errno : 7;
/* 1 = Upgrade header was present and the parser has exited because of that.
* 0 = No upgrade header present.
* Should be checked when http_parser_execute() returns in addition to
* error checking.
*/
- char upgrade;
+ char upgrade : 1;
+
+#if HTTP_PARSER_DEBUG
+ uint32_t error_lineno;
+#endif
/** PUBLIC **/
void *data; /* A pointer to get hook to the "connection" or "socket" object */
struct http_parser_settings {
http_cb on_message_begin;
- http_data_cb on_path;
- http_data_cb on_query_string;
http_data_cb on_url;
- http_data_cb on_fragment;
http_data_cb on_header_field;
http_data_cb on_header_value;
http_cb on_headers_complete;
int http_should_keep_alive(http_parser *parser);
/* Returns a string version of the HTTP method. */
-const char *http_method_str(enum http_method);
+const char *http_method_str(enum http_method m);
+
+/* Return a string name of the given error */
+const char *http_errno_name(enum http_errno err);
+
+/* Return a string description of the given error */
+const char *http_errno_description(enum http_errno err);
#ifdef __cplusplus
}
enum http_parser_type type;
enum http_method method;
int status_code;
- char request_path[MAX_ELEMENT_SIZE];
char request_url[MAX_ELEMENT_SIZE];
- char fragment[MAX_ELEMENT_SIZE];
- char query_string[MAX_ELEMENT_SIZE];
char body[MAX_ELEMENT_SIZE];
size_t body_size;
int num_headers;
char headers [MAX_HEADERS][2][MAX_ELEMENT_SIZE];
int should_keep_alive;
- int upgrade;
+ const char *upgrade; // upgraded body
unsigned short http_major;
unsigned short http_minor;
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/test"
,.request_url= "/test"
,.num_headers= 3
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/favicon.ico"
,.request_url= "/favicon.ico"
,.num_headers= 8
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/dumbfuck"
,.request_url= "/dumbfuck"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "page=1"
- ,.fragment= "posts-17408"
- ,.request_path= "/forums/1/topics/2375"
/* XXX request url does include fragment? */
,.request_url= "/forums/1/topics/2375?page=1#posts-17408"
,.num_headers= 0
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/get_no_headers_no_body/world"
,.request_url= "/get_no_headers_no_body/world"
,.num_headers= 0
,.body= ""
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/get_one_header_no_body"
,.request_url= "/get_one_header_no_body"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 0
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/get_funky_content_length_body_hello"
,.request_url= "/get_funky_content_length_body_hello"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_POST
- ,.query_string= "q=search"
- ,.fragment= "hey"
- ,.request_path= "/post_identity_body_world"
,.request_url= "/post_identity_body_world?q=search#hey"
,.num_headers= 3
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_POST
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/post_chunked_all_your_base"
,.request_url= "/post_chunked_all_your_base"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_POST
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/two_chunks_mult_zero_end"
,.request_url= "/two_chunks_mult_zero_end"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_POST
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/chunked_w_trailing_headers"
,.request_url= "/chunked_w_trailing_headers"
,.num_headers= 3
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_POST
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/chunked_w_bullshit_after_length"
,.request_url= "/chunked_w_bullshit_after_length"
,.num_headers= 1
,.headers=
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "foo=\"bar\""
- ,.fragment= ""
- ,.request_path= "/with_\"stupid\"_quotes"
,.request_url= "/with_\"stupid\"_quotes?foo=\"bar\""
,.num_headers= 0
,.headers= { }
,.http_major= 1
,.http_minor= 0
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/test"
,.request_url= "/test"
,.num_headers= 3
,.headers= { { "Host", "0.0.0.0:5000" }
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "foo=bar?baz"
- ,.fragment= ""
- ,.request_path= "/test.cgi"
,.request_url= "/test.cgi?foo=bar?baz"
,.num_headers= 0
,.headers= {}
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/test"
,.request_url= "/test"
,.num_headers= 0
,.headers= { }
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\n"
"Origin: http://example.com\r\n"
"\r\n"
+ "Hot diggity dogg"
,.should_keep_alive= TRUE
,.message_complete_on_eof= FALSE
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/demo"
,.request_url= "/demo"
,.num_headers= 7
- ,.upgrade=1
+ ,.upgrade="Hot diggity dogg"
,.headers= { { "Host", "example.com" }
, { "Connection", "Upgrade" }
, { "Sec-WebSocket-Key2", "12998 5 Y3 1 .P00" }
"User-agent: Mozilla/1.1N\r\n"
"Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
"\r\n"
+ "some data\r\n"
+ "and yet even more data"
,.should_keep_alive= FALSE
,.message_complete_on_eof= FALSE
,.http_major= 1
,.http_minor= 0
,.method= HTTP_CONNECT
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= ""
,.request_url= "0-home0.netscape.com:443"
,.num_headers= 2
- ,.upgrade=1
+ ,.upgrade="some data\r\nand yet even more data"
,.headers= { { "User-agent", "Mozilla/1.1N" }
, { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
}
,.http_major= 1
,.http_minor= 1
,.method= HTTP_REPORT
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/test"
,.request_url= "/test"
,.num_headers= 0
,.headers= {}
,.http_major= 0
,.http_minor= 9
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/"
,.request_url= "/"
,.num_headers= 0
,.headers= {}
,.http_major= 1
,.http_minor= 1
,.method= HTTP_MSEARCH
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "*"
,.request_url= "*"
,.num_headers= 3
,.headers= { { "HOST", "239.255.255.250:1900" }
,.body= ""
}
+#define LINE_FOLDING_IN_HEADER 20
+, {.name= "line folding in header value"
+ ,.type= HTTP_REQUEST
+ ,.raw= "GET / HTTP/1.1\r\n"
+ "Line1: abc\r\n"
+ "\tdef\r\n"
+ " ghi\r\n"
+ "\t\tjkl\r\n"
+ " mno \r\n"
+ "\t \tqrs\r\n"
+ "Line2: \t line2\t\r\n"
+ "\r\n"
+ ,.should_keep_alive= TRUE
+ ,.message_complete_on_eof= FALSE
+ ,.http_major= 1
+ ,.http_minor= 1
+ ,.method= HTTP_GET
+ ,.request_url= "/"
+ ,.num_headers= 2
+ ,.headers= { { "Line1", "abcdefghijklmno qrs" }
+ , { "Line2", "line2\t" }
+ }
+ ,.body= ""
+ }
+
+
#define QUERY_TERMINATED_HOST 21
, {.name= "host terminated by a query string"
,.type= HTTP_REQUEST
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "hail=all"
- ,.fragment= ""
- ,.request_path= ""
,.request_url= "http://hypnotoad.org?hail=all"
,.num_headers= 0
,.headers= { }
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "hail=all"
- ,.fragment= ""
- ,.request_path= ""
,.request_url= "http://hypnotoad.org:1234?hail=all"
,.num_headers= 0
,.headers= { }
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= ""
,.request_url= "http://hypnotoad.org:1234"
,.num_headers= 0
,.headers= { }
,.http_major= 1
,.http_minor= 1
,.method= HTTP_GET
- ,.query_string= "q=1"
- ,.fragment= "narf"
- ,.request_path= "/δ¶/δt/pope"
,.request_url= "/δ¶/δt/pope?q=1#narf"
,.num_headers= 1
,.headers= { {"Host", "github.com" }
,.http_major= 1
,.http_minor= 0
,.method= HTTP_CONNECT
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= ""
,.request_url= "home_0.netscape.com:443"
,.num_headers= 2
- ,.upgrade=1
+ ,.upgrade=""
,.headers= { { "User-agent", "Mozilla/1.1N" }
, { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
}
,.http_major= 1
,.http_minor= 1
,.method= HTTP_PATCH
- ,.query_string= ""
- ,.fragment= ""
- ,.request_path= "/file.txt"
,.request_url= "/file.txt"
,.num_headers= 4
- ,.upgrade=0
,.headers= { { "Host", "www.example.com" }
, { "Content-Type", "application/example" }
, { "If-Match", "\"e0023aa4e\"" }
,.body= "cccccccccc"
}
+#define CONNECT_CAPS_REQUEST 27
+, {.name = "connect caps request"
+ ,.type= HTTP_REQUEST
+ ,.raw= "CONNECT HOME0.NETSCAPE.COM:443 HTTP/1.0\r\n"
+ "User-agent: Mozilla/1.1N\r\n"
+ "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
+ "\r\n"
+ ,.should_keep_alive= FALSE
+ ,.message_complete_on_eof= FALSE
+ ,.http_major= 1
+ ,.http_minor= 0
+ ,.method= HTTP_CONNECT
+ ,.request_url= "HOME0.NETSCAPE.COM:443"
+ ,.num_headers= 2
+ ,.upgrade=""
+ ,.headers= { { "User-agent", "Mozilla/1.1N" }
+ , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
+ }
+ ,.body= ""
+ }
+
, {.name= NULL } /* sentinel */
};
};
int
-request_path_cb (http_parser *p, const char *buf, size_t len)
-{
- assert(p == parser);
- strncat(messages[num_messages].request_path, buf, len);
- return 0;
-}
-
-int
request_url_cb (http_parser *p, const char *buf, size_t len)
{
assert(p == parser);
}
int
-query_string_cb (http_parser *p, const char *buf, size_t len)
-{
- assert(p == parser);
- strncat(messages[num_messages].query_string, buf, len);
- return 0;
-}
-
-int
-fragment_cb (http_parser *p, const char *buf, size_t len)
-{
- assert(p == parser);
- strncat(messages[num_messages].fragment, buf, len);
- return 0;
-}
-
-int
header_field_cb (http_parser *p, const char *buf, size_t len)
{
assert(p == parser);
{.on_message_begin = message_begin_cb
,.on_header_field = header_field_cb
,.on_header_value = header_value_cb
- ,.on_path = request_path_cb
,.on_url = request_url_cb
- ,.on_fragment = fragment_cb
- ,.on_query_string = query_string_cb
,.on_body = body_cb
,.on_headers_complete = headers_complete_cb
,.on_message_complete = message_complete_cb
{.on_message_begin = message_begin_cb
,.on_header_field = header_field_cb
,.on_header_value = header_value_cb
- ,.on_path = request_path_cb
,.on_url = request_url_cb
- ,.on_fragment = fragment_cb
- ,.on_query_string = query_string_cb
,.on_body = count_body_cb
,.on_headers_complete = headers_complete_cb
,.on_message_complete = message_complete_cb
{.on_message_begin = 0
,.on_header_field = 0
,.on_header_value = 0
- ,.on_path = 0
,.on_url = 0
- ,.on_fragment = 0
- ,.on_query_string = 0
,.on_body = 0
,.on_headers_complete = 0
,.on_message_complete = 0
const char *prop,
const char *expected,
const char *found) {
- if (0 != strcmp(expected, found)) {
+ if ((expected == NULL) != (found == NULL)) {
+ printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
+ printf("expected %s\n", (expected == NULL) ? "NULL" : expected);
+ printf(" found %s\n", (found == NULL) ? "NULL" : found);
+ return 0;
+ }
+ if (expected != NULL && 0 != strcmp(expected, found)) {
printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
printf("expected '%s'\n", expected);
printf(" found '%s'\n", found);
assert(m->message_complete_cb_called);
- MESSAGE_CHECK_STR_EQ(expected, m, request_path);
- MESSAGE_CHECK_STR_EQ(expected, m, query_string);
- MESSAGE_CHECK_STR_EQ(expected, m, fragment);
MESSAGE_CHECK_STR_EQ(expected, m, request_url);
if (expected->body_size) {
MESSAGE_CHECK_NUM_EQ(expected, m, body_size);
if (!r) return 0;
}
+ MESSAGE_CHECK_STR_EQ(expected, m, upgrade);
+
return 1;
}
+/* Given a sequence of varargs messages, return the number of them that the
+ * parser should successfully parse, taking into account that upgraded
+ * messages prevent all subsequent messages from being parsed.
+ */
+size_t
+count_parsed_messages(const size_t nmsgs, ...) {
+ size_t i;
+ va_list ap;
+
+ va_start(ap, nmsgs);
+
+ for (i = 0; i < nmsgs; i++) {
+ struct message *m = va_arg(ap, struct message *);
+
+ if (m->upgrade) {
+ va_end(ap);
+ return i + 1;
+ }
+ }
+
+ va_end(ap);
+ return nmsgs;
+}
+
+/* Given a sequence of bytes and the number of these that we were able to
+ * parse, verify that upgrade bodies are correct.
+ */
+void
+upgrade_message_fix(char *body, const size_t nread, const size_t nmsgs, ...) {
+ va_list ap;
+ size_t i;
+ size_t off = 0;
+
+ va_start(ap, nmsgs);
+
+ for (i = 0; i < nmsgs; i++) {
+ struct message *m = va_arg(ap, struct message *);
+
+ off += strlen(m->raw);
+
+ if (m->upgrade) {
+ off -= strlen(m->upgrade);
+
+ /* Check the portion of the response after its specified upgrade */
+ if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
+ exit(1);
+ }
+
+ /* Fix up the response so that message_eq() will verify the beginning
+ * of the upgrade */
+ *(body + nread + strlen(m->upgrade)) = '\0';
+ messages[num_messages -1 ].upgrade = body + nread;
+
+ va_end(ap);
+ return;
+ }
+ }
+
+ va_end(ap);
+ printf("\n\n*** Error: expected a message with upgrade ***\n");
+
+ exit(1);
+}
+
static void
print_error (const char *raw, size_t error_location)
{
- fprintf(stderr, "\n*** parse error ***\n\n");
+ fprintf(stderr, "\n*** %s:%d -- %s ***\n\n",
+ "http_parser.c", HTTP_PARSER_ERRNO_LINE(parser),
+ http_errno_description(HTTP_PARSER_ERRNO(parser)));
int this_line = 0, char_len = 0;
size_t i, j, len = strlen(raw), error_location_line = 0;
if (msg1len) {
read = parse(msg1, msg1len);
- if (message->upgrade && parser->upgrade) goto test;
+ if (message->upgrade && parser->upgrade) {
+ messages[num_messages - 1].upgrade = msg1 + read;
+ goto test;
+ }
if (read != msg1len) {
print_error(msg1, read);
read = parse(msg2, msg2len);
- if (message->upgrade && parser->upgrade) goto test;
+ if (message->upgrade && parser->upgrade) {
+ messages[num_messages - 1].upgrade = msg2 + read;
+ goto test;
+ }
if (read != msg2len) {
print_error(msg2, read);
read = parse(NULL, 0);
- if (message->upgrade && parser->upgrade) goto test;
-
if (read != 0) {
print_error(message->raw, read);
exit(1);
}
void
-test_simple (const char *buf, int should_pass)
+test_simple (const char *buf, enum http_errno err_expected)
{
parser_init(HTTP_REQUEST);
size_t parsed;
int pass;
+ enum http_errno err;
+
parsed = parse(buf, strlen(buf));
pass = (parsed == strlen(buf));
+ err = HTTP_PARSER_ERRNO(parser);
parsed = parse(NULL, 0);
pass &= (parsed == 0);
parser_free();
- if (pass != should_pass) {
- fprintf(stderr, "\n*** test_simple expected %s ***\n\n%s", should_pass ? "success" : "error", buf);
+ /* In strict mode, allow us to pass with an unexpected HPE_STRICT as
+ * long as the caller isn't expecting success.
+ */
+#if HTTP_PARSER_STRICT
+ if (err_expected != err && err_expected != HPE_OK && err != HPE_STRICT) {
+#else
+ if (err_expected != err) {
+#endif
+ fprintf(stderr, "\n*** test_simple expected %s, but saw %s ***\n\n%s\n",
+ http_errno_name(err_expected), http_errno_name(err), buf);
exit(1);
}
}
assert(parsed == strlen(buf));
buf = "header-key: header-value\r\n";
+ size_t buflen = strlen(buf);
+
int i;
for (i = 0; i < 10000; i++) {
- if (http_parser_execute(&parser, &settings_null, buf, strlen(buf)) != strlen(buf)) {
+ parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
+ if (parsed != buflen) {
//fprintf(stderr, "error found on iter %d\n", i);
+ assert(HTTP_PARSER_ERRNO(&parser) == HPE_HEADER_OVERFLOW);
return;
}
}
void
test_multiple3 (const struct message *r1, const struct message *r2, const struct message *r3)
{
- int message_count = 1;
- if (!r1->upgrade) {
- message_count++;
- if (!r2->upgrade) message_count++;
- }
- int has_upgrade = (message_count < 3 || r3->upgrade);
+ int message_count = count_parsed_messages(3, r1, r2, r3);
char total[ strlen(r1->raw)
+ strlen(r2->raw)
read = parse(total, strlen(total));
- if (has_upgrade && parser->upgrade) goto test;
+ if (parser->upgrade) {
+ upgrade_message_fix(total, read, 3, r1, r2, r3);
+ goto test;
+ }
if (read != strlen(total)) {
print_error(total, read);
read = parse(NULL, 0);
- if (has_upgrade && parser->upgrade) goto test;
-
if (read != 0) {
print_error(total, read);
exit(1);
}
if (!message_eq(0, r1)) exit(1);
- if (message_count > 1) {
- if (!message_eq(1, r2)) exit(1);
- if (message_count > 2) {
- if (!message_eq(2, r3)) exit(1);
- }
- }
+ if (message_count > 1 && !message_eq(1, r2)) exit(1);
+ if (message_count > 2 && !message_eq(2, r3)) exit(1);
parser_free();
}
int ops = 0 ;
size_t buf1_len, buf2_len, buf3_len;
+ int message_count = count_parsed_messages(3, r1, r2, r3);
int i,j,type_both;
for (type_both = 0; type_both < 2; type_both ++ ) {
read = parse(buf1, buf1_len);
- if (r3->upgrade && parser->upgrade) goto test;
+ if (parser->upgrade) goto test;
if (read != buf1_len) {
print_error(buf1, read);
goto error;
}
- read = parse(buf2, buf2_len);
+ read += parse(buf2, buf2_len);
- if (r3->upgrade && parser->upgrade) goto test;
+ if (parser->upgrade) goto test;
- if (read != buf2_len) {
+ if (read != buf1_len + buf2_len) {
print_error(buf2, read);
goto error;
}
- read = parse(buf3, buf3_len);
+ read += parse(buf3, buf3_len);
- if (r3->upgrade && parser->upgrade) goto test;
+ if (parser->upgrade) goto test;
- if (read != buf3_len) {
+ if (read != buf1_len + buf2_len + buf3_len) {
print_error(buf3, read);
goto error;
}
parse(NULL, 0);
test:
+ if (parser->upgrade) {
+ upgrade_message_fix(total, read, 3, r1, r2, r3);
+ }
- if (3 != num_messages) {
- fprintf(stderr, "\n\nParser didn't see 3 messages only %d\n", num_messages);
+ if (message_count != num_messages) {
+ fprintf(stderr, "\n\nParser didn't see %d messages only %d\n",
+ message_count, num_messages);
goto error;
}
goto error;
}
- if (!message_eq(1, r2)) {
+ if (message_count > 1 && !message_eq(1, r2)) {
fprintf(stderr, "\n\nError matching messages[1] in test_scan.\n");
goto error;
}
- if (!message_eq(2, r3)) {
+ if (message_count > 2 && !message_eq(2, r3)) {
fprintf(stderr, "\n\nError matching messages[2] in test_scan.\n");
goto error;
}
/// REQUESTS
- test_simple("hello world", 0);
- test_simple("GET / HTP/1.1\r\n\r\n", 0);
+ test_simple("hello world", HPE_INVALID_METHOD);
+ test_simple("GET / HTP/1.1\r\n\r\n", HPE_INVALID_VERSION);
- test_simple("ASDF / HTTP/1.1\r\n\r\n", 0);
- test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", 0);
- test_simple("GETA / HTTP/1.1\r\n\r\n", 0);
+ test_simple("ASDF / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
+ test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
+ test_simple("GETA / HTTP/1.1\r\n\r\n", HPE_INVALID_METHOD);
// Well-formed but incomplete
test_simple("GET / HTTP/1.1\r\n"
"Content-Length: 6\r\n"
"\r\n"
"fooba",
- 0);
+ HPE_OK);
static const char *all_methods[] = {
"DELETE",
"PROPFIND",
"PROPPATCH",
"UNLOCK",
+ "REPORT",
+ "MKACTIVITY",
+ "CHECKOUT",
+ "MERGE",
+ "M-SEARCH",
+ "NOTIFY",
+ "SUBSCRIBE",
+ "UNSUBSCRIBE",
+ "PATCH",
0 };
const char **this_method;
for (this_method = all_methods; *this_method; this_method++) {
char buf[200];
sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
- test_simple(buf, 1);
+ test_simple(buf, HPE_OK);
+ }
+
+ static const char *bad_methods[] = {
+ "C******",
+ "M****",
+ 0 };
+ for (this_method = bad_methods; *this_method; this_method++) {
+ char buf[200];
+ sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
+ test_simple(buf, HPE_UNKNOWN);
}
const char *dumbfuck2 =
"\tRA==\r\n"
"\t-----END CERTIFICATE-----\r\n"
"\r\n";
- test_simple(dumbfuck2, 0);
+ test_simple(dumbfuck2, HPE_OK);
#if 0
// NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body
using namespace v8;
static Persistent<String> on_message_begin_sym;
-static Persistent<String> on_path_sym;
-static Persistent<String> on_query_string_sym;
static Persistent<String> on_url_sym;
-static Persistent<String> on_fragment_sym;
static Persistent<String> on_header_field_sym;
static Persistent<String> on_header_value_sym;
static Persistent<String> on_headers_complete_sym;
DEFINE_HTTP_CB(on_message_begin)
DEFINE_HTTP_CB(on_message_complete)
- DEFINE_HTTP_DATA_CB(on_path)
DEFINE_HTTP_DATA_CB(on_url)
- DEFINE_HTTP_DATA_CB(on_fragment)
- DEFINE_HTTP_DATA_CB(on_query_string)
DEFINE_HTTP_DATA_CB(on_header_field)
DEFINE_HTTP_DATA_CB(on_header_value)
DEFINE_HTTP_DATA_CB(on_body)
target->Set(String::NewSymbol("HTTPParser"), t->GetFunction());
on_message_begin_sym = NODE_PSYMBOL("onMessageBegin");
- on_path_sym = NODE_PSYMBOL("onPath");
- on_query_string_sym = NODE_PSYMBOL("onQueryString");
on_url_sym = NODE_PSYMBOL("onURL");
- on_fragment_sym = NODE_PSYMBOL("onFragment");
on_header_field_sym = NODE_PSYMBOL("onHeaderField");
on_header_value_sym = NODE_PSYMBOL("onHeaderValue");
on_headers_complete_sym = NODE_PSYMBOL("onHeadersComplete");
upgrade_sym = NODE_PSYMBOL("upgrade");
settings.on_message_begin = Parser::on_message_begin;
- settings.on_path = Parser::on_path;
- settings.on_query_string = Parser::on_query_string;
settings.on_url = Parser::on_url;
- settings.on_fragment = Parser::on_fragment;
settings.on_header_field = Parser::on_header_field;
settings.on_header_value = Parser::on_header_value;
settings.on_headers_complete = Parser::on_headers_complete;
projects / platform / upstream / nodejs.git / commitdiff