haiwan
/
http-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3f1a05a24c'
${ noResults }
http-parser/http_parser.c

2248 lines
62 KiB
Raw Normal View History Unescape

It was pointed out we're missing attribution to NGINX
14 years ago
/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev
*
* Additional changes are licensed under the same terms as NGINX and
* copyright Joyent, Inc. and other Node contributors. All rights reserved.
Remove EOL whitespace
16 years ago
*
copyright header
16 years ago
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
Remove EOL whitespace
16 years ago
*
copyright header
16 years ago
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
Remove EOL whitespace
16 years ago
*
copyright header
16 years ago
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
Remove EOL whitespace
16 years ago
* IN THE SOFTWARE.
copyright header
16 years ago
*/
Use "" instead of <> for the http_parser.h include. This avoids having to specify -I when building.
13 years ago
#include "http_parser.h"
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
#include <assert.h>
Use stddef.h
15 years ago
#include <stddef.h>
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
#include <ctype.h>
#include <stdlib.h>
http_parser_init does not clear status_code
13 years ago
#include <string.h>
Make content_length unsigned, add overflow checks.
13 years ago
#include <limits.h>
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Make content_length unsigned, add overflow checks.
13 years ago
#ifndef ULLONG_MAX
# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */
#endif
Tasteful vertical whitespace.
15 years ago
Handling chunked messages
16 years ago
#ifndef MIN
# define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
Add bounds check to http_method_str().
13 years ago
#ifndef ARRAY_SIZE
# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#endif
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
#ifndef BIT_AT
# define BIT_AT(a, i) \
(!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \
(1 << ((unsigned int) (i) & 7))))
#endif
Add bounds check to http_method_str().
13 years ago
#ifndef ELEM_AT
# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v))
#endif
Tasteful vertical whitespace.
15 years ago
Break out errno into its own field.
14 years ago
#define SET_ERRNO(e) \
do { \
rename parser->errno to parser->http_errno; conflicts with errno.h where errno is defined as a macro
14 years ago
parser->http_errno = (e); \
Break out errno into its own field.
14 years ago
} while(0)
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run the notify callback FOR, returning ER if it fails */
#define CALLBACK_NOTIFY_(FOR, ER) \
Use marcros instead of inline funcs to do callbacks Simplifies things.
15 years ago
do { \
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \
\
pass pointer to settings structure rather than pass by value
15 years ago
if (settings->on_##FOR) { \
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (0 != settings->on_##FOR(parser)) { \
SET_ERRNO(HPE_CB_##FOR); \
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} \
\
/* We either errored above or got paused; get out */ \
if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \
return (ER); \
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
} \
Use marcros instead of inline funcs to do callbacks Simplifies things.
15 years ago
} \
Introduce http_parser_settings
15 years ago
} while (0)
Handling chunked messages
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run the notify callback FOR and consume the current byte */
#define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1)
Tasteful vertical whitespace.
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run the notify callback FOR and don't consume the current byte */
#define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data)
reduce size of http_parser object from 104 to 84 bytes by only tracking one field size This does have some slight functional changes in cases where MAX_FIELD_SIZE is hit, specficially if a URL is made up of many components, each of which is smaller than MAX_FIELD_SIZE, but the total together is greater than MAX_FIELD_SIZE, then we now might not call callbacks for any of the components (even the ones that are smaller than 80kb). With the old code, it was possible to get a callback for query_string and never get a callback for the URL (or at least the end of the URL that is past 80kb), if the callback for the URL would have been larger than 80kb. (to be honest, I'm surprised that the MAX_FIELD_SIZE is implemented in http_parser at all, instead of requiring that callers pay attention to it, as it feels like it should be the caller's responsibility)
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run data callback FOR with LEN bytes, returning ER if it fails */
#define CALLBACK_DATA_(FOR, LEN, ER) \
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
do { \
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \
\
reduce the size of the http_parser struct The *_mark members were actually being used as just boolean values to the next call of the parser. However, you can calculate if the mark members should be set or not purely based on the current state, so they can just be gotten rid of entirely.
15 years ago
if (FOR##_mark) { \
pass pointer to settings structure rather than pass by value
15 years ago
if (settings->on_##FOR) { \
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (0 != settings->on_##FOR(parser, FOR##_mark, (LEN))) { \
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_CB_##FOR); \
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} \
\
/* We either errored above or got paused; get out */ \
if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \
return (ER); \
Use marcros instead of inline funcs to do callbacks Simplifies things.
15 years ago
} \
} \
Get rid of CALLBACK_NOCLEAR(). - This was only used by CALLBACK() (which then cleared the mark anyway), and the end of the http_parser_execute() body (after which they go out of scope).
14 years ago
FOR##_mark = NULL; \
Use marcros instead of inline funcs to do callbacks Simplifies things.
15 years ago
} \
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
} while (0)
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run the data callback FOR and consume the current byte */
#define CALLBACK_DATA(FOR) \
CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)
/* Run the data callback FOR and don't consume the current byte */
#define CALLBACK_DATA_NOADVANCE(FOR) \
CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)
/* Set the mark FOR; non-destructive if mark is already set */
#define MARK(FOR) \
do { \
if (!FOR##_mark) { \
FOR##_mark = p; \
} \
} while (0)
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Tasteful vertical whitespace.
15 years ago
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
#define PROXY_CONNECTION "proxy-connection"
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
#define CONNECTION "connection"
#define CONTENT_LENGTH "content-length"
#define TRANSFER_ENCODING "transfer-encoding"
Support Upgrade header
15 years ago
#define UPGRADE "upgrade"
better output for test_scan
16 years ago
#define CHUNKED "chunked"
#define KEEP_ALIVE "keep-alive"
#define CLOSE "close"
Tasteful vertical whitespace.
15 years ago
Expose http_method_str() to get a string version of a method
15 years ago
static const char *method_strings[] =
Create method_strings array with HTTP_METHOD_MAP macro.
13 years ago
{
#define XX(num, name, string) #string,
HTTP_METHOD_MAP(XX)
#undef XX
Expose http_method_str() to get a string version of a method
15 years ago
};
Accept tokens + SP for header fields
15 years ago
/* Tokens as defined by rfc 2616. Also lowercases them.
* token = 1*<any CHAR except CTLs or separators>
* separators = "(" | ")" | "<" | ">" | "@"
* | "," | ";" | ":" | "\" | <">
* | "/" | "[" | "]" | "?" | "="
* | "{" | "}" | SP | HT
*/
static const char tokens[256] = {
/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
0, 0, 0, 0, 0, 0, 0, 0,
/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
0, 0, 0, 0, 0, 0, 0, 0,
/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
0, 0, 0, 0, 0, 0, 0, 0,
/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
0, 0, 0, 0, 0, 0, 0, 0,
/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
Remove some chars from tokens[] per RFC. - Treat ' ' specially, as apparently IIS6.0 can send this in headers. Allow this character through if we're not in strict mode. - Move some test code around so that test indices don't break when HTTP_PARSER_STRICT changes. Fixes #13.
14 years ago
0, '!', 0, '#', '$', '%', '&', '\'',
Accept tokens + SP for header fields
15 years ago
/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
Remove some chars from tokens[] per RFC. - Treat ' ' specially, as apparently IIS6.0 can send this in headers. Allow this character through if we're not in strict mode. - Move some test code around so that test indices don't break when HTTP_PARSER_STRICT changes. Fixes #13.
14 years ago
0, 0, '*', '+', 0, '-', '.', 0,
Accept tokens + SP for header fields
15 years ago
/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
'0', '1', '2', '3', '4', '5', '6', '7',
/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
'8', '9', 0, 0, 0, 0, 0, 0,
/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
'x', 'y', 'z', 0, 0, 0, '^', '_',
/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
Remove some chars from tokens[] per RFC. - Treat ' ' specially, as apparently IIS6.0 can send this in headers. Allow this character through if we're not in strict mode. - Move some test code around so that test indices don't break when HTTP_PARSER_STRICT changes. Fixes #13.
14 years ago
'x', 'y', 'z', 0, '|', 0, '~', 0 };
Accept tokens + SP for header fields
15 years ago
Array type cleanups. Also save space acceptable_header[x] is always assigned to a variable of type char, so the 'unsigned' is unnecessary. The other arrays can be of type int8_t/uint8_t to save space.
15 years ago
static const int8_t unhex[256] =
Handling chunked messages
16 years ago
{-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
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
,-1,10,11,12,13,14,15,-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,10,11,12,13,14,15,-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
};
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Don't assert() on whitespace in URL. Be lenient about tabs and form feeds in non-strict mode.
13 years ago
#if HTTP_PARSER_STRICT
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
# define T(v) 0
Don't assert() on whitespace in URL. Be lenient about tabs and form feeds in non-strict mode.
13 years ago
#else
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
# define T(v) v
Don't assert() on whitespace in URL. Be lenient about tabs and form feeds in non-strict mode.
13 years ago
#endif
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
static const uint8_t normal_url_char[32] = {
Use lookup tables of my own.
15 years ago
/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
Use lookup tables of my own.
15 years ago
/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
0 | T(2) | 0 | 0 | T(16) | 0 | 0 | 0,
Use lookup tables of my own.
15 years ago
/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
Use lookup tables of my own.
15 years ago
/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,
Use lookup tables of my own.
15 years ago
/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
0 | 2 | 4 | 0 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 0,
Use lookup tables of my own.
15 years ago
/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 128,
Use lookup tables of my own.
15 years ago
/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, };
Add a macros for the usual case
16 years ago
Don't assert() on whitespace in URL. Be lenient about tabs and form feeds in non-strict mode.
13 years ago
#undef T
Tasteful vertical whitespace.
15 years ago
Remove EOL whitespace
16 years ago
enum state
add http_should_keep_alive()
16 years ago
{ s_dead = 1 /* important that this is > 0 */
Fix typo s_start_res_or_resp
15 years ago
, s_start_req_or_res
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
, s_res_or_resp_H
add http_should_keep_alive()
16 years ago
, s_start_res
Passing tests
16 years ago
, s_res_H
, s_res_HT
, s_res_HTT
, s_res_HTTP
, s_res_first_http_major
, s_res_http_major
, s_res_first_http_minor
, s_res_http_minor
, s_res_first_status_code
, s_res_status_code
Parse and emit status message of response
12 years ago
, s_res_status_start
Passing tests
16 years ago
, s_res_status
, s_res_line_almost_done
, s_start_req
accept webdav methods
16 years ago
Reimplement support for extension methods This sacrifices - a little space (10 bytes), - a few extra calculations, and - introduces a dependency on strncmp() to dramatically simplify the code of parsing methods and support almost arbitrary extension methods. In the future I will do as NGINX does and not use strncmp but bit level blob comparisons.
16 years ago
, s_req_method
Passing tests
16 years ago
, s_req_spaces_before_url
, s_req_schema
, s_req_schema_slash
, s_req_schema_slash_slash
Rename s_req_host* to be compliant with RFC 2396
13 years ago
, s_req_server_start
, s_req_server
, s_req_server_with_at
Passing tests
16 years ago
, s_req_path
, s_req_query_string_start
, s_req_query_string
, s_req_fragment_start
, s_req_fragment
, s_req_http_start
, s_req_http_H
, s_req_http_HT
, s_req_http_HTT
, s_req_http_HTTP
strict check
16 years ago
, s_req_first_http_major
, s_req_http_major
, s_req_first_http_minor
, s_req_http_minor
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, s_req_line_almost_done
, s_header_field_start
, s_header_field
Include separating ws when folding header values The support for folding of multi-line header values does not conform to the specs. Given a request containing Multi-Line-Header: foo<CRLF> bar<CRLF> http-parser will eliminate the whitespace breaking the header value to yield a header value of "foobar". This is confirmed by the LINE_FOLDING_IN_HEADER case in tests.c. But from rfc2616, section 2.2: A CRLF is allowed in the definition of TEXT only as part of a header field continuation. It is expected that the folding LWS will be replaced with a single SP before interpretation of the TEXT value. And from draft-ietf-httpbis-p1-messaging-25, section 3.2.4: A server that receives an obs-fold in a request message that is not within a message/http container MUST either reject the message by sending a 400 (Bad Request), preferably with a representation explaining that obsolete line folding is unacceptable, or replace each received obs-fold with one or more SP octets prior to interpreting the field value or forwarding the message downstream. So in the example above, the header value should be interpreted as "foo bar", possibly with multiple spaces. The current http-parser behaviour of eliminating the LWS altogether clearly deviates from the specs. For http-parser itself to confirm exactly would involve significant changes in order to synthesize replacement SP octets. Such changes are unlikely to be worth it to support what is an obscure and deprecated feature. But http-parser should at least preserve some separating whitespace when folding multi-line header values, so that applications using http-parser can conform to the specs. This commit is a minimal change to preserve whitespace when folding lines. It eliminates the CRLF, but retains any trailing and leading whitespace in the header value.
12 years ago
, s_header_value_discard_ws
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
, s_header_value_discard_ws_almost_done
, s_header_value_discard_lws
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, s_header_value_start
, s_header_value
Support multi-line folding in header values. Normal value cb is called for subsequent lines. LWS is skipped. Note that \t whitespace character is now supported after header field name. RFC 2616, Section 2.2 "HTTP/1.1 header field values can be folded onto multiple lines if the continuation line begins with a space or horizontal tab. All linear white space, including folding, has the same semantics as SP. A recipient MAY replace any linear white space with a single SP before interpreting the field value or forwarding the message downstream."
14 years ago
, s_header_value_lws
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, s_header_almost_done
Avoid chunk header parsing overflow. Recharacterize the chunk header states such that they are bound by the check for HTTP_MAX_HEADER_SIZE.
14 years ago
, s_chunk_size_start
, s_chunk_size
, s_chunk_parameters
, s_chunk_size_almost_done
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, s_headers_almost_done
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
, s_headers_done
/* Important: 's_headers_done' must be the last 'header' state. All
Only allow 80kb of header bytes
15 years ago
* states beyond this must be 'body' states. It is used for overflow
* checking. See the PARSING_HEADER() macro.
*/
Avoid chunk header parsing overflow. Recharacterize the chunk header states such that they are bound by the check for HTTP_MAX_HEADER_SIZE.
14 years ago
better output for test_scan
16 years ago
, s_chunk_data
, s_chunk_data_almost_done
, s_chunk_data_done
Handling chunked messages
16 years ago
Now parsing some req headers
16 years ago
, s_body_identity
, s_body_identity_eof
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
, s_message_done
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
};
Fix long chunked message bug The HTTP_MAX_HEADER_SIZE was being consulted at the end of the chunked message (when you look for trailing headers). http://github.com/ry/node/issues#issue/77
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
#define PARSING_HEADER(state) (state <= s_headers_done)
Only allow 80kb of header bytes
15 years ago
Tasteful vertical whitespace.
15 years ago
Remove EOL whitespace
16 years ago
enum header_states
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{ h_general = 0
, h_C
, h_CO
, h_CON
better output for test_scan
16 years ago
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, h_matching_connection
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
, h_matching_proxy_connection
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, h_matching_content_length
, h_matching_transfer_encoding
Support Upgrade header
15 years ago
, h_matching_upgrade
better output for test_scan
16 years ago
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
, h_connection
, h_content_length
, h_transfer_encoding
Support Upgrade header
15 years ago
, h_upgrade
better output for test_scan
16 years ago
, h_matching_transfer_encoding_chunked
, h_matching_connection_keep_alive
, h_matching_connection_close
, h_transfer_encoding_chunked
, h_connection_keep_alive
, h_connection_close
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
};
Refactor host parsing to allow basic auth management
13 years ago
enum http_host_state
{
s_http_host_dead = 1
User info implementation
13 years ago
, s_http_userinfo_start
, s_http_userinfo
Refactor host parsing to allow basic auth management
13 years ago
, s_http_host_start
, s_http_host_v6_start
, s_http_host
, s_http_host_v6
, s_http_host_v6_end
, s_http_host_port_start
, s_http_host_port
};
Tasteful vertical whitespace.
15 years ago
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
/* Macros for character classes; depends on strict-mode */
#define CR '\r'
#define LF '\n'
#define LOWER(c) (unsigned char)(c | 0x20)
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
#define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z')
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
#define IS_NUM(c) ((c) >= '0' && (c) <= '9')
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
#define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c))
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
#define IS_HEX(c) (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f'))
Coding style improvment
13 years ago
#define IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \
(c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \
(c) == ')')
#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \
(c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \
(c) == '$' || (c) == ',')
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
#if HTTP_PARSER_STRICT
Remove some chars from tokens[] per RFC. - Treat ' ' specially, as apparently IIS6.0 can send this in headers. Allow this character through if we're not in strict mode. - Move some test code around so that test indices don't break when HTTP_PARSER_STRICT changes. Fixes #13.
14 years ago
#define TOKEN(c) (tokens[(unsigned char)c])
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
#define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c))
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
#define IS_HOST_CHAR(c) (IS_ALPHANUM(c) || (c) == '.' || (c) == '-')
#else
Remove some chars from tokens[] per RFC. - Treat ' ' specially, as apparently IIS6.0 can send this in headers. Allow this character through if we're not in strict mode. - Move some test code around so that test indices don't break when HTTP_PARSER_STRICT changes. Fixes #13.
14 years ago
#define TOKEN(c) ((c == ' ') ? ' ' : tokens[(unsigned char)c])
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
#define IS_URL_CHAR(c) \
Turn normal_url_char into a bit array. Makes http_parser slightly more cache friendly.
13 years ago
(BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80))
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
#define IS_HOST_CHAR(c) \
(IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_')
#endif
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Tasteful vertical whitespace.
15 years ago
API: Define parser type in http_parser_init() That is, for a request parser do this: http_parser_init(my_parser, HTTP_REQUEST) for a response parser do this: http_parser_init(my_parser, HTTP_RESPONSE) Then http_parse_requests() and http_parse_responses() both turn into http_parer_execute().
16 years ago
#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
Tasteful vertical whitespace.
15 years ago
strict check
16 years ago
#if HTTP_PARSER_STRICT
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
# define STRICT_CHECK(cond) \
do { \
if (cond) { \
SET_ERRNO(HPE_STRICT); \
goto error; \
} \
} while (0)
Only use s_dead in STRICT mode.
16 years ago
# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
Remove EOL whitespace
16 years ago
#else
# define STRICT_CHECK(cond)
Only use s_dead in STRICT mode.
16 years ago
# define NEW_MESSAGE() start_state
strict check
16 years ago
#endif
Tasteful vertical whitespace.
15 years ago
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
/* 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
Make http_should_keep_alive() const correct.
13 years ago
int http_message_needs_eof(const http_parser *parser);
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
/* Our URL parser.
*
* This is designed to be shared by http_parser_execute() for URL validation,
* hence it has a state transition + byte-for-byte interface. In addition, it
* is meant to be embedded in http_parser_parse_url(), which does the dirty
* work of turning state transitions URL components for its API.
*
* This function should only be invoked with non-space characters. It is
* assumed that the caller cares about (and can detect) the transition between
* URL and non-URL states by looking for these.
*/
Don't use 'inline'. 'inline' is not a recognized C89 keyword, it made the build fail with strict or older compilers (msvc 2008, gcc with -std=c89). 'inline' is also just a hint, one that gcc 4.4.3 in this particular case happily ignored. Ergo, remove it.
13 years ago
static enum state
Use new state instead of pointer
13 years ago
parse_url_char(enum state s, const char ch)
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
{
Don't assert() on whitespace in URL. Be lenient about tabs and form feeds in non-strict mode.
13 years ago
if (ch == ' ' || ch == '\r' || ch == '\n') {
return s_dead;
}
#if HTTP_PARSER_STRICT
if (ch == '\t' || ch == '\f') {
return s_dead;
}
#endif
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
switch (s) {
case s_req_spaces_before_url:
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
/* Proxied requests are followed by scheme of an absolute URI (alpha).
* All methods except CONNECT are followed by '/' or '*'.
*/
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
if (ch == '/' || ch == '*') {
return s_req_path;
}
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
if (IS_ALPHA(ch)) {
return s_req_schema;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
}
break;
case s_req_schema:
if (IS_ALPHA(ch)) {
return s;
}
if (ch == ':') {
return s_req_schema_slash;
}
break;
case s_req_schema_slash:
if (ch == '/') {
return s_req_schema_slash_slash;
}
break;
case s_req_schema_slash_slash:
if (ch == '/') {
Rename s_req_host* to be compliant with RFC 2396
13 years ago
return s_req_server_start;
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
}
break;
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_with_at:
Use new state instead of pointer
13 years ago
if (ch == '@') {
return s_dead;
}
/* FALLTHROUGH */
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_start:
case s_req_server:
Refactor host parsing to allow basic auth management
13 years ago
if (ch == '/') {
return s_req_path;
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
Refactor host parsing to allow basic auth management
13 years ago
if (ch == '?') {
return s_req_query_string_start;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
}
User info implementation
13 years ago
if (ch == '@') {
Rename s_req_host* to be compliant with RFC 2396
13 years ago
return s_req_server_with_at;
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
}
Minor speed improvment
13 years ago
if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') {
Rename s_req_host* to be compliant with RFC 2396
13 years ago
return s_req_server;
Minor speed improvment
13 years ago
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
break;
case s_req_path:
if (IS_URL_CHAR(ch)) {
return s;
}
switch (ch) {
case '?':
return s_req_query_string_start;
case '#':
return s_req_fragment_start;
}
break;
case s_req_query_string_start:
case s_req_query_string:
if (IS_URL_CHAR(ch)) {
allow extra ? at the beginning of a query_string. fixes joyent/http-parser issue #25
13 years ago
return s_req_query_string;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
}
switch (ch) {
case '?':
/* allow extra '?' in query string */
allow extra ? at the beginning of a query_string. fixes joyent/http-parser issue #25
13 years ago
return s_req_query_string;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
case '#':
return s_req_fragment_start;
}
break;
case s_req_fragment_start:
if (IS_URL_CHAR(ch)) {
return s_req_fragment;
}
switch (ch) {
case '?':
return s_req_fragment;
case '#':
return s;
}
break;
case s_req_fragment:
if (IS_URL_CHAR(ch)) {
return s;
}
switch (ch) {
case '?':
case '#':
return s;
}
break;
default:
break;
}
/* We should never fall out of the switch above unless there's an error */
return s_dead;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
API: Define parser type in http_parser_init() That is, for a request parser do this: http_parser_init(my_parser, HTTP_REQUEST) for a response parser do this: http_parser_init(my_parser, HTTP_RESPONSE) Then http_parse_requests() and http_parse_responses() both turn into http_parer_execute().
16 years ago
size_t http_parser_execute (http_parser *parser,
pass pointer to settings structure rather than pass by value
15 years ago
const http_parser_settings *settings,
API: Define parser type in http_parser_init() That is, for a request parser do this: http_parser_init(my_parser, HTTP_REQUEST) for a response parser do this: http_parser_init(my_parser, HTTP_RESPONSE) Then http_parse_requests() and http_parse_responses() both turn into http_parer_execute().
16 years ago
const char *data,
size_t len)
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
Remove EOL whitespace
16 years ago
char c, ch;
Fix build when char is unsigned by default. I tested by building/testing with -funsigned-char. Thanks to apaprocki for pointing out this problem.
14 years ago
int8_t unhex_val;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
const char *p = data;
Move all data to before code to fix http parser for c89.
14 years ago
const char *header_field_mark = 0;
const char *header_value_mark = 0;
const char *url_mark = 0;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
const char *body_mark = 0;
Parse and emit status message of response
12 years ago
const char *status_mark = 0;
Move all data to before code to fix http parser for c89.
14 years ago
Break out errno into its own field.
14 years ago
/* We're in an error state. Don't bother doing anything. */
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
return 0;
}
Handling chunked messages
16 years ago
if (len == 0) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
switch (parser->state) {
Detect errors on EOF
14 years ago
case s_body_identity_eof:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if
* we got paused.
*/
CALLBACK_NOTIFY_NOADVANCE(message_complete);
Detect errors on EOF
14 years ago
return 0;
case s_dead:
case s_start_req_or_res:
case s_start_res:
case s_start_req:
return 0;
default:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_EOF_STATE);
return 1;
Handling chunked messages
16 years ago
}
Now parsing some req headers
16 years ago
}
reduce the size of the http_parser struct The *_mark members were actually being used as just boolean values to the next call of the parser. However, you can calculate if the mark members should be set or not purely based on the current state, so they can just be gotten rid of entirely.
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->state == s_header_field)
reduce the size of the http_parser struct The *_mark members were actually being used as just boolean values to the next call of the parser. However, you can calculate if the mark members should be set or not purely based on the current state, so they can just be gotten rid of entirely.
15 years ago
header_field_mark = data;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->state == s_header_value)
reduce the size of the http_parser struct The *_mark members were actually being used as just boolean values to the next call of the parser. However, you can calculate if the mark members should be set or not purely based on the current state, so they can just be gotten rid of entirely.
15 years ago
header_value_mark = data;
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
switch (parser->state) {
case s_req_path:
case s_req_schema:
case s_req_schema_slash:
case s_req_schema_slash_slash:
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_start:
case s_req_server:
case s_req_server_with_at:
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
case s_req_query_string_start:
case s_req_query_string:
case s_req_fragment_start:
case s_req_fragment:
reduce the size of the http_parser struct The *_mark members were actually being used as just boolean values to the next call of the parser. However, you can calculate if the mark members should be set or not purely based on the current state, so they can just be gotten rid of entirely.
15 years ago
url_mark = data;
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
break;
Parse and emit status message of response
12 years ago
case s_res_status:
status_mark = data;
break;
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
for (p=data; p != data + len; p++) {
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
ch = *p;
Only allow 80kb of header bytes
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (PARSING_HEADER(parser->state)) {
++parser->nread;
Update misleading comment. The HTTP_MAX_HEADER_SIZE check is not there to guard against buffer overflows, it's there to protect unwitting embedders against denial-of-service attacks.
12 years ago
/* Don't allow the total size of the HTTP headers (including the status
* line) to exceed HTTP_MAX_HEADER_SIZE. This check is here to protect
* embedders against denial-of-service attacks where the attacker feeds
* us a never-ending header that the embedder keeps buffering.
*
* This check is arguably the responsibility of embedders but we're doing
* it on the embedder's behalf because most won't bother and this way we
* make the web a little safer. HTTP_MAX_HEADER_SIZE is still far bigger
* than any reasonable request or response so this should never affect
* day-to-day operation.
*/
Allow HTTP_MAX_HEADER_SIZE to be defined externally
11 years ago
if (parser->nread > (HTTP_MAX_HEADER_SIZE)) {
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_HEADER_OVERFLOW);
goto error;
}
Only allow 80kb of header bytes
15 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
reexecute_byte:
switch (parser->state) {
Passing tests
16 years ago
add http_should_keep_alive()
16 years ago
case s_dead:
/* this state is used after a 'Connection: close' message
* the parser will error out if it reads another message
*/
Eat CRLF between requests, even on connection:close. Fixes #47.
14 years ago
if (ch == CR || ch == LF)
break;
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_CLOSED_CONNECTION);
Use error label, instead of returning directly
16 years ago
goto error;
add http_should_keep_alive()
16 years ago
Fix typo s_start_res_or_resp
15 years ago
case s_start_req_or_res:
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
{
if (ch == CR || ch == LF)
break;
parser->flags = 0;
Make content_length unsigned, add overflow checks.
13 years ago
parser->content_length = ULLONG_MAX;
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (ch == 'H') {
parser->state = s_res_or_resp_H;
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
CALLBACK_NOTIFY(message_begin);
} else {
Fix whitespace
15 years ago
parser->type = HTTP_REQUEST;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_start_req;
goto reexecute_byte;
Fix whitespace
15 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
Fix whitespace
15 years ago
break;
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
}
case s_res_or_resp_H:
Fix whitespace
15 years ago
if (ch == 'T') {
parser->type = HTTP_RESPONSE;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_HT;
Fix whitespace
15 years ago
} else {
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (ch != 'E') {
SET_ERRNO(HPE_INVALID_CONSTANT);
goto error;
}
Fix whitespace
15 years ago
parser->type = HTTP_REQUEST;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
parser->method = HTTP_HEAD;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index = 2;
parser->state = s_req_method;
Fix whitespace
15 years ago
}
break;
add support for HTTP_BOTH This is good for analyzing raw streams of data when one is not sure which direction it will be in.
15 years ago
Passing tests
16 years ago
case s_start_res:
{
parser->flags = 0;
Make content_length unsigned, add overflow checks.
13 years ago
parser->content_length = ULLONG_MAX;
Passing tests
16 years ago
switch (ch) {
case 'H':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_H;
Passing tests
16 years ago
break;
case CR:
case LF:
break;
default:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_CONSTANT);
Use error label, instead of returning directly
16 years ago
goto error;
Passing tests
16 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
CALLBACK_NOTIFY(message_begin);
Passing tests
16 years ago
break;
}
case s_res_H:
strict check
16 years ago
STRICT_CHECK(ch != 'T');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_HT;
Passing tests
16 years ago
break;
case s_res_HT:
strict check
16 years ago
STRICT_CHECK(ch != 'T');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_HTT;
Passing tests
16 years ago
break;
Remove EOL whitespace
16 years ago
case s_res_HTT:
strict check
16 years ago
STRICT_CHECK(ch != 'P');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_HTTP;
Passing tests
16 years ago
break;
case s_res_HTTP:
strict check
16 years ago
STRICT_CHECK(ch != '/');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_first_http_major;
Passing tests
16 years ago
break;
case s_res_first_http_major:
Accept HTTP/0.9 responses See joyent/node#1711
14 years ago
if (ch < '0' || ch > '9') {
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
parser->http_major = ch - '0';
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_http_major;
Passing tests
16 years ago
break;
/* major HTTP version or dot */
case s_res_http_major:
{
if (ch == '.') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_first_http_minor;
Passing tests
16 years ago
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
parser->http_major *= 10;
parser->http_major += ch - '0';
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (parser->http_major > 999) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
break;
}
Remove EOL whitespace
16 years ago
Passing tests
16 years ago
/* first digit of minor HTTP version */
case s_res_first_http_minor:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
parser->http_minor = ch - '0';
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_http_minor;
Passing tests
16 years ago
break;
/* minor HTTP version or end of request line */
case s_res_http_minor:
{
if (ch == ' ') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_first_status_code;
Passing tests
16 years ago
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
parser->http_minor *= 10;
parser->http_minor += ch - '0';
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (parser->http_minor > 999) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
Passing tests
16 years ago
break;
}
case s_res_first_status_code:
{
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
if (!IS_NUM(ch)) {
Passing tests
16 years ago
if (ch == ' ') {
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_STATUS);
Use error label, instead of returning directly
16 years ago
goto error;
Passing tests
16 years ago
}
parser->status_code = ch - '0';
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_status_code;
Passing tests
16 years ago
break;
}
case s_res_status_code:
{
IS_* macros for char classes. - Add IS_ALPHA(), IS_NUM(), IS_HOST_CHAR(), etc. macros for determining membership in a character class. HTTP_PARSER_STRICT causes some of these definitions to change. - Support '_' character in hostnames in non-strict mode. - Support leading digits in hostnames when the method is HTTP_CONNECT. - Don't re-define HTTP_PARSER_STRICT in http_parser.h if it's already defined. - Tweak Makefile to run non-strict-mode unit tests. Rearrange non-strict mode unit tests in test.c. - Add test_fast to .gitignore. Fixes #44
14 years ago
if (!IS_NUM(ch)) {
Passing tests
16 years ago
switch (ch) {
case ' ':
Parse and emit status message of response
12 years ago
parser->state = s_res_status_start;
Passing tests
16 years ago
break;
case CR:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_line_almost_done;
Passing tests
16 years ago
break;
case LF:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
Passing tests
16 years ago
break;
default:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_STATUS);
Use error label, instead of returning directly
16 years ago
goto error;
Passing tests
16 years ago
}
break;
}
parser->status_code *= 10;
parser->status_code += ch - '0';
strict check
16 years ago
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (parser->status_code > 999) {
SET_ERRNO(HPE_INVALID_STATUS);
goto error;
}
Passing tests
16 years ago
break;
}
Parse and emit status message of response
12 years ago
case s_res_status_start:
{
if (ch == CR) {
parser->state = s_res_line_almost_done;
break;
}
if (ch == LF) {
parser->state = s_header_field_start;
break;
}
MARK(status);
parser->state = s_res_status;
parser->index = 0;
break;
}
Passing tests
16 years ago
case s_res_status:
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_res_line_almost_done;
Parse and emit status message of response
12 years ago
CALLBACK_DATA(status);
Passing tests
16 years ago
break;
}
if (ch == LF) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
Parse and emit status message of response
12 years ago
CALLBACK_DATA(status);
Passing tests
16 years ago
break;
}
Parse and emit status message of response
12 years ago
Passing tests
16 years ago
break;
case s_res_line_almost_done:
strict check
16 years ago
STRICT_CHECK(ch != LF);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
Passing tests
16 years ago
break;
change around api
16 years ago
case s_start_req:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
Allow newlines before HTTP requests. I have seen cases where a browser will POST data, and then send an extra CRLF before issuing the next request.
15 years ago
if (ch == CR || ch == LF)
break;
Now parsing some req headers
16 years ago
parser->flags = 0;
Make content_length unsigned, add overflow checks.
13 years ago
parser->content_length = ULLONG_MAX;
Now parsing some req headers
16 years ago
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
if (!IS_ALPHA(ch)) {
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_METHOD);
goto error;
}
accept webdav methods
16 years ago
Fix c++ and mac compile errors
15 years ago
parser->method = (enum http_method) 0;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index = 1;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
switch (ch) {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
case 'D': parser->method = HTTP_DELETE; break;
case 'G': parser->method = HTTP_GET; break;
case 'H': parser->method = HTTP_HEAD; break;
case 'L': parser->method = HTTP_LOCK; break;
Added support for MKCALENDAR Signed-off-by: Fedor Indutny <fedor@indutny.com>
11 years ago
case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break;
Add support for "M-SEARCH" and "NOTIFY" request methods. Allow a request path of "*" (for SSDP requests).
15 years ago
case 'N': parser->method = HTTP_NOTIFY; break;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
case 'O': parser->method = HTTP_OPTIONS; break;
Support PATCH method Requested in https://groups.google.com/forum/#!topic/nodejs-dev/iEOyiDkJRLs
14 years ago
case 'P': parser->method = HTTP_POST;
Support PURGE request method. Fixes joyent/node#2775.
13 years ago
/* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */
Support PATCH method Requested in https://groups.google.com/forum/#!topic/nodejs-dev/iEOyiDkJRLs
14 years ago
break;
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
case 'R': parser->method = HTTP_REPORT; break;
add support for "SEARCH" request methods
13 years ago
case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH */ break;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
case 'T': parser->method = HTTP_TRACE; break;
Added support for "SUBSCRIBE" and "UNSUBSCRIBE" request methods.
15 years ago
case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break;
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
default:
SET_ERRNO(HPE_INVALID_METHOD);
goto error;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_method;
CALLBACK_NOTIFY(message_begin);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
Passing tests
16 years ago
Reimplement support for extension methods This sacrifices - a little space (10 bytes), - a few extra calculations, and - introduces a dependency on strncmp() to dramatically simplify the code of parsing methods and support almost arbitrary extension methods. In the future I will do as NGINX does and not use strncmp but bit level blob comparisons.
16 years ago
case s_req_method:
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
{
Move all data to before code to fix http parser for c89.
14 years ago
const char *matcher;
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (ch == '\0') {
SET_ERRNO(HPE_INVALID_METHOD);
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
goto error;
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Move all data to before code to fix http parser for c89.
14 years ago
matcher = method_strings[parser->method];
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (ch == ' ' && matcher[parser->index] == '\0') {
parser->state = s_req_spaces_before_url;
} else if (ch == matcher[parser->index]) {
Replace C++ style comments with C comments so it compiles with `gcc -ansi -Wall`
15 years ago
; /* nada */
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
} else if (parser->method == HTTP_CONNECT) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->index == 1 && ch == 'H') {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
parser->method = HTTP_CHECKOUT;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 2 && ch == 'P') {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
parser->method = HTTP_COPY;
Return error when bad method starts with M or C
14 years ago
} else {
Further request method check strengthening.
12 years ago
SET_ERRNO(HPE_INVALID_METHOD);
Return error when bad method starts with M or C
14 years ago
goto error;
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
}
} else if (parser->method == HTTP_MKCOL) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->index == 1 && ch == 'O') {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
parser->method = HTTP_MOVE;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 1 && ch == 'E') {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
parser->method = HTTP_MERGE;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 1 && ch == '-') {
Add support for "M-SEARCH" and "NOTIFY" request methods. Allow a request path of "*" (for SSDP requests).
15 years ago
parser->method = HTTP_MSEARCH;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 2 && ch == 'A') {
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
parser->method = HTTP_MKACTIVITY;
Added support for MKCALENDAR Signed-off-by: Fedor Indutny <fedor@indutny.com>
11 years ago
} else if (parser->index == 3 && ch == 'A') {
parser->method = HTTP_MKCALENDAR;
Return error when bad method starts with M or C
14 years ago
} else {
Further request method check strengthening.
12 years ago
SET_ERRNO(HPE_INVALID_METHOD);
Return error when bad method starts with M or C
14 years ago
goto error;
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
}
add support for "SEARCH" request methods
13 years ago
} else if (parser->method == HTTP_SUBSCRIBE) {
if (parser->index == 1 && ch == 'E') {
parser->method = HTTP_SEARCH;
} else {
Do not accept PUN/GEM methods as PUT/GET. * Encountering them returns an error, `HPE_INVALID_METHOD` * Tests have been added.
12 years ago
SET_ERRNO(HPE_INVALID_METHOD);
add support for "SEARCH" request methods
13 years ago
goto error;
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 1 && parser->method == HTTP_POST) {
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
if (ch == 'R') {
parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */
} else if (ch == 'U') {
Support PURGE request method. Fixes joyent/node#2775.
13 years ago
parser->method = HTTP_PUT; /* or HTTP_PURGE */
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
} else if (ch == 'A') {
parser->method = HTTP_PATCH;
} else {
Do not accept PUN/GEM methods as PUT/GET. * Encountering them returns an error, `HPE_INVALID_METHOD` * Tests have been added.
12 years ago
SET_ERRNO(HPE_INVALID_METHOD);
Group POST refinements, test all request methods, make IS_ALPHA use LOWER internally
14 years ago
goto error;
}
Support PURGE request method. Fixes joyent/node#2775.
13 years ago
} else if (parser->index == 2) {
if (parser->method == HTTP_PUT) {
Do not accept PUN/GEM methods as PUT/GET. * Encountering them returns an error, `HPE_INVALID_METHOD` * Tests have been added.
12 years ago
if (ch == 'R') {
parser->method = HTTP_PURGE;
} else {
SET_ERRNO(HPE_INVALID_METHOD);
goto error;
}
Support PURGE request method. Fixes joyent/node#2775.
13 years ago
} else if (parser->method == HTTP_UNLOCK) {
Do not accept PUN/GEM methods as PUT/GET. * Encountering them returns an error, `HPE_INVALID_METHOD` * Tests have been added.
12 years ago
if (ch == 'S') {
parser->method = HTTP_UNSUBSCRIBE;
} else {
SET_ERRNO(HPE_INVALID_METHOD);
goto error;
}
} else {
SET_ERRNO(HPE_INVALID_METHOD);
goto error;
Support PURGE request method. Fixes joyent/node#2775.
13 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
} else if (parser->index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') {
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
parser->method = HTTP_PROPPATCH;
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
} else {
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_METHOD);
Reimplement support for extension methods This sacrifices - a little space (10 bytes), - a few extra calculations, and - introduces a dependency on strncmp() to dramatically simplify the code of parsing methods and support almost arbitrary extension methods. In the future I will do as NGINX does and not use strncmp but bit level blob comparisons.
16 years ago
goto error;
Add subversion request methods REPORT, MKACTIVITY, CHECKOUT, MERGE
15 years ago
}
accept webdav methods
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
++parser->index;
accept webdav methods
16 years ago
break;
save more space by removing buffer and shortening method This also fixes test failures from the previous commit. It also adds support for the LOCK method, which was previously missing. This brings the size of http_parser from 44 bytes to 32 bytes. It also makes the code substantially shorter, at a slight cost in craziness.
15 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
Passing tests
16 years ago
case s_req_spaces_before_url:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
if (ch == ' ') break;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
MARK(url);
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
if (parser->method == HTTP_CONNECT) {
Rename s_req_host* to be compliant with RFC 2396
13 years ago
parser->state = s_req_server_start;
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Use new state instead of pointer
13 years ago
parser->state = parse_url_char((enum state)parser->state, ch);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->state == s_dead) {
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
SET_ERRNO(HPE_INVALID_URL);
goto error;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Passing tests
16 years ago
case s_req_schema:
case s_req_schema_slash:
case s_req_schema_slash_slash:
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_start:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
switch (ch) {
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
/* No whitespace allowed here */
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
case ' ':
case CR:
case LF:
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
SET_ERRNO(HPE_INVALID_URL);
Use error label, instead of returning directly
16 years ago
goto error;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
default:
Use new state instead of pointer
13 years ago
parser->state = parse_url_char((enum state)parser->state, ch);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->state == s_dead) {
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
SET_ERRNO(HPE_INVALID_URL);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Now parsing some req headers
16 years ago
break;
}
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server:
case s_req_server_with_at:
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
case s_req_path:
case s_req_query_string_start:
case s_req_query_string:
Passing tests
16 years ago
case s_req_fragment_start:
case s_req_fragment:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
switch (ch) {
case ' ':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_start;
CALLBACK_DATA(url);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
case CR:
case LF:
Set http_major when a request omits the HTTP version I.E. "GET /" in telnet
15 years ago
parser->http_major = 0;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
parser->http_minor = 9;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = (ch == CR) ?
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
s_req_line_almost_done :
s_header_field_start;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
CALLBACK_DATA(url);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
default:
Use new state instead of pointer
13 years ago
parser->state = parse_url_char((enum state)parser->state, ch);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->state == s_dead) {
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
SET_ERRNO(HPE_INVALID_URL);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
}
Passing tests
16 years ago
case s_req_http_start:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
switch (ch) {
case 'H':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_H;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
case ' ':
break;
default:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_CONSTANT);
Use error label, instead of returning directly
16 years ago
goto error;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
Passing tests
16 years ago
case s_req_http_H:
strict check
16 years ago
STRICT_CHECK(ch != 'T');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_HT;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Passing tests
16 years ago
case s_req_http_HT:
strict check
16 years ago
STRICT_CHECK(ch != 'T');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_HTT;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Passing tests
16 years ago
case s_req_http_HTT:
strict check
16 years ago
STRICT_CHECK(ch != 'P');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_HTTP;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Passing tests
16 years ago
case s_req_http_HTTP:
strict check
16 years ago
STRICT_CHECK(ch != '/');
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_first_http_major;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
/* first digit of major HTTP version */
strict check
16 years ago
case s_req_first_http_major:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (ch < '1' || ch > '9') {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
parser->http_major = ch - '0';
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_major;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
/* major HTTP version or dot */
strict check
16 years ago
case s_req_http_major:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
if (ch == '.') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_first_http_minor;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
parser->http_major *= 10;
parser->http_major += ch - '0';
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (parser->http_major > 999) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
/* first digit of minor HTTP version */
strict check
16 years ago
case s_req_first_http_minor:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
parser->http_minor = ch - '0';
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_http_minor;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
/* minor HTTP version or end of request line */
strict check
16 years ago
case s_req_http_minor:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
{
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_req_line_almost_done;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
if (ch == LF) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
/* XXX allow spaces after digit? */
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
parser->http_minor *= 10;
parser->http_minor += ch - '0';
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (parser->http_minor > 999) {
SET_ERRNO(HPE_INVALID_VERSION);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
/* end of request line */
case s_req_line_almost_done:
{
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (ch != LF) {
SET_ERRNO(HPE_LF_EXPECTED);
goto error;
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
case s_header_field_start:
{
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_headers_almost_done;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
if (ch == LF) {
Bugfix: sometimes servers send \n instead of \r\n
16 years ago
/* they might be just sending \n instead of \r\n so this would be
* the second \n to denote the end of headers*/
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_headers_almost_done;
goto reexecute_byte;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Accept tokens + SP for header fields
15 years ago
c = TOKEN(ch);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!c) {
SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
goto error;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
MARK(header_field);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index = 0;
parser->state = s_header_field;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
switch (c) {
case 'c':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_C;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
case 'p':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_proxy_connection;
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
case 't':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_transfer_encoding;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Support Upgrade header
15 years ago
case 'u':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_upgrade;
Support Upgrade header
15 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
default:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
break;
}
case s_header_field:
{
Accept tokens + SP for header fields
15 years ago
c = TOKEN(ch);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
if (c) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
switch (parser->header_state) {
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
case h_general:
break;
case h_C:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
parser->header_state = (c == 'o' ? h_CO : h_general);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
case h_CO:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
parser->header_state = (c == 'n' ? h_CON : h_general);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
case h_CON:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
switch (c) {
case 'n':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_connection;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
case 't':
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_content_length;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
default:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
break;
/* connection */
case h_matching_connection:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(CONNECTION)-1
|| c != CONNECTION[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(CONNECTION)-2) {
parser->header_state = h_connection;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
/* proxy-connection */
case h_matching_proxy_connection:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(PROXY_CONNECTION)-1
|| c != PROXY_CONNECTION[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(PROXY_CONNECTION)-2) {
parser->header_state = h_connection;
Support 'Proxy-Connection' header See http://www.http-stats.com/Proxy-Connection
16 years ago
}
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
/* content-length */
case h_matching_content_length:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(CONTENT_LENGTH)-1
|| c != CONTENT_LENGTH[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(CONTENT_LENGTH)-2) {
parser->header_state = h_content_length;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
/* transfer-encoding */
case h_matching_transfer_encoding:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(TRANSFER_ENCODING)-1
|| c != TRANSFER_ENCODING[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(TRANSFER_ENCODING)-2) {
parser->header_state = h_transfer_encoding;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
Support Upgrade header
15 years ago
/* upgrade */
case h_matching_upgrade:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(UPGRADE)-1
|| c != UPGRADE[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(UPGRADE)-2) {
parser->header_state = h_upgrade;
Support Upgrade header
15 years ago
}
break;
better output for test_scan
16 years ago
case h_connection:
case h_content_length:
Handling chunked messages
16 years ago
case h_transfer_encoding:
Support Upgrade header
15 years ago
case h_upgrade:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (ch != ' ') parser->header_state = h_general;
Handling chunked messages
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
default:
assert(0 && "Unknown header_state");
break;
}
Now parsing some req headers
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
if (ch == ':') {
Include separating ws when folding header values The support for folding of multi-line header values does not conform to the specs. Given a request containing Multi-Line-Header: foo<CRLF> bar<CRLF> http-parser will eliminate the whitespace breaking the header value to yield a header value of "foobar". This is confirmed by the LINE_FOLDING_IN_HEADER case in tests.c. But from rfc2616, section 2.2: A CRLF is allowed in the definition of TEXT only as part of a header field continuation. It is expected that the folding LWS will be replaced with a single SP before interpretation of the TEXT value. And from draft-ietf-httpbis-p1-messaging-25, section 3.2.4: A server that receives an obs-fold in a request message that is not within a message/http container MUST either reject the message by sending a 400 (Bad Request), preferably with a representation explaining that obsolete line folding is unacceptable, or replace each received obs-fold with one or more SP octets prior to interpreting the field value or forwarding the message downstream. So in the example above, the header value should be interpreted as "foo bar", possibly with multiple spaces. The current http-parser behaviour of eliminating the LWS altogether clearly deviates from the specs. For http-parser itself to confirm exactly would involve significant changes in order to synthesize replacement SP octets. Such changes are unlikely to be worth it to support what is an obscure and deprecated feature. But http-parser should at least preserve some separating whitespace when folding multi-line header values, so that applications using http-parser can conform to the specs. This commit is a minimal change to preserve whitespace when folding lines. It eliminates the CRLF, but retains any trailing and leading whitespace in the header value.
12 years ago
parser->state = s_header_value_discard_ws;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
CALLBACK_DATA(header_field);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
Use error label, instead of returning directly
16 years ago
goto error;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Include separating ws when folding header values The support for folding of multi-line header values does not conform to the specs. Given a request containing Multi-Line-Header: foo<CRLF> bar<CRLF> http-parser will eliminate the whitespace breaking the header value to yield a header value of "foobar". This is confirmed by the LINE_FOLDING_IN_HEADER case in tests.c. But from rfc2616, section 2.2: A CRLF is allowed in the definition of TEXT only as part of a header field continuation. It is expected that the folding LWS will be replaced with a single SP before interpretation of the TEXT value. And from draft-ietf-httpbis-p1-messaging-25, section 3.2.4: A server that receives an obs-fold in a request message that is not within a message/http container MUST either reject the message by sending a 400 (Bad Request), preferably with a representation explaining that obsolete line folding is unacceptable, or replace each received obs-fold with one or more SP octets prior to interpreting the field value or forwarding the message downstream. So in the example above, the header value should be interpreted as "foo bar", possibly with multiple spaces. The current http-parser behaviour of eliminating the LWS altogether clearly deviates from the specs. For http-parser itself to confirm exactly would involve significant changes in order to synthesize replacement SP octets. Such changes are unlikely to be worth it to support what is an obscure and deprecated feature. But http-parser should at least preserve some separating whitespace when folding multi-line header values, so that applications using http-parser can conform to the specs. This commit is a minimal change to preserve whitespace when folding lines. It eliminates the CRLF, but retains any trailing and leading whitespace in the header value.
12 years ago
case s_header_value_discard_ws:
Support multi-line folding in header values. Normal value cb is called for subsequent lines. LWS is skipped. Note that \t whitespace character is now supported after header field name. RFC 2616, Section 2.2 "HTTP/1.1 header field values can be folded onto multiple lines if the continuation line begins with a space or horizontal tab. All linear white space, including folding, has the same semantics as SP. A recipient MAY replace any linear white space with a single SP before interpreting the field value or forwarding the message downstream."
14 years ago
if (ch == ' ' || ch == '\t') break;
Handling chunked messages
16 years ago
Remove acceptable_header array This was not necessary, as it was just being used as a downcase function.
15 years ago
if (ch == CR) {
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
parser->state = s_header_value_discard_ws_almost_done;
Remove acceptable_header array This was not necessary, as it was just being used as a downcase function.
15 years ago
break;
}
if (ch == LF) {
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
parser->state = s_header_value_discard_lws;
strict check
16 years ago
break;
Remove EOL whitespace
16 years ago
}
Now parsing some req headers
16 years ago
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
/* FALLTHROUGH */
case s_header_value_start:
{
MARK(header_value);
parser->state = s_header_value;
parser->index = 0;
moved unecessary lookup
15 years ago
c = LOWER(ch);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
switch (parser->header_state) {
Support Upgrade header
15 years ago
case h_upgrade:
parser->flags |= F_UPGRADE;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
Support Upgrade header
15 years ago
break;
strict check
16 years ago
case h_transfer_encoding:
/* looking for 'Transfer-Encoding: chunked' */
if ('c' == c) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_transfer_encoding_chunked;
strict check
16 years ago
} else {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
strict check
16 years ago
}
break;
Now parsing some req headers
16 years ago
strict check
16 years ago
case h_content_length:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
goto error;
}
strict check
16 years ago
parser->content_length = ch - '0';
break;
Now parsing some req headers
16 years ago
strict check
16 years ago
case h_connection:
/* looking for 'Connection: keep-alive' */
if (c == 'k') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_connection_keep_alive;
strict check
16 years ago
/* looking for 'Connection: close' */
} else if (c == 'c') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_matching_connection_close;
strict check
16 years ago
} else {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
strict check
16 years ago
}
break;
default:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->header_state = h_general;
strict check
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Now parsing some req headers
16 years ago
break;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Now parsing some req headers
16 years ago
case s_header_value:
{
Remove acceptable_header array This was not necessary, as it was just being used as a downcase function.
15 years ago
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_almost_done;
CALLBACK_DATA(header_value);
Now parsing some req headers
16 years ago
break;
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Remove acceptable_header array This was not necessary, as it was just being used as a downcase function.
15 years ago
if (ch == LF) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_almost_done;
CALLBACK_DATA_NOADVANCE(header_value);
goto reexecute_byte;
Remove acceptable_header array This was not necessary, as it was just being used as a downcase function.
15 years ago
}
moved unecessary lookup
15 years ago
c = LOWER(ch);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
switch (parser->header_state) {
better output for test_scan
16 years ago
case h_general:
break;
Now parsing some req headers
16 years ago
case h_connection:
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
case h_transfer_encoding:
Now parsing some req headers
16 years ago
assert(0 && "Shouldn't get here.");
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
case h_content_length:
Make content_length unsigned, add overflow checks.
13 years ago
{
uint64_t t;
Allow whitespace in the 'Content-Length' header.
15 years ago
if (ch == ' ') break;
Make content_length unsigned, add overflow checks.
13 years ago
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (!IS_NUM(ch)) {
SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
goto error;
}
Make content_length unsigned, add overflow checks.
13 years ago
t = parser->content_length;
t *= 10;
t += ch - '0';
fix content-length and chunk-size overflow test The overflow check didn't work for all possible inputs.
11 years ago
/* Overflow? Test against a conservative limit for simplicity. */
if ((ULLONG_MAX - 10) / 10 < parser->content_length) {
Make content_length unsigned, add overflow checks.
13 years ago
SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
goto error;
}
parser->content_length = t;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
Make content_length unsigned, add overflow checks.
13 years ago
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Now parsing some req headers
16 years ago
/* Transfer-Encoding: chunked */
better output for test_scan
16 years ago
case h_matching_transfer_encoding_chunked:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(CHUNKED)-1
|| c != CHUNKED[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(CHUNKED)-2) {
parser->header_state = h_transfer_encoding_chunked;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
break;
Now parsing some req headers
16 years ago
/* looking for 'Connection: keep-alive' */
better output for test_scan
16 years ago
case h_matching_connection_keep_alive:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(KEEP_ALIVE)-1
|| c != KEEP_ALIVE[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(KEEP_ALIVE)-2) {
parser->header_state = h_connection_keep_alive;
better output for test_scan
16 years ago
}
break;
Now parsing some req headers
16 years ago
/* looking for 'Connection: close' */
better output for test_scan
16 years ago
case h_matching_connection_close:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->index++;
if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) {
parser->header_state = h_general;
} else if (parser->index == sizeof(CLOSE)-2) {
parser->header_state = h_connection_close;
better output for test_scan
16 years ago
}
break;
case h_transfer_encoding_chunked:
case h_connection_keep_alive:
case h_connection_close:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (ch != ' ') parser->header_state = h_general;
Now parsing some req headers
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
default:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_value;
parser->header_state = h_general;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
}
break;
}
case s_header_almost_done:
strict check
16 years ago
{
STRICT_CHECK(ch != LF);
better output for test_scan
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_value_lws;
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
break;
}
better output for test_scan
16 years ago
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
case s_header_value_lws:
{
if (ch == ' ' || ch == '\t') {
parser->state = s_header_value_start;
goto reexecute_byte;
}
/* finished the header */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
switch (parser->header_state) {
better output for test_scan
16 years ago
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;
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
parser->state = s_header_field_start;
goto reexecute_byte;
}
case s_header_value_discard_ws_almost_done:
{
STRICT_CHECK(ch != LF);
parser->state = s_header_value_discard_lws;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
break;
strict check
16 years ago
}
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
case s_header_value_discard_lws:
Support multi-line folding in header values. Normal value cb is called for subsequent lines. LWS is skipped. Note that \t whitespace character is now supported after header field name. RFC 2616, Section 2.2 "HTTP/1.1 header field values can be folded onto multiple lines if the continuation line begins with a space or horizontal tab. All linear white space, including folding, has the same semantics as SP. A recipient MAY replace any linear white space with a single SP before interpreting the field value or forwarding the message downstream."
14 years ago
{
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
if (ch == ' ' || ch == '\t') {
parser->state = s_header_value_discard_ws;
break;
} else {
/* header value was empty */
MARK(header_value);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
Fix issues around multi-line headers Always discard leading whitespace in a header value, even if it is folded. Pay attention to values of interesting headers (Connection, Content-Length, etc.) even when they come on a continuation line. Add a test case to check that requests and responses using only LF to separate lines are handled correctly.
12 years ago
CALLBACK_DATA_NOADVANCE(header_value);
goto reexecute_byte;
}
Support multi-line folding in header values. Normal value cb is called for subsequent lines. LWS is skipped. Note that \t whitespace character is now supported after header field name. RFC 2616, Section 2.2 "HTTP/1.1 header field values can be folded onto multiple lines if the continuation line begins with a space or horizontal tab. All linear white space, including folding, has the same semantics as SP. A recipient MAY replace any linear white space with a single SP before interpreting the field value or forwarding the message downstream."
14 years ago
}
Now parsing some req headers
16 years ago
case s_headers_almost_done:
strict check
16 years ago
{
STRICT_CHECK(ch != LF);
Handling chunked messages
16 years ago
if (parser->flags & F_TRAILING) {
/* End of a chunked request */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
Handling chunked messages
16 years ago
break;
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_headers_done;
Add http version to tests
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Set this here so that on_headers_complete() callbacks can see it */
parser->upgrade =
(parser->flags & F_UPGRADE || parser->method == HTTP_CONNECT);
Support Upgrade header
15 years ago
Skip body for HEAD responses TODO: need test for response with non-zero content length but no body.
15 years ago
/* Here we call the headers_complete callback. This is somewhat
* different than other callbacks because if the user returns 1, we
* will interpret that as saying that this message has no body. This
* is needed for the annoying case of recieving a response to a HEAD
* request.
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
*
* We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so
* we have to simulate it by handling a change in errno below.
Skip body for HEAD responses TODO: need test for response with non-zero content length but no body.
15 years ago
*/
if (settings->on_headers_complete) {
switch (settings->on_headers_complete(parser)) {
case 0:
break;
case 1:
parser->flags |= F_SKIPBODY;
break;
default:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_CB_headers_complete);
Skip body for HEAD responses TODO: need test for response with non-zero content length but no body.
15 years ago
return p - data; /* Error */
}
}
Remove EOL whitespace
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
return p - data;
}
goto reexecute_byte;
}
case s_headers_done:
{
STRICT_CHECK(ch != LF);
parser->nread = 0;
Replace C++ style comments with C comments so it compiles with `gcc -ansi -Wall`
15 years ago
/* Exit, the rest of the connect is in a different protocol. */
redundant upgrade flag check
15 years ago
if (parser->upgrade) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
Fix off-by-one in handling upgrade bodies. - When handling upgraded bodies, http_parser_execute() used to return one fewer bytes parsed than expected. This caused the final LF to be interpreted by the caller as part of the body. - Add a bunch of upgrade body unit tests.
14 years ago
return (p - data) + 1;
Support Upgrade header
15 years ago
}
Skip body for HEAD responses TODO: need test for response with non-zero content length but no body.
15 years ago
if (parser->flags & F_SKIPBODY) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
Skip body for HEAD responses TODO: need test for response with non-zero content length but no body.
15 years ago
} else if (parser->flags & F_CHUNKED) {
Don't put should_keep_alive messages in front of messages
16 years ago
/* chunked encoding - ignore Content-Length header */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_size_start;
Now parsing some req headers
16 years ago
} else {
if (parser->content_length == 0) {
Don't put should_keep_alive messages in front of messages
16 years ago
/* Content-Length header given but zero: Content-Length: 0\r\n */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
Make content_length unsigned, add overflow checks.
13 years ago
} else if (parser->content_length != ULLONG_MAX) {
Don't put should_keep_alive messages in front of messages
16 years ago
/* Content-Length header given and non-zero */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_body_identity;
better output for test_scan
16 years ago
} else {
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
if (parser->type == HTTP_REQUEST ||
!http_message_needs_eof(parser)) {
add http_should_keep_alive()
16 years ago
/* Assume content-length 0 - read the next */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
better output for test_scan
16 years ago
} else {
add http_should_keep_alive()
16 years ago
/* Read body until EOF */
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_body_identity_eof;
better output for test_scan
16 years ago
}
Now parsing some req headers
16 years ago
}
}
Add http version to tests
16 years ago
Now parsing some req headers
16 years ago
break;
strict check
16 years ago
}
Now parsing some req headers
16 years ago
case s_body_identity:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
{
Make content_length unsigned, add overflow checks.
13 years ago
uint64_t to_read = MIN(parser->content_length,
(uint64_t) ((data + len) - p));
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
Make content_length unsigned, add overflow checks.
13 years ago
assert(parser->content_length != 0
&& parser->content_length != ULLONG_MAX);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* The difference between advancing content_length and p is because
* the latter will automaticaly advance on the next loop iteration.
* Further, if content_length ends up at 0, we want to see the last
* byte again for our message complete callback.
*/
MARK(body);
parser->content_length -= to_read;
p += to_read - 1;
if (parser->content_length == 0) {
parser->state = s_message_done;
/* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte.
*
* The alternative to doing this is to wait for the next byte to
* trigger the data callback, just as in every other case. The
* problem with this is that this makes it difficult for the test
* harness to distinguish between complete-on-EOF and
* complete-on-length. It's not clear that this distinction is
* important for applications, but let's keep it for now.
*/
CALLBACK_DATA_(body, p - body_mark + 1, p - data);
goto reexecute_byte;
Handling chunked messages
16 years ago
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
Now parsing some req headers
16 years ago
break;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
}
Now parsing some req headers
16 years ago
better output for test_scan
16 years ago
/* read until EOF */
case s_body_identity_eof:
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
MARK(body);
p = data + len - 1;
break;
case s_message_done:
parser->state = NEW_MESSAGE();
CALLBACK_NOTIFY(message_complete);
better output for test_scan
16 years ago
break;
case s_chunk_size_start:
add response scan, fix persistent bug
16 years ago
{
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
assert(parser->nread == 1);
add response scan, fix persistent bug
16 years ago
assert(parser->flags & F_CHUNKED);
Fix build when char is unsigned by default. I tested by building/testing with -funsigned-char. Thanks to apaprocki for pointing out this problem.
14 years ago
unhex_val = unhex[(unsigned char)ch];
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (unhex_val == -1) {
SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
goto error;
}
Fix build when char is unsigned by default. I tested by building/testing with -funsigned-char. Thanks to apaprocki for pointing out this problem.
14 years ago
parser->content_length = unhex_val;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_size;
Now parsing some req headers
16 years ago
break;
add response scan, fix persistent bug
16 years ago
}
Now parsing some req headers
16 years ago
better output for test_scan
16 years ago
case s_chunk_size:
strict check
16 years ago
{
Make content_length unsigned, add overflow checks.
13 years ago
uint64_t t;
add response scan, fix persistent bug
16 years ago
assert(parser->flags & F_CHUNKED);
Handling chunked messages
16 years ago
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_size_almost_done;
Handling chunked messages
16 years ago
break;
}
Fix build when char is unsigned by default. I tested by building/testing with -funsigned-char. Thanks to apaprocki for pointing out this problem.
14 years ago
unhex_val = unhex[(unsigned char)ch];
Handling chunked messages
16 years ago
Fix build when char is unsigned by default. I tested by building/testing with -funsigned-char. Thanks to apaprocki for pointing out this problem.
14 years ago
if (unhex_val == -1) {
better output for test_scan
16 years ago
if (ch == ';' || ch == ' ') {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_parameters;
better output for test_scan
16 years ago
break;
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
Use error label, instead of returning directly
16 years ago
goto error;
better output for test_scan
16 years ago
}
Handling chunked messages
16 years ago
Make content_length unsigned, add overflow checks.
13 years ago
t = parser->content_length;
t *= 16;
t += unhex_val;
fix content-length and chunk-size overflow test The overflow check didn't work for all possible inputs.
11 years ago
/* Overflow? Test against a conservative limit for simplicity. */
if ((ULLONG_MAX - 16) / 16 < parser->content_length) {
Make content_length unsigned, add overflow checks.
13 years ago
SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
goto error;
}
parser->content_length = t;
Handling chunked messages
16 years ago
break;
strict check
16 years ago
}
Handling chunked messages
16 years ago
better output for test_scan
16 years ago
case s_chunk_parameters:
add response scan, fix persistent bug
16 years ago
{
assert(parser->flags & F_CHUNKED);
strict check
16 years ago
/* just ignore this shit. TODO check for overflow */
better output for test_scan
16 years ago
if (ch == CR) {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_size_almost_done;
better output for test_scan
16 years ago
break;
}
break;
add response scan, fix persistent bug
16 years ago
}
better output for test_scan
16 years ago
case s_chunk_size_almost_done:
strict check
16 years ago
{
add response scan, fix persistent bug
16 years ago
assert(parser->flags & F_CHUNKED);
strict check
16 years ago
STRICT_CHECK(ch != LF);
add response scan, fix persistent bug
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->nread = 0;
Avoid chunk header parsing overflow. Recharacterize the chunk header states such that they are bound by the check for HTTP_MAX_HEADER_SIZE.
14 years ago
add response scan, fix persistent bug
16 years ago
if (parser->content_length == 0) {
Handling chunked messages
16 years ago
parser->flags |= F_TRAILING;
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_header_field_start;
Handling chunked messages
16 years ago
} else {
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_data;
Handling chunked messages
16 years ago
}
break;
strict check
16 years ago
}
Handling chunked messages
16 years ago
better output for test_scan
16 years ago
case s_chunk_data:
strict check
16 years ago
{
Make content_length unsigned, add overflow checks.
13 years ago
uint64_t to_read = MIN(parser->content_length,
(uint64_t) ((data + len) - p));
add response scan, fix persistent bug
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
assert(parser->flags & F_CHUNKED);
Make content_length unsigned, add overflow checks.
13 years ago
assert(parser->content_length != 0
&& parser->content_length != ULLONG_MAX);
Handling chunked messages
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* See the explanation in s_body_identity for why the content
* length and data pointers are managed this way.
*/
MARK(body);
parser->content_length -= to_read;
p += to_read - 1;
Handling chunked messages
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
if (parser->content_length == 0) {
parser->state = s_chunk_data_almost_done;
Handling chunked messages
16 years ago
}
break;
strict check
16 years ago
}
Handling chunked messages
16 years ago
better output for test_scan
16 years ago
case s_chunk_data_almost_done:
add response scan, fix persistent bug
16 years ago
assert(parser->flags & F_CHUNKED);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
assert(parser->content_length == 0);
strict check
16 years ago
STRICT_CHECK(ch != CR);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->state = s_chunk_data_done;
CALLBACK_DATA(body);
Handling chunked messages
16 years ago
break;
better output for test_scan
16 years ago
case s_chunk_data_done:
add response scan, fix persistent bug
16 years ago
assert(parser->flags & F_CHUNKED);
strict check
16 years ago
STRICT_CHECK(ch != LF);
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->nread = 0;
parser->state = s_chunk_size_start;
Handling chunked messages
16 years ago
break;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
default:
assert(0 && "unhandled state");
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
SET_ERRNO(HPE_INVALID_INTERNAL_STATE);
Use error label, instead of returning directly
16 years ago
goto error;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
/* Run callbacks for any marks that we have leftover after we ran our of
* bytes. There should be at most one of these set, so it's OK to invoke
* them in series (unset marks will not result in callbacks).
*
* We use the NOADVANCE() variety of callbacks here because 'p' has already
* overflowed 'data' and this allows us to correct for the off-by-one that
* we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p'
* value that's in-bounds).
*/
assert(((header_field_mark ? 1 : 0) +
(header_value_mark ? 1 : 0) +
(url_mark ? 1 : 0) +
Parse and emit status message of response
12 years ago
(body_mark ? 1 : 0) +
(status_mark ? 1 : 0)) <= 1);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
CALLBACK_DATA_NOADVANCE(header_field);
CALLBACK_DATA_NOADVANCE(header_value);
CALLBACK_DATA_NOADVANCE(url);
CALLBACK_DATA_NOADVANCE(body);
Parse and emit status message of response
12 years ago
CALLBACK_DATA_NOADVANCE(status);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
return len;
Use error label, instead of returning directly
16 years ago
error:
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
if (HTTP_PARSER_ERRNO(parser) == HPE_OK) {
SET_ERRNO(HPE_UNKNOWN);
}
Use error label, instead of returning directly
16 years ago
return (p - data);
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
change around api
16 years ago
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
/* Does the parser need to see an EOF to find the end of the message? */
int
Make http_should_keep_alive() const correct.
13 years ago
http_message_needs_eof (const http_parser *parser)
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
{
if (parser->type == HTTP_REQUEST) {
return 0;
}
/* See RFC 2616 section 4.4 */
if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
parser->status_code == 204 || /* No Content */
parser->status_code == 304 || /* Not Modified */
parser->flags & F_SKIPBODY) { /* response to a HEAD request */
return 0;
}
Make content_length unsigned, add overflow checks.
13 years ago
if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) {
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
return 0;
}
return 1;
}
add http_should_keep_alive()
16 years ago
int
Make http_should_keep_alive() const correct.
13 years ago
http_should_keep_alive (const http_parser *parser)
add http_should_keep_alive()
16 years ago
{
if (parser->http_major > 0 && parser->http_minor > 0) {
/* HTTP/1.1 */
if (parser->flags & F_CONNECTION_CLOSE) {
return 0;
}
} else {
/* HTTP/1.0 or earlier */
Get HTTP/1.1 message length logic working for HTTP/1.0 - Port message length logic from #72 to HTTP/1.0. - Add a bunch of unit tests for handling 0-length messages.
13 years ago
if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
add http_should_keep_alive()
16 years ago
return 0;
}
}
Get HTTP/1.1 message length logic working for HTTP/1.0 - Port message length logic from #72 to HTTP/1.0. - Add a bunch of unit tests for handling 0-length messages.
13 years ago
Don't wait for EOF on 0-length KA messages. - Break EOF handling out of http_should_keep_alive() into http_message_needs_eof(), which we now use when determining what to do with a message of unknown length. This prevents us from falling into the s_body_identity_eof state in the cases where we actually *do* know the length of the message (e.g. because the response status was 204).
13 years ago
return !http_message_needs_eof(parser);
add http_should_keep_alive()
16 years ago
}
Add bounds check to http_method_str().
13 years ago
const char *
http_method_str (enum http_method m)
Expose http_method_str() to get a string version of a method
15 years ago
{
Add bounds check to http_method_str().
13 years ago
return ELEM_AT(method_strings, m, "<unknown>");
Expose http_method_str() to get a string version of a method
15 years ago
}
change around api
16 years ago
void
API: Define parser type in http_parser_init() That is, for a request parser do this: http_parser_init(my_parser, HTTP_REQUEST) for a response parser do this: http_parser_init(my_parser, HTTP_RESPONSE) Then http_parse_requests() and http_parse_responses() both turn into http_parer_execute().
16 years ago
http_parser_init (http_parser *parser, enum http_parser_type t)
change around api
16 years ago
{
http_parser_init does not clear status_code
13 years ago
void *data = parser->data; /* preserve application data */
memset(parser, 0, sizeof(*parser));
parser->data = data;
API: Define parser type in http_parser_init() That is, for a request parser do this: http_parser_init(my_parser, HTTP_REQUEST) for a response parser do this: http_parser_init(my_parser, HTTP_RESPONSE) Then http_parse_requests() and http_parse_responses() both turn into http_parer_execute().
16 years ago
parser->type = t;
Fix typo s_start_res_or_resp
15 years ago
parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
parser->http_errno = HPE_OK;
new version Trashing the old Ragel parser (which was based on Mongrel) because it's proving difficult to get the control I need in end-of-message cases. Replacing this with a hand written parser using a couple tricks borrowed from NGINX. The new parser will be much more work to write, but should prove faster and allow for better hacking.
16 years ago
}
Facility to report detailed parsing errors. - Add http_errno enum w/ values for many parsing error conditions. Stash this in http_parser.state if the 0x80 bit is set. - Report line numbers on error generation if the (new) HTTP_PARSER_DEBUG cpp symbol is set. Increases http_parser struct size by 8 bytes in this case. - Add http_errno_*() methods to help turning errno values into human-readable messages.
14 years ago
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;
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
User info implementation
13 years ago
static enum http_host_state
http_parse_host_char(enum http_host_state s, const char ch) {
Refactor host parsing to allow basic auth management
13 years ago
switch(s) {
User info implementation
13 years ago
case s_http_userinfo:
case s_http_userinfo_start:
if (ch == '@') {
return s_http_host_start;
}
if (IS_USERINFO_CHAR(ch)) {
return s_http_userinfo;
}
break;
Refactor host parsing to allow basic auth management
13 years ago
case s_http_host_start:
if (ch == '[') {
return s_http_host_v6_start;
}
if (IS_HOST_CHAR(ch)) {
return s_http_host;
}
break;
case s_http_host:
if (IS_HOST_CHAR(ch)) {
return s_http_host;
}
/* FALLTHROUGH */
case s_http_host_v6_end:
if (ch == ':') {
return s_http_host_port_start;
}
break;
case s_http_host_v6:
if (ch == ']') {
return s_http_host_v6_end;
}
/* FALLTHROUGH */
case s_http_host_v6_start:
Fix IPv6 address parsing. Fixes #133.
13 years ago
if (IS_HEX(ch) || ch == ':' || ch == '.') {
Refactor host parsing to allow basic auth management
13 years ago
return s_http_host_v6;
}
break;
case s_http_host_port:
case s_http_host_port_start:
if (IS_NUM(ch)) {
return s_http_host_port;
}
break;
default:
break;
}
return s_http_host_dead;
}
Small refactoring, add edge cases
13 years ago
static int
http_parse_host(const char * buf, struct http_parser_url *u, int found_at) {
Refactor host parsing to allow basic auth management
13 years ago
enum http_host_state s;
Small refactoring, add edge cases
13 years ago
const char *p;
size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len;
Refactor host parsing to allow basic auth management
13 years ago
u->field_data[UF_HOST].len = 0;
User info implementation
13 years ago
s = found_at ? s_http_userinfo_start : s_http_host_start;
Refactor host parsing to allow basic auth management
13 years ago
Small refactoring, add edge cases
13 years ago
for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) {
enum http_host_state new_s = http_parse_host_char(s, *p);
User info implementation
13 years ago
Refactor host parsing to allow basic auth management
13 years ago
if (new_s == s_http_host_dead) {
return 1;
}
switch(new_s) {
case s_http_host:
if (s != s_http_host) {
Small refactoring, add edge cases
13 years ago
u->field_data[UF_HOST].off = p - buf;
Refactor host parsing to allow basic auth management
13 years ago
}
Coding style : remove space before ++
13 years ago
u->field_data[UF_HOST].len++;
Refactor host parsing to allow basic auth management
13 years ago
break;
case s_http_host_v6:
if (s != s_http_host_v6) {
Small refactoring, add edge cases
13 years ago
u->field_data[UF_HOST].off = p - buf;
Refactor host parsing to allow basic auth management
13 years ago
}
Coding style : remove space before ++
13 years ago
u->field_data[UF_HOST].len++;
Refactor host parsing to allow basic auth management
13 years ago
break;
case s_http_host_port:
if (s != s_http_host_port) {
Small refactoring, add edge cases
13 years ago
u->field_data[UF_PORT].off = p - buf;
Refactor host parsing to allow basic auth management
13 years ago
u->field_data[UF_PORT].len = 0;
u->field_set |= (1 << UF_PORT);
}
Coding style : remove space before ++
13 years ago
u->field_data[UF_PORT].len++;
Refactor host parsing to allow basic auth management
13 years ago
break;
User info implementation
13 years ago
case s_http_userinfo:
if (s != s_http_userinfo) {
Small refactoring, add edge cases
13 years ago
u->field_data[UF_USERINFO].off = p - buf ;
User info implementation
13 years ago
u->field_data[UF_USERINFO].len = 0;
u->field_set |= (1 << UF_USERINFO);
}
Coding style : remove space before ++
13 years ago
u->field_data[UF_USERINFO].len++;
User info implementation
13 years ago
break;
Refactor host parsing to allow basic auth management
13 years ago
default:
break;
}
s = new_s;
}
/* Make sure we don't end somewhere unexpected */
switch (s) {
Small refactoring, add edge cases
13 years ago
case s_http_host_start:
Refactor host parsing to allow basic auth management
13 years ago
case s_http_host_v6_start:
case s_http_host_v6:
case s_http_host_port_start:
Small refactoring, add edge cases
13 years ago
case s_http_userinfo:
case s_http_userinfo_start:
Refactor host parsing to allow basic auth management
13 years ago
return 1;
default:
break;
}
return 0;
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
int
http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
struct http_parser_url *u)
{
enum state s;
const char *p;
enum http_parser_url_fields uf, old_uf;
User info implementation
13 years ago
int found_at = 0;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
u->port = u->field_set = 0;
Rename s_req_host* to be compliant with RFC 2396
13 years ago
s = is_connect ? s_req_server_start : s_req_spaces_before_url;
src: fix clang warning Fix http_parser.c:2147:3: warning: Value stored to 'uf' is never read found by Clang Analyser. Reviewed-By: Fedor Indutny <fedor@indutny.com>
11 years ago
old_uf = UF_MAX;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
for (p = buf; p < buf + buflen; p++) {
Use new state instead of pointer
13 years ago
s = parse_url_char(s, *p);
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
/* Figure out the next field that we're operating on */
switch (s) {
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
case s_dead:
return 1;
/* Skip delimeters */
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
case s_req_schema_slash:
case s_req_schema_slash_slash:
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_start:
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
case s_req_query_string_start:
case s_req_fragment_start:
continue;
case s_req_schema:
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
uf = UF_SCHEMA;
break;
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server_with_at:
Use new state instead of pointer
13 years ago
found_at = 1;
/* FALLTROUGH */
Rename s_req_host* to be compliant with RFC 2396
13 years ago
case s_req_server:
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
uf = UF_HOST;
break;
case s_req_path:
uf = UF_PATH;
break;
case s_req_query_string:
uf = UF_QUERY;
break;
case s_req_fragment:
uf = UF_FRAGMENT;
break;
default:
assert(!"Unexpected state");
return 1;
}
/* Nothing's changed; soldier on */
if (uf == old_uf) {
u->field_data[uf].len++;
continue;
}
Fix http_parser_parse_url for urls like "http://host/path". Before this change it would include the last slash in the separator between the schema and host as part of the host. we cant use the trick used for skipping the separator before ports, query strings, and fragments because if it was a CONNECT style url string (host:port) it would skip the first character of the hostname. Work around this by introducing a few more states to represent these separators in a url differently to what theyre separating. this in turn lets us simplify the url parsing so can simply skip what it considers delimiters rather than having to special case certain types of url parts and skip their prefixes. Add tests for the http_parser_parse_url(). This compares the http_parser_url struct that http_parser_parse_url() produces against one that we expect from the test. If they differ then http_parser_parse_url() misbehaved.
13 years ago
u->field_data[uf].off = p - buf;
u->field_data[uf].len = 1;
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
u->field_set |= (1 << uf);
old_uf = uf;
}
Coding style improvment
13 years ago
/* host must be present if there is a schema */
Add a comment
13 years ago
/* parsing http:///toto will fail */
Small refactoring, add edge cases
13 years ago
if ((u->field_set & ((1 << UF_SCHEMA) | (1 << UF_HOST))) != 0) {
User info implementation
13 years ago
if (http_parse_host(buf, u, found_at) != 0) {
Refactor host parsing to allow basic auth management
13 years ago
return 1;
}
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
}
Refactor host parsing to allow basic auth management
13 years ago
/* CONNECT requests can only contain "hostname:port" */
if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) {
implement parsing of v6 addresses and rejection of 0-length host and ports. the v6 parsing works by adding extra states for working with the [] notation for v6 addresses. hosts and ports cannot be 0-length because we url parsing from ending when we expect those fields to begin. http_parser_parse_url gets a free check for the correctness of CONNECT urls (they can only be host:port). this addresses the following issues: i was bored and had my head in this space.
13 years ago
return 1;
}
Add http_parser_parse_url(). - Add an http_parser_parse_url() method to parse a URL into its constituent components. This uses the same underlying parser as http_parser_parse() and doesn't do any data copies. - Re-add the URL components in various test.c structures; validate them when parsing.
14 years ago
if (u->field_set & (1 << UF_PORT)) {
/* Don't bother with endp; we've already validated the string */
unsigned long v = strtoul(buf + u->field_data[UF_PORT].off, NULL, 10);
/* Ports have a max value of 2^16 */
if (v > 0xffff) {
return 1;
}
u->port = (uint16_t) v;
}
return 0;
}
Implement http_parser_pause(). Summary: - Add http_parser_pause() API. A callback may invoke this at any time. This will cause http_parser_parse() to return indicating that it parsed less than the number of requested bytes and set an error to HBE_PAUSED. A paused parser with fail with HBE_PAUSED until it is un-paused with http_parser_pause(). - Stop using 'state', 'header_state', 'index', and 'nread' shadow variables and then updating their http_parser fields when we're done. Instead, update the live values as we go. This will make it possible to return from anywhere in the parser (say, due to EPAUSED) and have valid/expected state. - Update state before making callbacks so that if the want to pause, we'll know the correct state already. - Make sure that every callback has a state that uniquely identifies the next step so that we can resume in the right place if we were suppoed to be paused. - Clean and re-factor up CALLBACK() macros. - Use CALLBACK() macros for (almost) all callbacks; on_headers_complete is still a special case. This includes on_body which we used to invoke manually with a long run of bytes. We now use a 'body' mark and hit its callback just like every other data callback. - Clean up (most) gotos and replace with real states. - Add some unit tests. Fixes #70
13 years ago
void
http_parser_pause(http_parser *parser, int paused) {
/* Users should only be pausing/unpausing a parser that is not in an error
* state. In non-debug builds, there's not much that we can do about this
* other than ignore it.
*/
if (HTTP_PARSER_ERRNO(parser) == HPE_OK ||
HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) {
SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK);
} else {
assert(0 && "Attempting to pause parser in error state");
}
}
Add "int http_body_is_final(const http_parser *parser)" method. It's useful to check if the current chunk is the last one.
13 years ago
int
http_body_is_final(const struct http_parser *parser) {
return parser->state == s_message_done;
}
Add function http_parser_version(). Fixes #115.
13 years ago
unsigned long
http_parser_version(void) {
return HTTP_PARSER_VERSION_MAJOR * 0x10000 |
HTTP_PARSER_VERSION_MINOR * 0x00100 |
HTTP_PARSER_VERSION_PATCH * 0x00001;
}