lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Upgrade http-parser 

Now at version 6f72c780f0a237a775150a9963bcdf5299685cde
v0.7.4-release
Ryan Dahl 15 years ago
parent
765f0cdece
commit
54d4efd44b
8 changed files with 195 additions and 159 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      deps/http_parser/.gitignore
  2. 32
      deps/http_parser/README.md
  3. 173
      deps/http_parser/http_parser.c
  4. 41
      deps/http_parser/http_parser.h
  5. 49
      deps/http_parser/test.c
  6. 16
      src/node_http.cc
  7. 10
      src/node_http.h
  8. 30
      src/node_http_parser.cc

3
deps/http_parser/.gitignore
View File

@ -0,0 +1,3 @@
tags
*.o
test

32
deps/http_parser/README.md
View File

@ -4,8 +4,9 @@ HTTP Parser
This is a parser for HTTP messages written in C. It parses both requests
and responses. The parser is designed to be used in performance HTTP
applications. It does not make any allocations, it does not buffer data, and
it can be interrupted at anytime. It only requires about 136 bytes of data
per message stream (in a web server that is per connection).
it can be interrupted at anytime. Depending on your architecture, it only
requires between 100 and 200 bytes of data per message stream (in a web
server that is per connection).
Features:
@ -31,12 +32,14 @@ One `http_parser` object is used per TCP connection. Initialize the struct
using `http_parser_init()` and set the callbacks. That might look something
like this for a request parser:
http_parser_settings settings;
settings.on_path = my_path_callback;
settings.on_header_field = my_header_field_callback;
/* ... */
settings.data = my_socket;
http_parser *parser = malloc(sizeof(http_parser));
http_parser_init(parser, HTTP_REQUEST);
parser->on_path = my_path_callback;
parser->on_header_field = my_header_field_callback;
/* ... */
parser->data = my_socket;
When data is received on the socket execute the parser and check for errors.
@ -54,7 +57,7 @@ When data is received on the socket execute the parser and check for errors.
* Note we pass the recved==0 to http_parse_requests to signal
* that EOF has been recieved.
*/
nparsed = http_parser_execute(parser, buf, recved);
nparsed = http_parser_execute(parser, settings, buf, recved);
if (nparsed != recved) {
/* Handle error. Usually just close the connection. */
@ -63,13 +66,13 @@ When data is received on the socket execute the parser and check for errors.
HTTP needs to know where the end of the stream is. For example, sometimes
servers send responses without Content-Length and expect the client to
consume input (for the body) until EOF. To tell http_parser about EOF, give
`0` as the third parameter to `http_parser_execute()`. Callbacks and errors
`0` as the forth parameter to `http_parser_execute()`. Callbacks and errors
can still be encountered during an EOF, so one must still be prepared
to receive them.
Scalar valued message information such as `status_code`, `method`, and the
HTTP version are stored in the parser structure. This data is only
temporarlly stored in `http_parser` and gets reset on each new message. If
temporally stored in `http_parser` and gets reset on each new message. If
this information is needed later, copy it out of the structure during the
`headers_complete` callback.
@ -85,10 +88,10 @@ parser, for example, would not want such a feature.
Callbacks
---------
During the `http_parser_execute()` call, the callbacks set in `http_parser`
will be executed. The parser maintains state and never looks behind, so
buffering the data is not necessary. If you need to save certain data for
later usage, you can do that from the callbacks.
During the `http_parser_execute()` call, the callbacks set in
`http_parser_settings` will be executed. The parser maintains state and
never looks behind, so buffering the data is not necessary. If you need to
save certain data for later usage, you can do that from the callbacks.
There are two types of callbacks:
@ -98,6 +101,9 @@ There are two types of callbacks:
Callbacks: (requests only) on_path, on_query_string, on_uri, on_fragment,
(common) on_header_field, on_header_value, on_body;
Callbacks must return 0 on success. Returning a non-zero value indicates
error to the parser, making it exit immediately.
In case you parse HTTP message in chunks (i.e. `read()` request line
from socket, parse, read half headers, parse, etc) your data callbacks
may be called more than once. Http-parser guarantees that data pointer is only

173
deps/http_parser/http_parser.c
View File

@ -24,88 +24,65 @@
#include <http_parser.h>
#include <stdint.h>
#include <assert.h>
#include <string.h> /* strncmp */
#include <stddef.h>
#ifndef NULL
# define NULL ((void*)0)
#endif
#ifndef MIN
# define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
#define MAX_FIELD_SIZE (80*1024)
#define CALLBACK2(FOR) \
do { \
if (settings.on_##FOR) { \
if (0 != settings.on_##FOR(parser)) return (p - data); \
} \
} while (0)
#define MARK(FOR) \
do { \
parser->FOR##_mark = p; \
parser->FOR##_size = 0; \
} while (0)
#define CALLBACK(FOR) \
do { \
if (0 != FOR##_callback(parser, p)) return (p - data); \
parser->FOR##_mark = NULL; \
} while (0)
#define CALLBACK_NOCLEAR(FOR) \
do { \
if (0 != FOR##_callback(parser, p)) return (p - data); \
if (parser->FOR##_mark) { \
parser->FOR##_size += p - parser->FOR##_mark; \
if (parser->FOR##_size > MAX_FIELD_SIZE) return (p - data); \
if (settings.on_##FOR) { \
if (0 != settings.on_##FOR(parser, \
parser->FOR##_mark, \
p - parser->FOR##_mark)) \
{ \
return (p - data); \
} \
} \
} \
} while (0)
#define CALLBACK2(FOR) \
#define CALLBACK(FOR) \
do { \
if (0 != FOR##_callback(parser)) return (p - data); \
CALLBACK_NOCLEAR(FOR); \
parser->FOR##_mark = NULL; \
} while (0)
#define DEFINE_CALLBACK(FOR) \
static inline int FOR##_callback (http_parser *parser, const char *p) \
{ \
if (!parser->FOR##_mark) return 0; \
assert(parser->FOR##_mark); \
const char *mark = parser->FOR##_mark; \
parser->FOR##_size += p - mark; \
if (parser->FOR##_size > MAX_FIELD_SIZE) return -1; \
int r = 0; \
if (parser->on_##FOR) r = parser->on_##FOR(parser, mark, p - mark); \
return r; \
}
DEFINE_CALLBACK(url)
DEFINE_CALLBACK(path)
DEFINE_CALLBACK(query_string)
DEFINE_CALLBACK(fragment)
DEFINE_CALLBACK(header_field)
DEFINE_CALLBACK(header_value)
static inline int headers_complete_callback (http_parser *parser)
{
if (parser->on_headers_complete == NULL) return 0;
return parser->on_headers_complete(parser);
}
static inline int message_begin_callback (http_parser *parser)
{
if (parser->on_message_begin == NULL) return 0;
return parser->on_message_begin(parser);
}
static inline int message_complete_callback (http_parser *parser)
{
if (parser->on_message_complete == NULL) return 0;
return parser->on_message_complete(parser);
}
#define PROXY_CONNECTION "proxy-connection"
#define CONNECTION "connection"
#define CONTENT_LENGTH "content-length"
#define TRANSFER_ENCODING "transfer-encoding"
#define CHUNKED "chunked"
#define KEEP_ALIVE "keep-alive"
#define CLOSE "close"
static const unsigned char lowcase[] =
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0" "0123456789\0\0\0\0\0\0"
@ -116,6 +93,7 @@ static const unsigned char lowcase[] =
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
static const int unhex[] =
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
@ -128,6 +106,7 @@ static const int unhex[] =
};
static const uint32_t usual[] = {
0xffffdbfe, /* 1111 1111 1111 1111 1101 1011 1111 1110 */
@ -148,6 +127,7 @@ static const uint32_t usual[] = {
#define USUAL(c) (usual[c >> 5] & (1 << (c & 0x1f)))
enum state
{ s_dead = 1 /* important that this is > 0 */
@ -216,6 +196,7 @@ enum state
#define PARSING_HEADER(state) (state <= s_headers_almost_done)
enum header_states
{ h_general = 0
, h_C
@ -240,6 +221,7 @@ enum header_states
, h_connection_close
};
enum flags
{ F_CHUNKED = 1 << 0
, F_CONNECTION_KEEP_ALIVE = 1 << 1
@ -247,12 +229,15 @@ enum flags
, F_TRAILING = 1 << 3
};
#define CR '\r'
#define LF '\n'
#define LOWER(c) (unsigned char)(c | 0x20)
#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
#if HTTP_PARSER_STRICT
# define STRICT_CHECK(cond) if (cond) goto error
# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
@ -261,7 +246,38 @@ enum flags
# define NEW_MESSAGE() start_state
#endif
#define ngx_str3_cmp(m, c0, c1, c2) \
m[0] == c0 && m[1] == c1 && m[2] == c2
#define ngx_str3Ocmp(m, c0, c1, c2, c3) \
m[0] == c0 && m[2] == c2 && m[3] == c3
#define ngx_str4cmp(m, c0, c1, c2, c3) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3
#define ngx_str5cmp(m, c0, c1, c2, c3, c4) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 && m[4] == c4
#define ngx_str6cmp(m, c0, c1, c2, c3, c4, c5) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 \
&& m[4] == c4 && m[5] == c5
#define ngx_str7_cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 \
&& m[4] == c4 && m[5] == c5 && m[6] == c6
#define ngx_str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 \
&& m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7
#define ngx_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8) \
m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 \
&& m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7 && m[8] == c8
size_t http_parser_execute (http_parser *parser,
http_parser_settings settings,
const char *data,
size_t len)
{
@ -269,8 +285,8 @@ size_t http_parser_execute (http_parser *parser,
const char *p = data, *pe;
ssize_t to_read;
enum state state = parser->state;
enum header_states header_state = parser->header_state;
enum state state = (enum state) parser->state;
enum header_states header_state = (enum header_states) parser->header_state;
size_t index = parser->index;
size_t nread = parser->nread;
@ -462,7 +478,7 @@ size_t http_parser_execute (http_parser *parser,
if (ch < 'A' || 'Z' < ch) goto error;
parser->method = 0;
parser->method = (enum http_method) 0;
index = 0;
parser->buffer[0] = ch;
state = s_req_method;
@ -474,16 +490,14 @@ size_t http_parser_execute (http_parser *parser,
assert(index+1 < HTTP_PARSER_MAX_METHOD_LEN);
parser->buffer[index+1] = '\0';
/* TODO Instead of using strncmp() use NGINX's ngx_str3Ocmp() */
switch (index+1) {
case 3:
if (strncmp(parser->buffer, "GET", 3) == 0) {
if (ngx_str3_cmp(parser->buffer, 'G', 'E', 'T')) {
parser->method = HTTP_GET;
break;
}
if (strncmp(parser->buffer, "PUT", 3) == 0) {
if (ngx_str3_cmp(parser->buffer, 'P', 'U', 'T')) {
parser->method = HTTP_PUT;
break;
}
@ -491,22 +505,22 @@ size_t http_parser_execute (http_parser *parser,
break;
case 4:
if (strncmp(parser->buffer, "POST", 4) == 0) {
if (ngx_str4cmp(parser->buffer, 'P', 'O', 'S', 'T')) {
parser->method = HTTP_POST;
break;
}
if (strncmp(parser->buffer, "HEAD", 4) == 0) {
if (ngx_str4cmp(parser->buffer, 'H', 'E', 'A', 'D')) {
parser->method = HTTP_HEAD;
break;
}
if (strncmp(parser->buffer, "COPY", 4) == 0) {
if (ngx_str4cmp(parser->buffer, 'C', 'O', 'P', 'Y')) {
parser->method = HTTP_COPY;
break;
}
if (strncmp(parser->buffer, "MOVE", 4) == 0) {
if (ngx_str4cmp(parser->buffer, 'M', 'O', 'V', 'E')) {
parser->method = HTTP_MOVE;
break;
}
@ -514,12 +528,12 @@ size_t http_parser_execute (http_parser *parser,
break;
case 5:
if (strncmp(parser->buffer, "MKCOL", 5) == 0) {
if (ngx_str5cmp(parser->buffer, 'M', 'K', 'C', 'O', 'L')) {
parser->method = HTTP_MKCOL;
break;
}
if (strncmp(parser->buffer, "TRACE", 5) == 0) {
if (ngx_str5cmp(parser->buffer, 'T', 'R', 'A', 'C', 'E')) {
parser->method = HTTP_TRACE;
break;
}
@ -527,12 +541,12 @@ size_t http_parser_execute (http_parser *parser,
break;
case 6:
if (strncmp(parser->buffer, "DELETE", 6) == 0) {
if (ngx_str6cmp(parser->buffer, 'D', 'E', 'L', 'E', 'T', 'E')) {
parser->method = HTTP_DELETE;
break;
}
if (strncmp(parser->buffer, "UNLOCK", 6) == 0) {
if (ngx_str6cmp(parser->buffer, 'U', 'N', 'L', 'O', 'C', 'K')) {
parser->method = HTTP_UNLOCK;
break;
}
@ -540,12 +554,14 @@ size_t http_parser_execute (http_parser *parser,
break;
case 7:
if (strncmp(parser->buffer, "OPTIONS", 7) == 0) {
if (ngx_str7_cmp(parser->buffer,
'O', 'P', 'T', 'I', 'O', 'N', 'S', '\0')) {
parser->method = HTTP_OPTIONS;
break;
}
if (strncmp(parser->buffer, "CONNECT", 7) == 0) {
if (ngx_str7_cmp(parser->buffer,
'C', 'O', 'N', 'N', 'E', 'C', 'T', '\0')) {
parser->method = HTTP_CONNECT;
break;
}
@ -553,7 +569,8 @@ size_t http_parser_execute (http_parser *parser,
break;
case 8:
if (strncmp(parser->buffer, "PROPFIND", 8) == 0) {
if (ngx_str8cmp(parser->buffer,
'P', 'R', 'O', 'P', 'F', 'I', 'N', 'D')) {
parser->method = HTTP_PROPFIND;
break;
}
@ -561,7 +578,8 @@ size_t http_parser_execute (http_parser *parser,
break;
case 9:
if (strncmp(parser->buffer, "PROPPATCH", 9) == 0) {
if (ngx_str9cmp(parser->buffer,
'P', 'R', 'O', 'P', 'P', 'A', 'T', 'C', 'H')) {
parser->method = HTTP_PROPPATCH;
break;
}
@ -1311,7 +1329,7 @@ size_t http_parser_execute (http_parser *parser,
case s_body_identity:
to_read = MIN(pe - p, (ssize_t)(parser->content_length - parser->body_read));
if (to_read > 0) {
if (parser->on_body) parser->on_body(parser, p, to_read);
if (settings.on_body) settings.on_body(parser, p, to_read);
p += to_read - 1;
parser->body_read += to_read;
if (parser->body_read == parser->content_length) {
@ -1325,7 +1343,7 @@ size_t http_parser_execute (http_parser *parser,
case s_body_identity_eof:
to_read = pe - p;
if (to_read > 0) {
if (parser->on_body) parser->on_body(parser, p, to_read);
if (settings.on_body) settings.on_body(parser, p, to_read);
p += to_read - 1;
parser->body_read += to_read;
}
@ -1398,7 +1416,7 @@ size_t http_parser_execute (http_parser *parser,
to_read = MIN(pe - p, (ssize_t)(parser->content_length));
if (to_read > 0) {
if (parser->on_body) parser->on_body(parser, p, to_read);
if (settings.on_body) settings.on_body(parser, p, to_read);
p += to_read - 1;
}
@ -1475,17 +1493,6 @@ http_parser_init (http_parser *parser, enum http_parser_type t)
parser->state = (t == HTTP_REQUEST ? s_start_req : s_start_res);
parser->nread = 0;
parser->on_message_begin = NULL;
parser->on_path = NULL;
parser->on_query_string = NULL;
parser->on_url = NULL;
parser->on_fragment = NULL;
parser->on_header_field = NULL;
parser->on_header_value = NULL;
parser->on_headers_complete = NULL;
parser->on_body = NULL;
parser->on_message_complete = NULL;
parser->header_field_mark = NULL;
parser->header_value_mark = NULL;
parser->query_string_mark = NULL;

41
deps/http_parser/http_parser.h
View File

@ -24,11 +24,10 @@
extern "C" {
#endif
#ifdef _MSC_VER
# include <stddef.h>
#endif
#include <sys/types.h>
/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
* faster
*/
@ -38,12 +37,16 @@ extern "C" {
# define HTTP_PARSER_STRICT 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;
/* Callbacks should return non-zero to indicate an error. The parse will
/* Callbacks should return non-zero to indicate an error. The parser will
* then halt execution.
*
* http_data_cb does not return data chunks. It will be call arbitrarally
@ -53,9 +56,11 @@ typedef struct http_parser http_parser;
typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
typedef int (*http_cb) (http_parser*);
/* Should be at least one longer than the longest request method */
#define HTTP_PARSER_MAX_METHOD_LEN 10
/* Request Methods */
enum http_method
{ HTTP_DELETE = 0x0001
@ -77,8 +82,10 @@ enum http_method
, HTTP_UNLOCK = 0x4000
};
enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE };
struct http_parser {
/** PRIVATE **/
enum http_parser_type type;
@ -114,17 +121,15 @@ struct http_parser {
/** PUBLIC **/
void *data; /* A pointer to get hook to the "connection" or "socket" object */
};
/* an ordered list of callbacks */
struct http_parser_settings {
http_cb on_message_begin;
/* requests only */
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;
@ -132,15 +137,25 @@ struct http_parser {
http_cb on_message_complete;
};
void http_parser_init(http_parser *parser, enum http_parser_type type);
size_t http_parser_execute(http_parser *parser, const char *data, size_t len);
/* Call this in the on_headers_complete or on_message_complete callback to
* determine if this will be the last message on the connection.
* If you are the server, respond with the "Connection: close" header
* if you are the client, close the connection.
size_t http_parser_execute(http_parser *parser,
http_parser_settings settings,
const char *data,
size_t len);
/* If http_should_keep_alive() in the on_headers_complete or
* on_message_complete callback returns true, then this will be should be
* the last message on the connection.
* If you are the server, respond with the "Connection: close" header.
* If you are the client, close the connection.
*/
int http_should_keep_alive(http_parser *parser);
#ifdef __cplusplus
}
#endif

49
deps/http_parser/test.c
View File

@ -63,14 +63,6 @@ struct message {
static int currently_parsing_eof;
inline size_t parse (const char *buf, size_t len)
{
size_t nparsed;
currently_parsing_eof = (len == 0);
nparsed = http_parser_execute(parser, buf, len);
return nparsed;
}
static struct message messages[5];
static int num_messages;
@ -802,6 +794,19 @@ message_complete_cb (http_parser *p)
return 0;
}
static http_parser_settings settings =
{.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
};
void
parser_init (enum http_parser_type type)
{
@ -815,16 +820,6 @@ parser_init (enum http_parser_type type)
memset(&messages, 0, sizeof messages);
parser->on_message_begin = message_begin_cb;
parser->on_header_field = header_field_cb;
parser->on_header_value = header_value_cb;
parser->on_path = request_path_cb;
parser->on_url = request_url_cb;
parser->on_fragment = fragment_cb;
parser->on_query_string = query_string_cb;
parser->on_body = body_cb;
parser->on_headers_complete = headers_complete_cb;
parser->on_message_complete = message_complete_cb;
}
void
@ -835,6 +830,14 @@ parser_free ()
parser = NULL;
}
inline size_t parse (const char *buf, size_t len)
{
size_t nparsed;
currently_parsing_eof = (len == 0);
nparsed = http_parser_execute(parser, settings, buf, len);
return nparsed;
}
static inline int
check_str_eq (const struct message *m,
const char *prop,
@ -950,7 +953,7 @@ print_error (const char *raw, size_t error_location)
for (j = 0; j < error_location_line; j++) {
fputc(' ', stderr);
}
fprintf(stderr, "^\n\nerror location: %d\n", error_location);
fprintf(stderr, "^\n\nerror location: %u\n", (unsigned int)error_location);
}
@ -1142,9 +1145,9 @@ test_scan (const struct message *r1, const struct message *r2, const struct mess
error:
fprintf(stderr, "i=%d j=%d\n", i, j);
fprintf(stderr, "buf1 (%d) %s\n\n", buf1_len, buf1);
fprintf(stderr, "buf2 (%d) %s\n\n", buf2_len , buf2);
fprintf(stderr, "buf3 (%d) %s\n", buf3_len, buf3);
fprintf(stderr, "buf1 (%u) %s\n\n", (unsigned int)buf1_len, buf1);
fprintf(stderr, "buf2 (%u) %s\n\n", (unsigned int)buf2_len , buf2);
fprintf(stderr, "buf3 (%u) %s\n", (unsigned int)buf3_len, buf3);
exit(1);
}
@ -1156,7 +1159,7 @@ main (void)
int request_count;
int response_count;
printf("sizeof(http_parser) = %d\n", sizeof(http_parser));
printf("sizeof(http_parser) = %u\n", (unsigned int)sizeof(http_parser));
for (request_count = 0; requests[request_count].name; request_count++);
for (response_count = 0; responses[response_count].name; response_count++);

16
src/node_http.cc
View File

@ -46,6 +46,8 @@ static Persistent<String> proppatch_sym;
static Persistent<String> unlock_sym;
static Persistent<String> unknown_method_sym;
static struct http_parser_settings settings;
void
HTTPConnection::Initialize (Handle<Object> target)
{
@ -68,6 +70,16 @@ HTTPConnection::Initialize (Handle<Object> target)
end_symbol = NODE_PSYMBOL("end");
settings.on_message_begin = on_message_begin;
settings.on_path = on_path;
settings.on_query_string = on_query_string;
settings.on_url = on_url;
settings.on_fragment = on_fragment;
settings.on_header_field = on_header_field;
settings.on_header_value = on_header_value;
settings.on_headers_complete = on_headers_complete;
settings.on_body = on_body;
settings.on_message_complete = on_message_complete;
}
Handle<Value>
@ -109,7 +121,7 @@ HTTPConnection::OnReceive (const void *buf, size_t len)
assert(refs_);
size_t nparsed;
nparsed = http_parser_execute(&parser_, static_cast<const char*>(buf), len);
nparsed = http_parser_execute(&parser_, settings, static_cast<const char*>(buf), len);
if (nparsed != len) {
ForceClose();
@ -122,7 +134,7 @@ HTTPConnection::OnEOF ()
HandleScope scope;
assert(refs_);
size_t nparsed;
nparsed = http_parser_execute(&parser_, NULL, 0);
nparsed = http_parser_execute(&parser_, settings, NULL, 0);
Emit(end_symbol, 0, NULL);
}

10
src/node_http.h
View File

@ -28,16 +28,6 @@ protected:
void ResetParser() {
http_parser_init (&parser_, type_);
parser_.on_message_begin = on_message_begin;
parser_.on_url = on_url;
parser_.on_path = on_path;
parser_.on_fragment = on_fragment;
parser_.on_query_string = on_query_string;
parser_.on_header_field = on_header_field;
parser_.on_header_value = on_header_value;
parser_.on_headers_complete = on_headers_complete;
parser_.on_body = on_body;
parser_.on_message_complete = on_message_complete;
parser_.data = this;
}

30
src/node_http_parser.cc
View File

@ -27,8 +27,6 @@ namespace node {
using namespace v8;
static int deep = 0;
static Persistent<String> on_message_begin_sym;
static Persistent<String> on_path_sym;
static Persistent<String> on_query_string_sym;
@ -64,6 +62,8 @@ static Persistent<String> version_major_sym;
static Persistent<String> version_minor_sym;
static Persistent<String> should_keep_alive_sym;
static struct http_parser_settings settings;
// Callback prototype for http_cb
#define DEFINE_HTTP_CB(name) \
static int name(http_parser *p) { \
@ -231,7 +231,7 @@ class Parser : public ObjectWrap {
parser->buffer_ = buffer;
size_t nparsed =
http_parser_execute(&parser->parser_, buffer->data()+off, len);
http_parser_execute(&parser->parser_, settings, buffer->data()+off, len);
// Unassign the 'buffer_' variable
assert(parser->buffer_);
@ -261,7 +261,7 @@ class Parser : public ObjectWrap {
assert(!parser->buffer_);
http_parser_execute(&(parser->parser_), NULL, 0);
http_parser_execute(&(parser->parser_), settings, NULL, 0);
return Undefined();
}
@ -290,17 +290,6 @@ class Parser : public ObjectWrap {
assert(buffer_ == NULL); // don't call this during Execute()
http_parser_init(&parser_, type);
parser_.on_message_begin = on_message_begin;
parser_.on_path = on_path;
parser_.on_query_string = on_query_string;
parser_.on_url = on_url;
parser_.on_fragment = on_fragment;
parser_.on_header_field = on_header_field;
parser_.on_header_value = on_header_value;
parser_.on_headers_complete = on_headers_complete;
parser_.on_body = on_body;
parser_.on_message_complete = on_message_complete;
parser_.data = this;
}
@ -356,6 +345,17 @@ void InitHttpParser(Handle<Object> target) {
version_major_sym = NODE_PSYMBOL("versionMajor");
version_minor_sym = NODE_PSYMBOL("versionMinor");
should_keep_alive_sym = NODE_PSYMBOL("shouldKeepAlive");
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;
settings.on_body = Parser::on_body;
settings.on_message_complete = Parser::on_message_complete;
}
} // namespace node

Write Preview
Loading…
Cancel
Save