haiwan
/
http-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

better output for test_scan

Browse Source
event_stream
Ryan Dahl 16 years ago
parent 0b8a48049c
commit b71a17ec85
2 changed files with 214 additions and 156 deletions
Show Stats Download Patch File Download Diff File

203
http_parser.c
Unescape View File

@ -92,6 +92,10 @@ static inline int message_complete_callback (http_parser *parser)
#define CONTENT_LENGTH "content-length" #define CONTENT_LENGTH "content-length"
#define TRANSFER_ENCODING "transfer-encoding" #define TRANSFER_ENCODING "transfer-encoding"
#define CHUNKED "chunked"
#define KEEP_ALIVE "keep-alive"
#define CLOSE "close"
static const unsigned char lowcase[] = 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\0"
@ -191,13 +195,13 @@ enum state
, s_headers_almost_done , s_headers_almost_done
, s_headers_done , s_headers_done
, s_chunked_len_start , s_chunk_size_start
, s_chunked_len , s_chunk_size
, s_chunked_len_almost_done , s_chunk_size_almost_done
, s_chunked_data , s_chunk_parameters
, s_chunked_data_almost_done , s_chunk_data
, s_chunked_data_done , s_chunk_data_almost_done
, s_chunked_almost_done , s_chunk_data_done
, s_body_identity , s_body_identity
, s_body_identity_eof , s_body_identity_eof
@ -208,26 +212,29 @@ enum header_states
, h_C , h_C
, h_CO , h_CO
, h_CON , h_CON
, h_matching_connection , h_matching_connection
, h_matching_content_length , h_matching_content_length
, h_matching_transfer_encoding , h_matching_transfer_encoding
, h_connection , h_connection
, h_content_length , h_content_length
, h_transfer_encoding , h_transfer_encoding
, h_encoding_C
, h_encoding_CH , h_matching_transfer_encoding_chunked
, h_encoding_CHU , h_matching_connection_keep_alive
, h_encoding_CHUN , h_matching_connection_close
, h_encoding_CHUNK
, h_encoding_CHUNKE , h_transfer_encoding_chunked
, h_encoding_CHUNKED , h_connection_keep_alive
, h_connection_K , h_connection_close
, h_connection_C
}; };
enum flags enum flags
{ F_CHUNKED = 0x0001 { F_CHUNKED = 0x0001
, F_TRAILING= 0x0002 , F_CONNECTION_KEEP_ALIVE = 0x0002
, F_CONNECTION_CLOSE = 0x0004
, F_TRAILING = 0x0010
}; };
#define ERROR (p - data); #define ERROR (p - data);
@ -836,10 +843,6 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
} }
break; break;
case h_connection:
if (ch != ' ') header_state = h_general;
break;
/* content-length */ /* content-length */
case h_matching_content_length: case h_matching_content_length:
@ -851,10 +854,6 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
} }
break; break;
case h_content_length:
if (ch != ' ') header_state = h_general;
break;
/* transfer-encoding */ /* transfer-encoding */
case h_matching_transfer_encoding: case h_matching_transfer_encoding:
@ -866,6 +865,8 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
} }
break; break;
case h_connection:
case h_content_length:
case h_transfer_encoding: case h_transfer_encoding:
if (ch != ' ') header_state = h_general; if (ch != ' ') header_state = h_general;
break; break;
@ -916,6 +917,7 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
MARK(header_value); MARK(header_value);
state = s_header_value; state = s_header_value;
header_index = 0;
c = lowcase[(int)ch]; c = lowcase[(int)ch];
@ -926,7 +928,7 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
case h_transfer_encoding: case h_transfer_encoding:
/* looking for 'Transfer-Encoding: chunked' */ /* looking for 'Transfer-Encoding: chunked' */
if ('c' == c) { if ('c' == c) {
header_state = h_encoding_C; header_state = h_matching_transfer_encoding_chunked;
} else { } else {
header_state = h_general; header_state = h_general;
} }
@ -940,10 +942,10 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
case h_connection: case h_connection:
/* looking for 'Connection: keep-alive' */ /* looking for 'Connection: keep-alive' */
if (c == 'k') { if (c == 'k') {
header_state = h_connection_K; header_state = h_matching_connection_keep_alive;
/* looking for 'Connection: close' */ /* looking for 'Connection: close' */
} else if (c == 'c') { } else if (c == 'c') {
header_state = h_connection_C; header_state = h_matching_connection_close;
} else { } else {
header_state = h_general; header_state = h_general;
} }
@ -976,15 +978,17 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
break; break;
} }
header_index++;
switch (header_state) { switch (header_state) {
case h_general:
break;
case h_connection: case h_connection:
case h_transfer_encoding: case h_transfer_encoding:
assert(0 && "Shouldn't get here."); assert(0 && "Shouldn't get here.");
break; break;
case h_general:
break;
case h_content_length: case h_content_length:
if (ch < '0' || ch > '9') return ERROR; if (ch < '0' || ch > '9') return ERROR;
parser->content_length *= 10; parser->content_length *= 10;
@ -992,37 +996,38 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
break; break;
/* Transfer-Encoding: chunked */ /* Transfer-Encoding: chunked */
case h_matching_transfer_encoding_chunked:
case h_encoding_C: if (header_index > sizeof(CHUNKED)-1
header_state = (c == 'h' ? h_encoding_CH : h_general); || c != CHUNKED[header_index]) {
break; header_state = h_general;
case h_encoding_CH: } else if (header_index == sizeof(CHUNKED)-2) {
header_state = (c == 'u' ? h_encoding_CHU : h_general); header_state = h_transfer_encoding_chunked;
break;
case h_encoding_CHU:
header_state = (c == 'n' ? h_encoding_CHUN : h_general);
break;
case h_encoding_CHUN:
header_state = (c == 'k' ? h_encoding_CHUNK : h_general);
break;
case h_encoding_CHUNK:
header_state = (c == 'e' ? h_encoding_CHUNKE : h_general);
break;
case h_encoding_CHUNKE:
if (c == 'd') {
parser->flags |= F_CHUNKED;
header_state = h_encoding_CHUNKED;
} }
break; break;
case h_encoding_CHUNKED:
if (ch != ' ') return ERROR;
break;
/* looking for 'Connection: keep-alive' */ /* looking for 'Connection: keep-alive' */
case h_matching_connection_keep_alive:
if (header_index > sizeof(KEEP_ALIVE)-1
|| c != KEEP_ALIVE[header_index]) {
header_state = h_general;
} else if (header_index == sizeof(KEEP_ALIVE)-2) {
header_state = h_connection_keep_alive;
}
break;
/* looking for 'Connection: close' */ /* looking for 'Connection: close' */
case h_connection_K: case h_matching_connection_close:
case h_connection_C: if (header_index > sizeof(CLOSE)-1 || c != CLOSE[header_index]) {
header_state = h_general; header_state = h_general;
} else if (header_index == sizeof(CLOSE)-2) {
header_state = h_connection_keep_alive;
}
break;
case h_transfer_encoding_chunked:
case h_connection_keep_alive:
case h_connection_close:
if (ch != ' ') header_state = h_general;
break; break;
default: default:
@ -1035,7 +1040,22 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
case s_header_almost_done: case s_header_almost_done:
if (ch != LF) return ERROR; if (ch != LF) return ERROR;
state = s_header_field_start; state = s_header_field_start;
switch (header_state) {
case h_connection_keep_alive:
parser->flags |= F_CONNECTION_KEEP_ALIVE;
break;
case h_connection_close:
parser->flags |= F_CONNECTION_CLOSE;
break;
case h_transfer_encoding_chunked:
parser->flags |= F_CHUNKED;
break;
default:
break;
}
break; break;
case s_headers_almost_done: case s_headers_almost_done:
@ -1053,21 +1073,22 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
parser->body_read = 0; parser->body_read = 0;
if (parser->flags & F_CHUNKED) { if (parser->flags & F_CHUNKED) {
state = s_chunked_len_start; state = s_chunk_size_start;
} else { } else {
if (parser->content_length == 0) { if (parser->content_length == 0) {
CALLBACK2(message_complete); CALLBACK2(message_complete);
state = s_start; state = s_start;
} else if (parser->content_length < 0) { } else if (parser->content_length > 0) {
state = s_body_identity_eof;
} else {
state = s_body_identity; state = s_body_identity;
} else {
if (parser->method & (HTTP_GET | HTTP_HEAD)) {
CALLBACK2(message_complete);
state = s_start;
} else {
state = s_body_identity_eof;
}
} }
} }
break;
/* read until EOF */
case s_body_identity_eof:
break; break;
case s_body_identity: case s_body_identity:
@ -1083,38 +1104,63 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
} }
break; break;
case s_chunked_len_start: /* read until EOF */
case s_body_identity_eof:
to_read = pe - p;
if (to_read > 0) {
if (parser->on_body) parser->on_body(parser, p, to_read);
p += to_read - 1;
parser->body_read += to_read;
}
break;
case s_chunk_size_start:
c = unhex[(int)ch]; c = unhex[(int)ch];
if (c == -1) return ERROR; if (c == -1) return ERROR;
parser->chunk_size = c; parser->chunk_size = c;
state = s_chunked_len; state = s_chunk_size;
break; break;
case s_chunked_len: case s_chunk_size:
if (ch == CR) { if (ch == CR) {
state = s_chunked_len_almost_done; state = s_chunk_size_almost_done;
break; break;
} }
c = unhex[(int)ch]; c = unhex[(int)ch];
if (c == -1) return ERROR; if (c == -1) {
if (ch == ';' || ch == ' ') {
state = s_chunk_parameters;
break;
}
return ERROR;
}
parser->chunk_size *= 16; parser->chunk_size *= 16;
parser->chunk_size += c; parser->chunk_size += c;
break; break;
case s_chunked_len_almost_done: case s_chunk_parameters:
/* just ignore this shit */
/* TODO check for overflow */
if (ch == CR) {
state = s_chunk_size_almost_done;
break;
}
break;
case s_chunk_size_almost_done:
if (ch != LF) return ERROR; if (ch != LF) return ERROR;
if (parser->chunk_size == 0) { if (parser->chunk_size == 0) {
parser->flags |= F_TRAILING; parser->flags |= F_TRAILING;
state = s_header_field_start; state = s_header_field_start;
} else { } else {
state = s_chunked_data; state = s_chunk_data;
} }
break; break;
case s_chunked_data: case s_chunk_data:
to_read = MIN(pe - p, (ssize_t)(parser->chunk_size)); to_read = MIN(pe - p, (ssize_t)(parser->chunk_size));
if (to_read > 0) { if (to_read > 0) {
@ -1123,25 +1169,22 @@ size_t http_parser_execute (http_parser *parser, const char *data, size_t len)
} }
if (to_read == parser->chunk_size) { if (to_read == parser->chunk_size) {
state = s_chunked_data_almost_done; state = s_chunk_data_almost_done;
} }
parser->chunk_size -= to_read; parser->chunk_size -= to_read;
break; break;
case s_chunked_data_almost_done: case s_chunk_data_almost_done:
if (ch != CR) return ERROR; if (ch != CR) return ERROR;
state = s_chunked_data_done; state = s_chunk_data_done;
break; break;
case s_chunked_data_done: case s_chunk_data_done:
if (ch != LF) return ERROR; if (ch != LF) return ERROR;
state = s_chunked_len_start; state = s_chunk_size_start;
break; break;
case s_chunked_almost_done:
if (ch != LF) return ERROR;
default: default:
assert(0 && "unhandled state"); assert(0 && "unhandled state");
return ERROR; return ERROR;

163
test.c
Unescape View File

@ -610,7 +610,7 @@ parser_init (enum http_parser_type type)
parser.on_message_complete = message_complete_cb; parser.on_message_complete = message_complete_cb;
} }
static inline void static inline int
check_str_eq (const struct message *m, check_str_eq (const struct message *m,
const char *prop, const char *prop,
const char *expected, const char *expected,
@ -619,11 +619,12 @@ check_str_eq (const struct message *m,
printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name); printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
printf("expected '%s'\n", expected); printf("expected '%s'\n", expected);
printf(" found '%s'\n", found); printf(" found '%s'\n", found);
exit(1); return 0;
} }
return 1;
} }
static inline void static inline int
check_num_eq (const struct message *m, check_num_eq (const struct message *m,
const char *prop, const char *prop,
int expected, int expected,
@ -632,18 +633,19 @@ check_num_eq (const struct message *m,
printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name); printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
printf("expected %d\n", expected); printf("expected %d\n", expected);
printf(" found %d\n", found); printf(" found %d\n", found);
exit(1); return 0;
} }
return 1;
} }
#define MESSAGE_CHECK_STR_EQ(expected, found, prop) \ #define MESSAGE_CHECK_STR_EQ(expected, found, prop) \
check_str_eq(expected, #prop, expected->prop, found->prop) if (!check_str_eq(expected, #prop, expected->prop, found->prop)) return 0
#define MESSAGE_CHECK_NUM_EQ(expected, found, prop) \ #define MESSAGE_CHECK_NUM_EQ(expected, found, prop) \
check_num_eq(expected, #prop, expected->prop, found->prop) if (!check_num_eq(expected, #prop, expected->prop, found->prop)) return 0
void int
message_eq (int index, const struct message *expected) message_eq (int index, const struct message *expected)
{ {
int i; int i;
@ -664,60 +666,35 @@ message_eq (int index, const struct message *expected)
MESSAGE_CHECK_NUM_EQ(expected, m, num_headers); MESSAGE_CHECK_NUM_EQ(expected, m, num_headers);
int r;
for (i = 0; i < m->num_headers; i++) { for (i = 0; i < m->num_headers; i++) {
check_str_eq(expected, "header field", expected->headers[i][0], m->headers[i][0]); r = check_str_eq(expected, "header field", expected->headers[i][0], m->headers[i][0]);
check_str_eq(expected, "header value", expected->headers[i][1], m->headers[i][1]); if (!r) return 0;
} r = check_str_eq(expected, "header value", expected->headers[i][1], m->headers[i][1]);
} if (!r) return 0;
void
parse_messages (int message_count, const struct message *input_messages[])
{
// Concat the input messages
size_t length = 0;
int i;
for (i = 0; i < message_count; i++) {
length += strlen(input_messages[i]->raw);
} }
char total[length + 1];
total[0] = '\0';
for (i = 0; i < message_count; i++) {
strcat(total, input_messages[i]->raw);
}
// Parse the stream
parser_init(HTTP_REQUEST);
http_parser_execute(&parser, total, length);
http_parser_execute(&parser, NULL, 0); return 1;
assert(num_messages == message_count);
for (i = 0; i < message_count; i++) {
message_eq(i, input_messages[i]);
}
} }
static void static void
print_error (const struct message *message, size_t error_location) print_error (const char *raw, size_t error_location)
{ {
printf("\n*** parse error on '%s' ***\n\n", message->name); fprintf(stderr, "\n*** parse error ***\n\n");
int this_line = 0, char_len = 0; int this_line = 0, char_len = 0;
size_t i, j, len = strlen(message->raw), error_location_line = 0; size_t i, j, len = strlen(raw), error_location_line = 0;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (i == error_location) this_line = 1; if (i == error_location) this_line = 1;
switch (message->raw[i]) { switch (raw[i]) {
case '\r': case '\r':
char_len = 2; char_len = 2;
printf("\\r"); fprintf(stderr, "\\r");
break; break;
case '\n': case '\n':
char_len = 2; char_len = 2;
printf("\\n\n"); fprintf(stderr, "\\n\n");
if (this_line) goto print; if (this_line) goto print;
@ -726,19 +703,19 @@ print_error (const struct message *message, size_t error_location)
default: default:
char_len = 1; char_len = 1;
putchar(message->raw[i]); fputc(raw[i], stderr);
break; break;
} }
if (!this_line) error_location_line += char_len; if (!this_line) error_location_line += char_len;
} }
printf("[eof]\n"); fprintf(stderr, "[eof]\n");
print: print:
for (j = 0; j < error_location_line; j++) { for (j = 0; j < error_location_line; j++) {
putchar(' '); fputc(' ', stderr);
} }
printf("^\n\nerror location: %d\n", error_location); fprintf(stderr, "^\n\nerror location: %d\n", error_location);
} }
@ -751,13 +728,13 @@ test_message (const struct message *message)
read = http_parser_execute(&parser, message->raw, strlen(message->raw)); read = http_parser_execute(&parser, message->raw, strlen(message->raw));
if (read != strlen(message->raw)) { if (read != strlen(message->raw)) {
print_error(message, read); print_error(message->raw, read);
exit(1); exit(1);
} }
read = http_parser_execute(&parser, NULL, 0); read = http_parser_execute(&parser, NULL, 0);
if (read != 0) { if (read != 0) {
print_error(message, read); print_error(message->raw, read);
exit(1); exit(1);
} }
@ -766,7 +743,7 @@ test_message (const struct message *message)
exit(1); exit(1);
} }
message_eq(0, message); if(!message_eq(0, message)) exit(1);
} }
int int
@ -781,7 +758,7 @@ test_error (const char *buf)
parsed = http_parser_execute(&parser, NULL, 0); parsed = http_parser_execute(&parser, NULL, 0);
if (parsed != 0) return 1; if (parsed != 0) return 1;
printf("\n*** Error expected but none found ***\n\n%s", buf); fprintf(stderr, "\n*** Error expected but none found ***\n\n%s", buf);
exit(1); exit(1);
return 0; return 0;
@ -803,14 +780,24 @@ test_multiple3 (const struct message *r1, const struct message *r2, const struct
parser_init(HTTP_REQUEST); parser_init(HTTP_REQUEST);
http_parser_execute(&parser, total, strlen(total)); size_t read;
http_parser_execute(&parser, NULL, 0); read = http_parser_execute(&parser, total, strlen(total));
if (read != strlen(total)) {
print_error(total, read);
exit(1);
}
read = http_parser_execute(&parser, NULL, 0);
if (read != 0) {
print_error(total, read);
exit(1);
}
assert(num_messages == 3); assert(num_messages == 3);
message_eq(0, r1); if (!message_eq(0, r1)) exit(1);
message_eq(1, r2); if (!message_eq(1, r2)) exit(1);
message_eq(2, r3); if (!message_eq(2, r3)) exit(1);
} }
/* SCAN through every possible breaking to make sure the /* SCAN through every possible breaking to make sure the
@ -829,11 +816,15 @@ test_scan (const struct message *r1, const struct message *r2, const struct mess
strcat(total, r2->raw); strcat(total, r2->raw);
strcat(total, r3->raw); strcat(total, r3->raw);
size_t read;
int total_len = strlen(total); int total_len = strlen(total);
int total_ops = (total_len - 1) * (total_len - 2) / 2; int total_ops = (total_len - 1) * (total_len - 2) / 2;
int ops = 0 ; int ops = 0 ;
size_t buf1_len, buf2_len, buf3_len;
int i,j; int i,j;
for (j = 2; j < total_len; j ++ ) { for (j = 2; j < total_len; j ++ ) {
for (i = 1; i < j; i ++ ) { for (i = 1; i < j; i ++ ) {
@ -846,40 +837,65 @@ test_scan (const struct message *r1, const struct message *r2, const struct mess
parser_init(HTTP_REQUEST); parser_init(HTTP_REQUEST);
int buf1_len = i; buf1_len = i;
strncpy(buf1, total, buf1_len); strncpy(buf1, total, buf1_len);
buf1[buf1_len] = 0; buf1[buf1_len] = 0;
int buf2_len = j - i; buf2_len = j - i;
strncpy(buf2, total+i, buf2_len); strncpy(buf2, total+i, buf2_len);
buf2[buf2_len] = 0; buf2[buf2_len] = 0;
int buf3_len = total_len - j; buf3_len = total_len - j;
strncpy(buf3, total+j, buf3_len); strncpy(buf3, total+j, buf3_len);
buf3[buf3_len] = 0; buf3[buf3_len] = 0;
/* read = http_parser_execute(&parser, buf1, buf1_len);
printf("buf1: %s - %d\n", buf1, buf1_len); if (read != buf1_len) {
printf("buf2: %s - %d \n", buf2, buf2_len ); print_error(buf1, read);
printf("buf3: %s - %d\n\n", buf3, buf3_len); goto error;
*/ }
http_parser_execute(&parser, buf1, buf1_len);
http_parser_execute(&parser, buf2, buf2_len); read = http_parser_execute(&parser, buf2, buf2_len);
if (read != buf2_len) {
print_error(buf2, read);
goto error;
}
http_parser_execute(&parser, buf3, buf3_len); read = http_parser_execute(&parser, buf3, buf3_len);
if (read != buf3_len) {
print_error(buf3, read);
goto error;
}
http_parser_execute(&parser, NULL, 0); http_parser_execute(&parser, NULL, 0);
assert(3 == num_messages); assert(3 == num_messages);
message_eq(0, r1); if (!message_eq(0, r1)) {
message_eq(1, r2); fprintf(stderr, "\n\nError matching messages[0] in test_scan.\n");
message_eq(2, r3); goto error;
}
if (!message_eq(1, r2)) {
fprintf(stderr, "\n\nError matching messages[1] in test_scan.\n");
goto error;
}
if (!message_eq(2, r3)) {
fprintf(stderr, "\n\nError matching messages[2] in test_scan.\n");
goto error;
}
} }
} }
puts("\b\b\b\b100%"); puts("\b\b\b\b100%");
return;
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);
exit(1);
} }
int int
@ -958,14 +974,12 @@ main (void)
test_message(&requests[i]); test_message(&requests[i]);
} }
#if 0
int j, k; int j, k;
for (i = 0; i < request_count; i++) { for (i = 0; i < request_count; i++) {
for (j = 0; j < request_count; j++) { for (j = 0; j < request_count; j++) {
for (k = 0; k < request_count; k++) { for (k = 0; k < request_count; k++) {
//printf("%d %d %d\n", i, j, k);
test_multiple3(&requests[i], &requests[j], &requests[k]); test_multiple3(&requests[i], &requests[j], &requests[k]);
} }
} }
@ -976,6 +990,7 @@ main (void)
, &requests[GET_ONE_HEADER_NO_BODY] , &requests[GET_ONE_HEADER_NO_BODY]
, &requests[GET_NO_HEADERS_NO_BODY] , &requests[GET_NO_HEADERS_NO_BODY]
); );
#if 0
printf("request scan 2/3 "); printf("request scan 2/3 ");
test_scan( &requests[GET_FUNKY_CONTENT_LENGTH] test_scan( &requests[GET_FUNKY_CONTENT_LENGTH]

Write Preview
Loading…
Cancel
Save