From 90367ff7b9948cabf44662020c90ead73a176f25 Mon Sep 17 00:00:00 2001 From: Michael Maier Date: Sun, 21 Nov 2010 21:09:20 +0100 Subject: [PATCH] Exchange the Mongrel parser with the Mongrel2 parser because of licensing issues --- config.m4 | 2 +- http11_common.h | 9 + http11_parser.c | 1300 +++++++++++ http11_parser.h | 41 + mistral.c | 22 +- original_parser/http11_common.h | 9 + original_parser/http11_parser.c | 1300 +++++++++++ original_parser/http11_parser.h | 41 + original_parser/{parser.rl => http11_parser.rl} | 191 +- original_parser/parser.h | 53 - parser.c | 2860 ----------------------- parser.h | 53 - 12 files changed, 2809 insertions(+), 3072 deletions(-) create mode 100644 http11_common.h create mode 100644 http11_parser.c create mode 100644 http11_parser.h create mode 100644 original_parser/http11_common.h create mode 100644 original_parser/http11_parser.c create mode 100644 original_parser/http11_parser.h rename original_parser/{parser.rl => http11_parser.rl} (56%) delete mode 100644 original_parser/parser.h delete mode 100644 parser.c delete mode 100644 parser.h diff --git a/config.m4 b/config.m4 index 6bad1a7..158d3be 100644 --- a/config.m4 +++ b/config.m4 @@ -30,5 +30,5 @@ dnl if test "$PHP_LIBEV" != "no"; then AC_DEFINE(HAVE_LIBEV,1,[Whether you have libev]) - PHP_NEW_EXTENSION(mistral, mistral.c parser.c, $ext_shared) + PHP_NEW_EXTENSION(mistral, mistral.c http11_parser.c, $ext_shared) dnl fi \ No newline at end of file diff --git a/http11_common.h b/http11_common.h new file mode 100644 index 0000000..6df7970 --- /dev/null +++ b/http11_common.h @@ -0,0 +1,9 @@ +#ifndef _http11_common_h +#define _http11_common_h + +#include + +typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen); +typedef void (*element_cb)(void *data, int type, const char *at, size_t length); + +#endif diff --git a/http11_parser.c b/http11_parser.c new file mode 100644 index 0000000..870dda4 --- /dev/null +++ b/http11_parser.c @@ -0,0 +1,1300 @@ + +#line 1 "http11_parser.rl" +/** + * + * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names + * of its contributors may be used to endorse or promote products + * derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "http11_parser.h" +#include +#include +#include +#include +#include + +#define LEN(AT, FPC) (FPC - buffer - parser->AT) +#define MARK(M,FPC) (parser->M = (FPC) - buffer) +#define PTR_TO(F) (buffer + parser->F) + +/** Machine **/ + + +#line 165 "http11_parser.rl" + + +/** Data **/ + +#line 57 "http11_parser.c" +static const int http_parser_start = 1; +static const int http_parser_first_final = 60; +static const int http_parser_error = 0; + +static const int http_parser_en_main = 1; + + +#line 169 "http11_parser.rl" + +static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length) +{ + int len = (int)(end-begin); + if(len > max_length) { + return(0); + } + if(parser->on_element) + parser->on_element(parser->data, type, begin, len); + return(1); +} + + + +int http_parser_init(http_parser *parser) { + int cs = 0; + +#line 83 "http11_parser.c" + { + cs = http_parser_start; + } + +#line 186 "http11_parser.rl" + parser->cs = cs; + parser->body_start = 0; + parser->content_len = 0; + parser->mark = 0; + parser->nread = 0; + parser->field_len = 0; + parser->field_start = 0; + + return(1); +} + +/** exec **/ +size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off) +{ + if(len == 0) return 0; + + const char *p, *pe; + int cs = parser->cs; + + assert(off <= len && "offset past end of buffer"); + + p = buffer+off; + pe = buffer+len; + + assert(pe - p == (int)len - (int)off && "pointers aren't same distance"); + + +#line 116 "http11_parser.c" + { + if ( p == pe ) + goto _test_eof; + switch ( cs ) + { +case 1: + switch( (*p) ) { + case 36: goto tr0; + case 95: goto tr0; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto tr0; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto tr0; + } else + goto tr0; + goto st0; +st0: +cs = 0; + goto _out; +tr0: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st2; +st2: + if ( ++p == pe ) + goto _test_eof2; +case 2: +#line 147 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st41; + case 95: goto st41; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st41; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st41; + } else + goto st41; + goto st0; +tr2: +#line 94 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), p, 1024)) + {p++; cs = 3; goto _out;} + } + goto st3; +st3: + if ( ++p == pe ) + goto _test_eof3; +case 3: +#line 173 "http11_parser.c" + switch( (*p) ) { + case 42: goto tr4; + case 47: goto tr5; + case 104: goto tr6; + } + goto st0; +tr4: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st4; +st4: + if ( ++p == pe ) + goto _test_eof4; +case 4: +#line 188 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr7; + case 35: goto tr8; + } + goto st0; +tr7: +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr33: +#line 52 "http11_parser.rl" + {MARK(mark, p); } +#line 79 "http11_parser.rl" + { + if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr36: +#line 79 "http11_parser.rl" + { + if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr40: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr51: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr55: +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +st5: + if ( ++p == pe ) + goto _test_eof5; +case 5: +#line 259 "http11_parser.c" + if ( (*p) == 72 ) + goto tr9; + goto st0; +tr9: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st6; +st6: + if ( ++p == pe ) + goto _test_eof6; +case 6: +#line 271 "http11_parser.c" + if ( (*p) == 84 ) + goto st7; + goto st0; +st7: + if ( ++p == pe ) + goto _test_eof7; +case 7: + if ( (*p) == 84 ) + goto st8; + goto st0; +st8: + if ( ++p == pe ) + goto _test_eof8; +case 8: + if ( (*p) == 80 ) + goto st9; + goto st0; +st9: + if ( ++p == pe ) + goto _test_eof9; +case 9: + if ( (*p) == 47 ) + goto st10; + goto st0; +st10: + if ( ++p == pe ) + goto _test_eof10; +case 10: + if ( (*p) == 49 ) + goto st11; + goto st0; +st11: + if ( ++p == pe ) + goto _test_eof11; +case 11: + if ( (*p) == 46 ) + goto st12; + goto st0; +st12: + if ( ++p == pe ) + goto _test_eof12; +case 12: + if ( 48 <= (*p) && (*p) <= 49 ) + goto st13; + goto st0; +st13: + if ( ++p == pe ) + goto _test_eof13; +case 13: + switch( (*p) ) { + case 10: goto tr17; + case 13: goto tr18; + } + goto st0; +tr17: +#line 84 "http11_parser.rl" + { + if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10)) + {p++; cs = 14; goto _out;} + } + goto st14; +tr25: +#line 60 "http11_parser.rl" + { MARK(mark, p); } +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st14; +tr29: +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st14; +st14: + if ( ++p == pe ) + goto _test_eof14; +case 14: +#line 355 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr19; + case 13: goto st15; + case 33: goto tr21; + case 124: goto tr21; + case 126: goto tr21; + } + if ( (*p) < 45 ) { + if ( (*p) > 39 ) { + if ( 42 <= (*p) && (*p) <= 43 ) + goto tr21; + } else if ( (*p) >= 35 ) + goto tr21; + } else if ( (*p) > 46 ) { + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto tr21; + } else if ( (*p) > 90 ) { + if ( 94 <= (*p) && (*p) <= 122 ) + goto tr21; + } else + goto tr21; + } else + goto tr21; + goto st0; +tr19: +#line 111 "http11_parser.rl" + { + parser->body_start = p - buffer + 1; + {p++; cs = 60; goto _out;} + } + goto st60; +st60: + if ( ++p == pe ) + goto _test_eof60; +case 60: +#line 392 "http11_parser.c" + goto st0; +st15: + if ( ++p == pe ) + goto _test_eof15; +case 15: + if ( (*p) == 10 ) + goto tr19; + goto st0; +tr21: +#line 55 "http11_parser.rl" + { MARK(field_start, p); } + goto st16; +st16: + if ( ++p == pe ) + goto _test_eof16; +case 16: +#line 409 "http11_parser.c" + switch( (*p) ) { + case 33: goto st16; + case 58: goto tr23; + case 124: goto st16; + case 126: goto st16; + } + if ( (*p) < 45 ) { + if ( (*p) > 39 ) { + if ( 42 <= (*p) && (*p) <= 43 ) + goto st16; + } else if ( (*p) >= 35 ) + goto st16; + } else if ( (*p) > 46 ) { + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st16; + } else if ( (*p) > 90 ) { + if ( 94 <= (*p) && (*p) <= 122 ) + goto st16; + } else + goto st16; + } else + goto st16; + goto st0; +tr23: +#line 56 "http11_parser.rl" + { + parser->field_len = LEN(field_start, p); + } + goto st17; +tr27: +#line 60 "http11_parser.rl" + { MARK(mark, p); } + goto st17; +st17: + if ( ++p == pe ) + goto _test_eof17; +case 17: +#line 448 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr25; + case 13: goto tr26; + case 32: goto tr27; + } + goto tr24; +tr24: +#line 60 "http11_parser.rl" + { MARK(mark, p); } + goto st18; +st18: + if ( ++p == pe ) + goto _test_eof18; +case 18: +#line 463 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr29; + case 13: goto tr30; + } + goto st18; +tr18: +#line 84 "http11_parser.rl" + { + if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10)) + {p++; cs = 19; goto _out;} + } + goto st19; +tr26: +#line 60 "http11_parser.rl" + { MARK(mark, p); } +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st19; +tr30: +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st19; +st19: + if ( ++p == pe ) + goto _test_eof19; +case 19: +#line 498 "http11_parser.c" + if ( (*p) == 10 ) + goto st14; + goto st0; +tr8: +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr41: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr52: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr56: +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +st20: + if ( ++p == pe ) + goto _test_eof20; +case 20: +#line 551 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr33; + case 37: goto tr34; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( (*p) > 31 ) { + if ( 34 <= (*p) && (*p) <= 35 ) + goto st0; + } else if ( (*p) >= 0 ) + goto st0; + goto tr32; +tr32: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st21; +st21: + if ( ++p == pe ) + goto _test_eof21; +case 21: +#line 573 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr36; + case 37: goto st22; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( (*p) > 31 ) { + if ( 34 <= (*p) && (*p) <= 35 ) + goto st0; + } else if ( (*p) >= 0 ) + goto st0; + goto st21; +tr34: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st22; +st22: + if ( ++p == pe ) + goto _test_eof22; +case 22: +#line 595 "http11_parser.c" + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st23; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st23; + } else + goto st23; + goto st0; +st23: + if ( ++p == pe ) + goto _test_eof23; +case 23: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st21; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st21; + } else + goto st21; + goto st0; +tr5: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st24; +st24: + if ( ++p == pe ) + goto _test_eof24; +case 24: +#line 626 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr40; + case 34: goto st0; + case 35: goto tr41; + case 37: goto st25; + case 59: goto tr43; + case 60: goto st0; + case 62: goto st0; + case 63: goto tr44; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st24; +st25: + if ( ++p == pe ) + goto _test_eof25; +case 25: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st26; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st26; + } else + goto st26; + goto st0; +st26: + if ( ++p == pe ) + goto _test_eof26; +case 26: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st24; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st24; + } else + goto st24; + goto st0; +tr43: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 27; goto _out;} + } + goto st27; +st27: + if ( ++p == pe ) + goto _test_eof27; +case 27: +#line 678 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr7; + case 34: goto st0; + case 35: goto tr8; + case 37: goto st28; + case 60: goto st0; + case 62: goto st0; + case 63: goto st30; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st27; +st28: + if ( ++p == pe ) + goto _test_eof28; +case 28: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st29; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st29; + } else + goto st29; + goto st0; +st29: + if ( ++p == pe ) + goto _test_eof29; +case 29: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st27; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st27; + } else + goto st27; + goto st0; +tr44: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 30; goto _out;} + } + goto st30; +st30: + if ( ++p == pe ) + goto _test_eof30; +case 30: +#line 729 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr51; + case 34: goto st0; + case 35: goto tr52; + case 37: goto tr53; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto tr50; +tr50: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } + goto st31; +st31: + if ( ++p == pe ) + goto _test_eof31; +case 31: +#line 750 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr55; + case 34: goto st0; + case 35: goto tr56; + case 37: goto st32; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st31; +tr53: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } + goto st32; +st32: + if ( ++p == pe ) + goto _test_eof32; +case 32: +#line 771 "http11_parser.c" + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st33; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st33; + } else + goto st33; + goto st0; +st33: + if ( ++p == pe ) + goto _test_eof33; +case 33: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st31; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st31; + } else + goto st31; + goto st0; +tr6: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st34; +st34: + if ( ++p == pe ) + goto _test_eof34; +case 34: +#line 802 "http11_parser.c" + if ( (*p) == 116 ) + goto st35; + goto st0; +st35: + if ( ++p == pe ) + goto _test_eof35; +case 35: + if ( (*p) == 116 ) + goto st36; + goto st0; +st36: + if ( ++p == pe ) + goto _test_eof36; +case 36: + if ( (*p) == 112 ) + goto st37; + goto st0; +st37: + if ( ++p == pe ) + goto _test_eof37; +case 37: + if ( (*p) == 58 ) + goto st38; + goto st0; +st38: + if ( ++p == pe ) + goto _test_eof38; +case 38: + switch( (*p) ) { + case 32: goto tr7; + case 34: goto st0; + case 35: goto tr8; + case 37: goto st39; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st38; +st39: + if ( ++p == pe ) + goto _test_eof39; +case 39: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st40; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st40; + } else + goto st40; + goto st0; +st40: + if ( ++p == pe ) + goto _test_eof40; +case 40: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st38; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st38; + } else + goto st38; + goto st0; +st41: + if ( ++p == pe ) + goto _test_eof41; +case 41: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st42; + case 95: goto st42; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st42; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st42; + } else + goto st42; + goto st0; +st42: + if ( ++p == pe ) + goto _test_eof42; +case 42: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st43; + case 95: goto st43; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st43; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st43; + } else + goto st43; + goto st0; +st43: + if ( ++p == pe ) + goto _test_eof43; +case 43: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st44; + case 95: goto st44; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st44; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st44; + } else + goto st44; + goto st0; +st44: + if ( ++p == pe ) + goto _test_eof44; +case 44: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st45; + case 95: goto st45; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st45; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st45; + } else + goto st45; + goto st0; +st45: + if ( ++p == pe ) + goto _test_eof45; +case 45: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st46; + case 95: goto st46; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st46; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st46; + } else + goto st46; + goto st0; +st46: + if ( ++p == pe ) + goto _test_eof46; +case 46: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st47; + case 95: goto st47; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st47; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st47; + } else + goto st47; + goto st0; +st47: + if ( ++p == pe ) + goto _test_eof47; +case 47: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st48; + case 95: goto st48; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st48; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st48; + } else + goto st48; + goto st0; +st48: + if ( ++p == pe ) + goto _test_eof48; +case 48: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st49; + case 95: goto st49; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st49; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st49; + } else + goto st49; + goto st0; +st49: + if ( ++p == pe ) + goto _test_eof49; +case 49: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st50; + case 95: goto st50; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st50; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st50; + } else + goto st50; + goto st0; +st50: + if ( ++p == pe ) + goto _test_eof50; +case 50: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st51; + case 95: goto st51; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st51; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st51; + } else + goto st51; + goto st0; +st51: + if ( ++p == pe ) + goto _test_eof51; +case 51: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st52; + case 95: goto st52; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st52; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st52; + } else + goto st52; + goto st0; +st52: + if ( ++p == pe ) + goto _test_eof52; +case 52: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st53; + case 95: goto st53; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st53; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st53; + } else + goto st53; + goto st0; +st53: + if ( ++p == pe ) + goto _test_eof53; +case 53: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st54; + case 95: goto st54; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st54; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st54; + } else + goto st54; + goto st0; +st54: + if ( ++p == pe ) + goto _test_eof54; +case 54: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st55; + case 95: goto st55; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st55; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st55; + } else + goto st55; + goto st0; +st55: + if ( ++p == pe ) + goto _test_eof55; +case 55: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st56; + case 95: goto st56; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st56; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st56; + } else + goto st56; + goto st0; +st56: + if ( ++p == pe ) + goto _test_eof56; +case 56: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st57; + case 95: goto st57; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st57; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st57; + } else + goto st57; + goto st0; +st57: + if ( ++p == pe ) + goto _test_eof57; +case 57: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st58; + case 95: goto st58; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st58; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st58; + } else + goto st58; + goto st0; +st58: + if ( ++p == pe ) + goto _test_eof58; +case 58: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st59; + case 95: goto st59; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st59; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st59; + } else + goto st59; + goto st0; +st59: + if ( ++p == pe ) + goto _test_eof59; +case 59: + if ( (*p) == 32 ) + goto tr2; + goto st0; + } + _test_eof2: cs = 2; goto _test_eof; + _test_eof3: cs = 3; goto _test_eof; + _test_eof4: cs = 4; goto _test_eof; + _test_eof5: cs = 5; goto _test_eof; + _test_eof6: cs = 6; goto _test_eof; + _test_eof7: cs = 7; goto _test_eof; + _test_eof8: cs = 8; goto _test_eof; + _test_eof9: cs = 9; goto _test_eof; + _test_eof10: cs = 10; goto _test_eof; + _test_eof11: cs = 11; goto _test_eof; + _test_eof12: cs = 12; goto _test_eof; + _test_eof13: cs = 13; goto _test_eof; + _test_eof14: cs = 14; goto _test_eof; + _test_eof60: cs = 60; goto _test_eof; + _test_eof15: cs = 15; goto _test_eof; + _test_eof16: cs = 16; goto _test_eof; + _test_eof17: cs = 17; goto _test_eof; + _test_eof18: cs = 18; goto _test_eof; + _test_eof19: cs = 19; goto _test_eof; + _test_eof20: cs = 20; goto _test_eof; + _test_eof21: cs = 21; goto _test_eof; + _test_eof22: cs = 22; goto _test_eof; + _test_eof23: cs = 23; goto _test_eof; + _test_eof24: cs = 24; goto _test_eof; + _test_eof25: cs = 25; goto _test_eof; + _test_eof26: cs = 26; goto _test_eof; + _test_eof27: cs = 27; goto _test_eof; + _test_eof28: cs = 28; goto _test_eof; + _test_eof29: cs = 29; goto _test_eof; + _test_eof30: cs = 30; goto _test_eof; + _test_eof31: cs = 31; goto _test_eof; + _test_eof32: cs = 32; goto _test_eof; + _test_eof33: cs = 33; goto _test_eof; + _test_eof34: cs = 34; goto _test_eof; + _test_eof35: cs = 35; goto _test_eof; + _test_eof36: cs = 36; goto _test_eof; + _test_eof37: cs = 37; goto _test_eof; + _test_eof38: cs = 38; goto _test_eof; + _test_eof39: cs = 39; goto _test_eof; + _test_eof40: cs = 40; goto _test_eof; + _test_eof41: cs = 41; goto _test_eof; + _test_eof42: cs = 42; goto _test_eof; + _test_eof43: cs = 43; goto _test_eof; + _test_eof44: cs = 44; goto _test_eof; + _test_eof45: cs = 45; goto _test_eof; + _test_eof46: cs = 46; goto _test_eof; + _test_eof47: cs = 47; goto _test_eof; + _test_eof48: cs = 48; goto _test_eof; + _test_eof49: cs = 49; goto _test_eof; + _test_eof50: cs = 50; goto _test_eof; + _test_eof51: cs = 51; goto _test_eof; + _test_eof52: cs = 52; goto _test_eof; + _test_eof53: cs = 53; goto _test_eof; + _test_eof54: cs = 54; goto _test_eof; + _test_eof55: cs = 55; goto _test_eof; + _test_eof56: cs = 56; goto _test_eof; + _test_eof57: cs = 57; goto _test_eof; + _test_eof58: cs = 58; goto _test_eof; + _test_eof59: cs = 59; goto _test_eof; + + _test_eof: {} + _out: {} + } + +#line 213 "http11_parser.rl" + + assert(p <= pe && "Buffer overflow after parsing."); + + if (!http_parser_has_error(parser)) { + parser->cs = cs; + } + + parser->nread += p - (buffer + off); + + assert(parser->nread <= len && "nread longer than length"); + assert(parser->body_start <= len && "body starts after buffer end"); + assert(parser->mark < len && "mark is after buffer end"); + assert(parser->field_len <= len && "field has length longer than whole buffer"); + assert(parser->field_start < len && "field starts after buffer end"); + + return(parser->nread); +} + +int http_parser_finish(http_parser *parser) +{ + if (http_parser_has_error(parser) ) { + return -1; + } else if (http_parser_is_finished(parser) ) { + return 1; + } else { + return 0; + } +} + +int http_parser_has_error(http_parser *parser) { + return parser->cs == http_parser_error; +} + +int http_parser_is_finished(http_parser *parser) { + return parser->cs >= http_parser_first_final; +} diff --git a/http11_parser.h b/http11_parser.h new file mode 100644 index 0000000..c7f0ae1 --- /dev/null +++ b/http11_parser.h @@ -0,0 +1,41 @@ + +#ifndef http11_parser_h +#define http11_parser_h + +#include "http11_common.h" + +enum { CONTENT_LENGTH + , CONTENT_TYPE + , FRAGMENT + , HTTP_VERSION + , QUERY_STRING + , REQUEST_PATH + , REQUEST_METHOD + , REQUEST_URI + }; + +typedef struct http_parser { + int cs; + size_t body_start; + int content_len; + size_t nread; + size_t mark; + size_t field_start; + size_t field_len; + size_t query_start; + + void *data; + + field_cb http_field; + element_cb on_element; +} http_parser; + +int http_parser_init(http_parser *parser); +int http_parser_finish(http_parser *parser); +size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off); +int http_parser_has_error(http_parser *parser); +int http_parser_is_finished(http_parser *parser); + +#define http_parser_nread(parser) (parser)->nread + +#endif diff --git a/mistral.c b/mistral.c index caabff0..a73cf1a 100644 --- a/mistral.c +++ b/mistral.c @@ -22,7 +22,7 @@ #include -#include "parser.h" +#include "http11_parser.h" #include "mistral.h" /* @@ -42,7 +42,7 @@ struct client { struct ev_loop *loop; char *rbuff; int rlen; - int done; + int done; int close; }; @@ -62,7 +62,7 @@ http_parser parser; void http_field_cb(void *data, const char *field, size_t flen, const char *value, size_t vlen) { zval *server_vars = (zval *)data; - char *fld = malloc(5 + flen + 1); + char *fld = malloc(sizeof(char) * (5 + flen + 1)); char *val = strndup(value, vlen); size_t i; @@ -85,35 +85,35 @@ void http_on_element(void *data, int type, const char *at, size_t length) { zval *server_vars = (zval *)data; switch( type ) { - case MONGREL_CONTENT_LENGTH: + case CONTENT_LENGTH: line = "CONTENT_LENGTH"; break; - case MONGREL_CONTENT_TYPE: + case CONTENT_TYPE: line = "CONTENT_TYPE"; break; - case MONGREL_FRAGMENT: + case FRAGMENT: line = "FRAGMENT"; break; - case MONGREL_HTTP_VERSION: + case HTTP_VERSION: line = "HTTP_VERSION"; break; - case MONGREL_QUERY_STRING: + case QUERY_STRING: line = "QUERY_STRING"; break; - case MONGREL_REQUEST_PATH: + case REQUEST_PATH: line = "REQUEST_PATH"; break; - case MONGREL_REQUEST_METHOD: + case REQUEST_METHOD: line = "REQUEST_METHOD"; break; - case MONGREL_REQUEST_URI: + case REQUEST_URI: line = "REQUEST_URI"; break; diff --git a/original_parser/http11_common.h b/original_parser/http11_common.h new file mode 100644 index 0000000..6df7970 --- /dev/null +++ b/original_parser/http11_common.h @@ -0,0 +1,9 @@ +#ifndef _http11_common_h +#define _http11_common_h + +#include + +typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen); +typedef void (*element_cb)(void *data, int type, const char *at, size_t length); + +#endif diff --git a/original_parser/http11_parser.c b/original_parser/http11_parser.c new file mode 100644 index 0000000..870dda4 --- /dev/null +++ b/original_parser/http11_parser.c @@ -0,0 +1,1300 @@ + +#line 1 "http11_parser.rl" +/** + * + * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names + * of its contributors may be used to endorse or promote products + * derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "http11_parser.h" +#include +#include +#include +#include +#include + +#define LEN(AT, FPC) (FPC - buffer - parser->AT) +#define MARK(M,FPC) (parser->M = (FPC) - buffer) +#define PTR_TO(F) (buffer + parser->F) + +/** Machine **/ + + +#line 165 "http11_parser.rl" + + +/** Data **/ + +#line 57 "http11_parser.c" +static const int http_parser_start = 1; +static const int http_parser_first_final = 60; +static const int http_parser_error = 0; + +static const int http_parser_en_main = 1; + + +#line 169 "http11_parser.rl" + +static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length) +{ + int len = (int)(end-begin); + if(len > max_length) { + return(0); + } + if(parser->on_element) + parser->on_element(parser->data, type, begin, len); + return(1); +} + + + +int http_parser_init(http_parser *parser) { + int cs = 0; + +#line 83 "http11_parser.c" + { + cs = http_parser_start; + } + +#line 186 "http11_parser.rl" + parser->cs = cs; + parser->body_start = 0; + parser->content_len = 0; + parser->mark = 0; + parser->nread = 0; + parser->field_len = 0; + parser->field_start = 0; + + return(1); +} + +/** exec **/ +size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off) +{ + if(len == 0) return 0; + + const char *p, *pe; + int cs = parser->cs; + + assert(off <= len && "offset past end of buffer"); + + p = buffer+off; + pe = buffer+len; + + assert(pe - p == (int)len - (int)off && "pointers aren't same distance"); + + +#line 116 "http11_parser.c" + { + if ( p == pe ) + goto _test_eof; + switch ( cs ) + { +case 1: + switch( (*p) ) { + case 36: goto tr0; + case 95: goto tr0; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto tr0; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto tr0; + } else + goto tr0; + goto st0; +st0: +cs = 0; + goto _out; +tr0: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st2; +st2: + if ( ++p == pe ) + goto _test_eof2; +case 2: +#line 147 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st41; + case 95: goto st41; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st41; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st41; + } else + goto st41; + goto st0; +tr2: +#line 94 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), p, 1024)) + {p++; cs = 3; goto _out;} + } + goto st3; +st3: + if ( ++p == pe ) + goto _test_eof3; +case 3: +#line 173 "http11_parser.c" + switch( (*p) ) { + case 42: goto tr4; + case 47: goto tr5; + case 104: goto tr6; + } + goto st0; +tr4: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st4; +st4: + if ( ++p == pe ) + goto _test_eof4; +case 4: +#line 188 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr7; + case 35: goto tr8; + } + goto st0; +tr7: +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr33: +#line 52 "http11_parser.rl" + {MARK(mark, p); } +#line 79 "http11_parser.rl" + { + if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr36: +#line 79 "http11_parser.rl" + { + if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr40: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr51: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +tr55: +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 5; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 5; goto _out;} + } + goto st5; +st5: + if ( ++p == pe ) + goto _test_eof5; +case 5: +#line 259 "http11_parser.c" + if ( (*p) == 72 ) + goto tr9; + goto st0; +tr9: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st6; +st6: + if ( ++p == pe ) + goto _test_eof6; +case 6: +#line 271 "http11_parser.c" + if ( (*p) == 84 ) + goto st7; + goto st0; +st7: + if ( ++p == pe ) + goto _test_eof7; +case 7: + if ( (*p) == 84 ) + goto st8; + goto st0; +st8: + if ( ++p == pe ) + goto _test_eof8; +case 8: + if ( (*p) == 80 ) + goto st9; + goto st0; +st9: + if ( ++p == pe ) + goto _test_eof9; +case 9: + if ( (*p) == 47 ) + goto st10; + goto st0; +st10: + if ( ++p == pe ) + goto _test_eof10; +case 10: + if ( (*p) == 49 ) + goto st11; + goto st0; +st11: + if ( ++p == pe ) + goto _test_eof11; +case 11: + if ( (*p) == 46 ) + goto st12; + goto st0; +st12: + if ( ++p == pe ) + goto _test_eof12; +case 12: + if ( 48 <= (*p) && (*p) <= 49 ) + goto st13; + goto st0; +st13: + if ( ++p == pe ) + goto _test_eof13; +case 13: + switch( (*p) ) { + case 10: goto tr17; + case 13: goto tr18; + } + goto st0; +tr17: +#line 84 "http11_parser.rl" + { + if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10)) + {p++; cs = 14; goto _out;} + } + goto st14; +tr25: +#line 60 "http11_parser.rl" + { MARK(mark, p); } +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st14; +tr29: +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st14; +st14: + if ( ++p == pe ) + goto _test_eof14; +case 14: +#line 355 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr19; + case 13: goto st15; + case 33: goto tr21; + case 124: goto tr21; + case 126: goto tr21; + } + if ( (*p) < 45 ) { + if ( (*p) > 39 ) { + if ( 42 <= (*p) && (*p) <= 43 ) + goto tr21; + } else if ( (*p) >= 35 ) + goto tr21; + } else if ( (*p) > 46 ) { + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto tr21; + } else if ( (*p) > 90 ) { + if ( 94 <= (*p) && (*p) <= 122 ) + goto tr21; + } else + goto tr21; + } else + goto tr21; + goto st0; +tr19: +#line 111 "http11_parser.rl" + { + parser->body_start = p - buffer + 1; + {p++; cs = 60; goto _out;} + } + goto st60; +st60: + if ( ++p == pe ) + goto _test_eof60; +case 60: +#line 392 "http11_parser.c" + goto st0; +st15: + if ( ++p == pe ) + goto _test_eof15; +case 15: + if ( (*p) == 10 ) + goto tr19; + goto st0; +tr21: +#line 55 "http11_parser.rl" + { MARK(field_start, p); } + goto st16; +st16: + if ( ++p == pe ) + goto _test_eof16; +case 16: +#line 409 "http11_parser.c" + switch( (*p) ) { + case 33: goto st16; + case 58: goto tr23; + case 124: goto st16; + case 126: goto st16; + } + if ( (*p) < 45 ) { + if ( (*p) > 39 ) { + if ( 42 <= (*p) && (*p) <= 43 ) + goto st16; + } else if ( (*p) >= 35 ) + goto st16; + } else if ( (*p) > 46 ) { + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st16; + } else if ( (*p) > 90 ) { + if ( 94 <= (*p) && (*p) <= 122 ) + goto st16; + } else + goto st16; + } else + goto st16; + goto st0; +tr23: +#line 56 "http11_parser.rl" + { + parser->field_len = LEN(field_start, p); + } + goto st17; +tr27: +#line 60 "http11_parser.rl" + { MARK(mark, p); } + goto st17; +st17: + if ( ++p == pe ) + goto _test_eof17; +case 17: +#line 448 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr25; + case 13: goto tr26; + case 32: goto tr27; + } + goto tr24; +tr24: +#line 60 "http11_parser.rl" + { MARK(mark, p); } + goto st18; +st18: + if ( ++p == pe ) + goto _test_eof18; +case 18: +#line 463 "http11_parser.c" + switch( (*p) ) { + case 10: goto tr29; + case 13: goto tr30; + } + goto st18; +tr18: +#line 84 "http11_parser.rl" + { + if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10)) + {p++; cs = 19; goto _out;} + } + goto st19; +tr26: +#line 60 "http11_parser.rl" + { MARK(mark, p); } +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st19; +tr30: +#line 62 "http11_parser.rl" + { + if(parser->http_field != NULL) { + parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); + } + } + goto st19; +st19: + if ( ++p == pe ) + goto _test_eof19; +case 19: +#line 498 "http11_parser.c" + if ( (*p) == 10 ) + goto st14; + goto st0; +tr8: +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr41: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr52: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +tr56: +#line 106 "http11_parser.rl" + { + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024)) + {p++; cs = 20; goto _out;} + } +#line 99 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024)) + {p++; cs = 20; goto _out;} + } + goto st20; +st20: + if ( ++p == pe ) + goto _test_eof20; +case 20: +#line 551 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr33; + case 37: goto tr34; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( (*p) > 31 ) { + if ( 34 <= (*p) && (*p) <= 35 ) + goto st0; + } else if ( (*p) >= 0 ) + goto st0; + goto tr32; +tr32: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st21; +st21: + if ( ++p == pe ) + goto _test_eof21; +case 21: +#line 573 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr36; + case 37: goto st22; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( (*p) > 31 ) { + if ( 34 <= (*p) && (*p) <= 35 ) + goto st0; + } else if ( (*p) >= 0 ) + goto st0; + goto st21; +tr34: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st22; +st22: + if ( ++p == pe ) + goto _test_eof22; +case 22: +#line 595 "http11_parser.c" + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st23; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st23; + } else + goto st23; + goto st0; +st23: + if ( ++p == pe ) + goto _test_eof23; +case 23: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st21; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st21; + } else + goto st21; + goto st0; +tr5: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st24; +st24: + if ( ++p == pe ) + goto _test_eof24; +case 24: +#line 626 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr40; + case 34: goto st0; + case 35: goto tr41; + case 37: goto st25; + case 59: goto tr43; + case 60: goto st0; + case 62: goto st0; + case 63: goto tr44; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st24; +st25: + if ( ++p == pe ) + goto _test_eof25; +case 25: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st26; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st26; + } else + goto st26; + goto st0; +st26: + if ( ++p == pe ) + goto _test_eof26; +case 26: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st24; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st24; + } else + goto st24; + goto st0; +tr43: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 27; goto _out;} + } + goto st27; +st27: + if ( ++p == pe ) + goto _test_eof27; +case 27: +#line 678 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr7; + case 34: goto st0; + case 35: goto tr8; + case 37: goto st28; + case 60: goto st0; + case 62: goto st0; + case 63: goto st30; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st27; +st28: + if ( ++p == pe ) + goto _test_eof28; +case 28: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st29; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st29; + } else + goto st29; + goto st0; +st29: + if ( ++p == pe ) + goto _test_eof29; +case 29: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st27; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st27; + } else + goto st27; + goto st0; +tr44: +#line 89 "http11_parser.rl" + { + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024)) + {p++; cs = 30; goto _out;} + } + goto st30; +st30: + if ( ++p == pe ) + goto _test_eof30; +case 30: +#line 729 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr51; + case 34: goto st0; + case 35: goto tr52; + case 37: goto tr53; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto tr50; +tr50: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } + goto st31; +st31: + if ( ++p == pe ) + goto _test_eof31; +case 31: +#line 750 "http11_parser.c" + switch( (*p) ) { + case 32: goto tr55; + case 34: goto st0; + case 35: goto tr56; + case 37: goto st32; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st31; +tr53: +#line 104 "http11_parser.rl" + {MARK(query_start, p); } + goto st32; +st32: + if ( ++p == pe ) + goto _test_eof32; +case 32: +#line 771 "http11_parser.c" + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st33; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st33; + } else + goto st33; + goto st0; +st33: + if ( ++p == pe ) + goto _test_eof33; +case 33: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st31; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st31; + } else + goto st31; + goto st0; +tr6: +#line 52 "http11_parser.rl" + {MARK(mark, p); } + goto st34; +st34: + if ( ++p == pe ) + goto _test_eof34; +case 34: +#line 802 "http11_parser.c" + if ( (*p) == 116 ) + goto st35; + goto st0; +st35: + if ( ++p == pe ) + goto _test_eof35; +case 35: + if ( (*p) == 116 ) + goto st36; + goto st0; +st36: + if ( ++p == pe ) + goto _test_eof36; +case 36: + if ( (*p) == 112 ) + goto st37; + goto st0; +st37: + if ( ++p == pe ) + goto _test_eof37; +case 37: + if ( (*p) == 58 ) + goto st38; + goto st0; +st38: + if ( ++p == pe ) + goto _test_eof38; +case 38: + switch( (*p) ) { + case 32: goto tr7; + case 34: goto st0; + case 35: goto tr8; + case 37: goto st39; + case 60: goto st0; + case 62: goto st0; + case 127: goto st0; + } + if ( 0 <= (*p) && (*p) <= 31 ) + goto st0; + goto st38; +st39: + if ( ++p == pe ) + goto _test_eof39; +case 39: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st40; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st40; + } else + goto st40; + goto st0; +st40: + if ( ++p == pe ) + goto _test_eof40; +case 40: + if ( (*p) < 65 ) { + if ( 48 <= (*p) && (*p) <= 57 ) + goto st38; + } else if ( (*p) > 70 ) { + if ( 97 <= (*p) && (*p) <= 102 ) + goto st38; + } else + goto st38; + goto st0; +st41: + if ( ++p == pe ) + goto _test_eof41; +case 41: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st42; + case 95: goto st42; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st42; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st42; + } else + goto st42; + goto st0; +st42: + if ( ++p == pe ) + goto _test_eof42; +case 42: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st43; + case 95: goto st43; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st43; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st43; + } else + goto st43; + goto st0; +st43: + if ( ++p == pe ) + goto _test_eof43; +case 43: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st44; + case 95: goto st44; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st44; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st44; + } else + goto st44; + goto st0; +st44: + if ( ++p == pe ) + goto _test_eof44; +case 44: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st45; + case 95: goto st45; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st45; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st45; + } else + goto st45; + goto st0; +st45: + if ( ++p == pe ) + goto _test_eof45; +case 45: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st46; + case 95: goto st46; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st46; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st46; + } else + goto st46; + goto st0; +st46: + if ( ++p == pe ) + goto _test_eof46; +case 46: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st47; + case 95: goto st47; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st47; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st47; + } else + goto st47; + goto st0; +st47: + if ( ++p == pe ) + goto _test_eof47; +case 47: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st48; + case 95: goto st48; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st48; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st48; + } else + goto st48; + goto st0; +st48: + if ( ++p == pe ) + goto _test_eof48; +case 48: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st49; + case 95: goto st49; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st49; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st49; + } else + goto st49; + goto st0; +st49: + if ( ++p == pe ) + goto _test_eof49; +case 49: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st50; + case 95: goto st50; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st50; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st50; + } else + goto st50; + goto st0; +st50: + if ( ++p == pe ) + goto _test_eof50; +case 50: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st51; + case 95: goto st51; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st51; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st51; + } else + goto st51; + goto st0; +st51: + if ( ++p == pe ) + goto _test_eof51; +case 51: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st52; + case 95: goto st52; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st52; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st52; + } else + goto st52; + goto st0; +st52: + if ( ++p == pe ) + goto _test_eof52; +case 52: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st53; + case 95: goto st53; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st53; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st53; + } else + goto st53; + goto st0; +st53: + if ( ++p == pe ) + goto _test_eof53; +case 53: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st54; + case 95: goto st54; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st54; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st54; + } else + goto st54; + goto st0; +st54: + if ( ++p == pe ) + goto _test_eof54; +case 54: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st55; + case 95: goto st55; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st55; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st55; + } else + goto st55; + goto st0; +st55: + if ( ++p == pe ) + goto _test_eof55; +case 55: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st56; + case 95: goto st56; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st56; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st56; + } else + goto st56; + goto st0; +st56: + if ( ++p == pe ) + goto _test_eof56; +case 56: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st57; + case 95: goto st57; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st57; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st57; + } else + goto st57; + goto st0; +st57: + if ( ++p == pe ) + goto _test_eof57; +case 57: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st58; + case 95: goto st58; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st58; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st58; + } else + goto st58; + goto st0; +st58: + if ( ++p == pe ) + goto _test_eof58; +case 58: + switch( (*p) ) { + case 32: goto tr2; + case 36: goto st59; + case 95: goto st59; + } + if ( (*p) < 48 ) { + if ( 45 <= (*p) && (*p) <= 46 ) + goto st59; + } else if ( (*p) > 57 ) { + if ( 65 <= (*p) && (*p) <= 90 ) + goto st59; + } else + goto st59; + goto st0; +st59: + if ( ++p == pe ) + goto _test_eof59; +case 59: + if ( (*p) == 32 ) + goto tr2; + goto st0; + } + _test_eof2: cs = 2; goto _test_eof; + _test_eof3: cs = 3; goto _test_eof; + _test_eof4: cs = 4; goto _test_eof; + _test_eof5: cs = 5; goto _test_eof; + _test_eof6: cs = 6; goto _test_eof; + _test_eof7: cs = 7; goto _test_eof; + _test_eof8: cs = 8; goto _test_eof; + _test_eof9: cs = 9; goto _test_eof; + _test_eof10: cs = 10; goto _test_eof; + _test_eof11: cs = 11; goto _test_eof; + _test_eof12: cs = 12; goto _test_eof; + _test_eof13: cs = 13; goto _test_eof; + _test_eof14: cs = 14; goto _test_eof; + _test_eof60: cs = 60; goto _test_eof; + _test_eof15: cs = 15; goto _test_eof; + _test_eof16: cs = 16; goto _test_eof; + _test_eof17: cs = 17; goto _test_eof; + _test_eof18: cs = 18; goto _test_eof; + _test_eof19: cs = 19; goto _test_eof; + _test_eof20: cs = 20; goto _test_eof; + _test_eof21: cs = 21; goto _test_eof; + _test_eof22: cs = 22; goto _test_eof; + _test_eof23: cs = 23; goto _test_eof; + _test_eof24: cs = 24; goto _test_eof; + _test_eof25: cs = 25; goto _test_eof; + _test_eof26: cs = 26; goto _test_eof; + _test_eof27: cs = 27; goto _test_eof; + _test_eof28: cs = 28; goto _test_eof; + _test_eof29: cs = 29; goto _test_eof; + _test_eof30: cs = 30; goto _test_eof; + _test_eof31: cs = 31; goto _test_eof; + _test_eof32: cs = 32; goto _test_eof; + _test_eof33: cs = 33; goto _test_eof; + _test_eof34: cs = 34; goto _test_eof; + _test_eof35: cs = 35; goto _test_eof; + _test_eof36: cs = 36; goto _test_eof; + _test_eof37: cs = 37; goto _test_eof; + _test_eof38: cs = 38; goto _test_eof; + _test_eof39: cs = 39; goto _test_eof; + _test_eof40: cs = 40; goto _test_eof; + _test_eof41: cs = 41; goto _test_eof; + _test_eof42: cs = 42; goto _test_eof; + _test_eof43: cs = 43; goto _test_eof; + _test_eof44: cs = 44; goto _test_eof; + _test_eof45: cs = 45; goto _test_eof; + _test_eof46: cs = 46; goto _test_eof; + _test_eof47: cs = 47; goto _test_eof; + _test_eof48: cs = 48; goto _test_eof; + _test_eof49: cs = 49; goto _test_eof; + _test_eof50: cs = 50; goto _test_eof; + _test_eof51: cs = 51; goto _test_eof; + _test_eof52: cs = 52; goto _test_eof; + _test_eof53: cs = 53; goto _test_eof; + _test_eof54: cs = 54; goto _test_eof; + _test_eof55: cs = 55; goto _test_eof; + _test_eof56: cs = 56; goto _test_eof; + _test_eof57: cs = 57; goto _test_eof; + _test_eof58: cs = 58; goto _test_eof; + _test_eof59: cs = 59; goto _test_eof; + + _test_eof: {} + _out: {} + } + +#line 213 "http11_parser.rl" + + assert(p <= pe && "Buffer overflow after parsing."); + + if (!http_parser_has_error(parser)) { + parser->cs = cs; + } + + parser->nread += p - (buffer + off); + + assert(parser->nread <= len && "nread longer than length"); + assert(parser->body_start <= len && "body starts after buffer end"); + assert(parser->mark < len && "mark is after buffer end"); + assert(parser->field_len <= len && "field has length longer than whole buffer"); + assert(parser->field_start < len && "field starts after buffer end"); + + return(parser->nread); +} + +int http_parser_finish(http_parser *parser) +{ + if (http_parser_has_error(parser) ) { + return -1; + } else if (http_parser_is_finished(parser) ) { + return 1; + } else { + return 0; + } +} + +int http_parser_has_error(http_parser *parser) { + return parser->cs == http_parser_error; +} + +int http_parser_is_finished(http_parser *parser) { + return parser->cs >= http_parser_first_final; +} diff --git a/original_parser/http11_parser.h b/original_parser/http11_parser.h new file mode 100644 index 0000000..c7f0ae1 --- /dev/null +++ b/original_parser/http11_parser.h @@ -0,0 +1,41 @@ + +#ifndef http11_parser_h +#define http11_parser_h + +#include "http11_common.h" + +enum { CONTENT_LENGTH + , CONTENT_TYPE + , FRAGMENT + , HTTP_VERSION + , QUERY_STRING + , REQUEST_PATH + , REQUEST_METHOD + , REQUEST_URI + }; + +typedef struct http_parser { + int cs; + size_t body_start; + int content_len; + size_t nread; + size_t mark; + size_t field_start; + size_t field_len; + size_t query_start; + + void *data; + + field_cb http_field; + element_cb on_element; +} http_parser; + +int http_parser_init(http_parser *parser); +int http_parser_finish(http_parser *parser); +size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off); +int http_parser_has_error(http_parser *parser); +int http_parser_is_finished(http_parser *parser); + +#define http_parser_nread(parser) (parser)->nread + +#endif diff --git a/original_parser/parser.rl b/original_parser/http11_parser.rl similarity index 56% rename from original_parser/parser.rl rename to original_parser/http11_parser.rl index 5850e9f..301ec4e 100644 --- a/original_parser/parser.rl +++ b/original_parser/http11_parser.rl @@ -1,92 +1,115 @@ /** - * Copyright (c) 2005 Zed A. Shaw - * You can redistribute it and/or modify it under the same terms as Ruby. + * + * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names + * of its contributors may be used to endorse or promote products + * derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "parser.h" + +#include "http11_parser.h" #include #include #include #include #include -#define TRUE 1 -#define FALSE 0 #define LEN(AT, FPC) (FPC - buffer - parser->AT) #define MARK(M,FPC) (parser->M = (FPC) - buffer) #define PTR_TO(F) (buffer + parser->F) -/** machine **/ + +/** Machine **/ + %%{ - machine http_parser; + machine http_parser; + action mark {MARK(mark, fpc); } - + + action start_field { MARK(field_start, fpc); } action write_field { parser->field_len = LEN(field_start, fpc); - if(parser->field_len > 256) { - parser->overflow_error = TRUE; - fbreak; - } } - + action start_value { MARK(mark, fpc); } + action write_value { - if(LEN(mark, fpc) > 80 * 1024) { parser->overflow_error = TRUE; fbreak; } if(parser->http_field != NULL) { parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc)); } } - - action content_length { - if(!apply_element(parser, MONGREL_CONTENT_LENGTH, PTR_TO(mark), fpc, 20)) - fbreak; - set_content_length(parser, PTR_TO(mark), LEN(mark, fpc)); - } - + action content_type { - if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), fpc, 10*1024)) + if(!apply_element(parser, CONTENT_TYPE, PTR_TO(mark), fpc, 10*1024)) fbreak; } - + action fragment { - if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), fpc, 10*1024)) + if(!apply_element(parser, FRAGMENT, PTR_TO(mark), fpc, 10*1024)) fbreak; } - + action http_version { - if(!apply_element(parser, MONGREL_HTTP_VERSION, PTR_TO(mark), fpc, 10)) + if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), fpc, 10)) fbreak; } - + action request_path { - if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), fpc, 1024)) + if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), fpc, 1024)) fbreak; } - + action request_method { - if(!apply_element(parser, MONGREL_REQUEST_METHOD, PTR_TO(mark), fpc, 1024)) + if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), fpc, 1024)) fbreak; } - + action request_uri { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), fpc, 12*1024)) + if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), fpc, 12*1024)) fbreak; } - + action start_query {MARK(query_start, fpc); } + action query_string { - if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), fpc, 10*1024)) + if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), fpc, 10*1024)) fbreak; } - + action done { - parser->body_start = fpc - buffer + 1; + parser->body_start = fpc - buffer + 1; fbreak; } #### HTTP PROTOCOL GRAMMAR # line endings - CRLF = "\r\n"; + CRLF = ("\r\n" | "\n"); # character types CTL = (cntrl | 127); @@ -105,7 +128,7 @@ token = (ascii -- (CTL | tspecials)); # URI schemes and absolute paths - scheme = ( alpha | digit | "+" | "-" | "." )* ; + scheme = "http"; absolute_uri = (scheme ":" (uchar | reserved )*); path = ( pchar+ ( "/" pchar* )* ) ; @@ -119,119 +142,99 @@ Fragment = ( uchar | reserved )* >mark %fragment; Method = ( upper | digit | safe ){1,20} >mark %request_method; - http_number = ( digit+ "." digit+ ) ; + http_number = ( "1." ("0" | "1") ) ; HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ; Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ; field_name = ( token -- ":" )+ >start_field %write_field; field_value = any* >start_value %write_value; - - known_headers = ( ("Content-Length:"i " "* (digit+ >mark %content_length)) - | ("Content-Type:"i " "* (any* >mark %content_type)) - ) :> CRLF; - unknown_header = (field_name ":" " "* field_value :> CRLF) -- known_headers; - - Request = Request_Line (known_headers | unknown_header)* ( CRLF @done ); -main := Request; + message_header = field_name ":" " "* field_value :> CRLF; + + Request = Request_Line ( message_header )* ( CRLF ); + +main := (Request ) @done; }%% /** Data **/ %% write data; -/* returns TRUE if applied, FALSE if there was an error */ static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length) { int len = (int)(end-begin); if(len > max_length) { - parser->overflow_error = TRUE; - return FALSE; + return(0); } if(parser->on_element) parser->on_element(parser->data, type, begin, len); - return TRUE; + return(1); } -static void set_content_length(http_parser *parser, const char *at, int length) -{ - /* atoi_length - why isn't this in the statndard library? i hate c */ - assert(parser->content_length == 0); - int i, mult; - for(mult=1, i=length-1; i>=0; i--, mult*=10) - parser->content_length += (at[i] - '0') * mult; -} -void http_parser_init(http_parser *parser) { + +int http_parser_init(http_parser *parser) { int cs = 0; %% write init; parser->cs = cs; - parser->overflow_error = FALSE; parser->body_start = 0; - parser->content_length = 0; + parser->content_len = 0; parser->mark = 0; parser->nread = 0; parser->field_len = 0; parser->field_start = 0; - parser->data = NULL; - parser->http_field = NULL; -} + return(1); +} /** exec **/ -size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off) { +size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off) +{ + if(len == 0) return 0; + const char *p, *pe; int cs = parser->cs; - + assert(off <= len && "offset past end of buffer"); - + p = buffer+off; pe = buffer+len; - - /* Ragel 6 does not require this */ - // assert(*pe == '\0' && "pointer does not end on NUL"); - assert(pe - p == len - off && "pointers aren't same distance"); - + + assert(pe - p == (int)len - (int)off && "pointers aren't same distance"); + %% write exec; - - parser->cs = cs; + + assert(p <= pe && "Buffer overflow after parsing."); + + if (!http_parser_has_error(parser)) { + parser->cs = cs; + } + parser->nread += p - (buffer + off); - - assert(p <= pe && "buffer overflow after parsing execute"); + assert(parser->nread <= len && "nread longer than length"); assert(parser->body_start <= len && "body starts after buffer end"); assert(parser->mark < len && "mark is after buffer end"); assert(parser->field_len <= len && "field has length longer than whole buffer"); assert(parser->field_start < len && "field starts after buffer end"); - - if(parser->nread > 1024 * (80 + 32)) - parser->overflow_error = TRUE; - - - /* Ragel 6 does not use write eof; no need for this - if(parser->body_start) { - // final \r\n combo encountered so stop right here - parser->nread++; - %% write eof; - } - */ - + return(parser->nread); } int http_parser_finish(http_parser *parser) { - if (http_parser_has_error(parser)) + if (http_parser_has_error(parser) ) { return -1; - else if (http_parser_is_finished(parser)) + } else if (http_parser_is_finished(parser) ) { return 1; - else + } else { return 0; + } } int http_parser_has_error(http_parser *parser) { - return parser->cs == http_parser_error || parser->overflow_error; + return parser->cs == http_parser_error; } int http_parser_is_finished(http_parser *parser) { diff --git a/original_parser/parser.h b/original_parser/parser.h deleted file mode 100644 index d515281..0000000 --- a/original_parser/parser.h +++ /dev/null @@ -1,53 +0,0 @@ -/** - * Copyright (c) 2005 Zed A. Shaw - * You can redistribute it and/or modify it under the same terms as Ruby. - */ - -#ifndef http11_parser_h -#define http11_parser_h - -#include - -#if defined(_WIN32) -#include -#endif - -enum { MONGREL_CONTENT_LENGTH - , MONGREL_CONTENT_TYPE - , MONGREL_FRAGMENT - , MONGREL_HTTP_VERSION - , MONGREL_QUERY_STRING - , MONGREL_REQUEST_PATH - , MONGREL_REQUEST_METHOD - , MONGREL_REQUEST_URI - }; - -typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen); -typedef void (*element_cb)(void *data, int type, const char *at, size_t length); - -typedef struct http_parser { - int cs; - int overflow_error; - size_t body_start; - size_t content_length; - size_t nread; - size_t mark; - size_t field_start; - size_t field_len; - size_t query_start; - - void *data; - - field_cb http_field; - element_cb on_element; -} http_parser; - -void http_parser_init(http_parser *parser); -int http_parser_finish(http_parser *parser); -size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off); -int http_parser_has_error(http_parser *parser); -int http_parser_is_finished(http_parser *parser); - -#define http_parser_nread(parser) (parser)->nread - -#endif diff --git a/parser.c b/parser.c deleted file mode 100644 index d30253c..0000000 --- a/parser.c +++ /dev/null @@ -1,2860 +0,0 @@ -#line 1 "src/parser.rl" -/** - * Copyright (c) 2005 Zed A. Shaw - * You can redistribute it and/or modify it under the same terms as Ruby. - */ -#include "parser.h" -#include -#include -#include -#include -#include - -#define TRUE 1 -#define FALSE 0 -#define LEN(AT, FPC) (FPC - buffer - parser->AT) -#define MARK(M,FPC) (parser->M = (FPC) - buffer) -#define PTR_TO(F) (buffer + parser->F) -/** machine **/ -#line 139 "src/parser.rl" - - -/** Data **/ - -#line 25 "src/parser.c" -static const int http_parser_start = 1; -static const int http_parser_first_final = 118; -static const int http_parser_error = 0; - -static const int http_parser_en_main = 1; - -#line 143 "src/parser.rl" - -/* returns TRUE if applied, FALSE if there was an error */ -static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length) -{ - int len = (int)(end-begin); - if(len > max_length) { - parser->overflow_error = TRUE; - return FALSE; - } - if(parser->on_element) - parser->on_element(parser->data, type, begin, len); - return TRUE; -} - -static void set_content_length(http_parser *parser, const char *at, int length) -{ - /* atoi_length - why isn't this in the statndard library? i hate c */ - assert(parser->content_length == 0); - int i, mult; - for(mult=1, i=length-1; i>=0; i--, mult*=10) - parser->content_length += (at[i] - '0') * mult; -} - -void http_parser_init(http_parser *parser) { - int cs = 0; - -#line 59 "src/parser.c" - { - cs = http_parser_start; - } -#line 169 "src/parser.rl" - parser->cs = cs; - parser->overflow_error = FALSE; - parser->body_start = 0; - parser->content_length = 0; - parser->mark = 0; - parser->nread = 0; - parser->field_len = 0; - parser->field_start = 0; - parser->data = NULL; - parser->http_field = NULL; -} - - -/** exec **/ -size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off) { - const char *p, *pe; - int cs = parser->cs; - - assert(off <= len && "offset past end of buffer"); - - p = buffer+off; - pe = buffer+len; - - /* Ragel 6 does not require this */ - // assert(*pe == '\0' && "pointer does not end on NUL"); - assert(pe - p == len - off && "pointers aren't same distance"); - - -#line 92 "src/parser.c" - { - if ( p == pe ) - goto _test_eof; - switch ( cs ) - { -case 1: - switch( (*p) ) { - case 36: goto tr0; - case 95: goto tr0; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto tr0; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto tr0; - } else - goto tr0; - goto st0; -st0: -cs = 0; - goto _out; -tr0: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st2; -st2: - if ( ++p == pe ) - goto _test_eof2; -case 2: -#line 123 "src/parser.c" - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st99; - case 95: goto st99; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st99; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st99; - } else - goto st99; - goto st0; -tr2: -#line 66 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_METHOD, PTR_TO(mark), p, 1024)) - {p++; cs = 3; goto _out;} - } - goto st3; -st3: - if ( ++p == pe ) - goto _test_eof3; -case 3: -#line 149 "src/parser.c" - switch( (*p) ) { - case 42: goto tr4; - case 43: goto tr5; - case 47: goto tr6; - case 58: goto tr7; - } - if ( (*p) < 65 ) { - if ( 45 <= (*p) && (*p) <= 57 ) - goto tr5; - } else if ( (*p) > 90 ) { - if ( 97 <= (*p) && (*p) <= 122 ) - goto tr5; - } else - goto tr5; - goto st0; -tr4: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st4; -st4: - if ( ++p == pe ) - goto _test_eof4; -case 4: -#line 173 "src/parser.c" - switch( (*p) ) { - case 32: goto tr8; - case 35: goto tr9; - } - goto st0; -tr8: -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -tr103: -#line 21 "src/parser.rl" - {MARK(mark, p); } -#line 51 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -tr106: -#line 51 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -tr114: -#line 61 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024)) - {p++; cs = 5; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -tr125: -#line 76 "src/parser.rl" - {MARK(query_start, p); } -#line 77 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024)) - {p++; cs = 5; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -tr129: -#line 77 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024)) - {p++; cs = 5; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 5; goto _out;} - } - goto st5; -st5: - if ( ++p == pe ) - goto _test_eof5; -case 5: -#line 244 "src/parser.c" - if ( (*p) == 72 ) - goto tr10; - goto st0; -tr10: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st6; -st6: - if ( ++p == pe ) - goto _test_eof6; -case 6: -#line 256 "src/parser.c" - if ( (*p) == 84 ) - goto st7; - goto st0; -st7: - if ( ++p == pe ) - goto _test_eof7; -case 7: - if ( (*p) == 84 ) - goto st8; - goto st0; -st8: - if ( ++p == pe ) - goto _test_eof8; -case 8: - if ( (*p) == 80 ) - goto st9; - goto st0; -st9: - if ( ++p == pe ) - goto _test_eof9; -case 9: - if ( (*p) == 47 ) - goto st10; - goto st0; -st10: - if ( ++p == pe ) - goto _test_eof10; -case 10: - if ( 48 <= (*p) && (*p) <= 57 ) - goto st11; - goto st0; -st11: - if ( ++p == pe ) - goto _test_eof11; -case 11: - if ( (*p) == 46 ) - goto st12; - if ( 48 <= (*p) && (*p) <= 57 ) - goto st11; - goto st0; -st12: - if ( ++p == pe ) - goto _test_eof12; -case 12: - if ( 48 <= (*p) && (*p) <= 57 ) - goto st13; - goto st0; -st13: - if ( ++p == pe ) - goto _test_eof13; -case 13: - if ( (*p) == 13 ) - goto tr18; - if ( 48 <= (*p) && (*p) <= 57 ) - goto st13; - goto st0; -tr18: -#line 56 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_HTTP_VERSION, PTR_TO(mark), p, 10)) - {p++; cs = 14; goto _out;} - } - goto st14; -tr28: -#line 32 "src/parser.rl" - { MARK(mark, p); } -#line 33 "src/parser.rl" - { - if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} } - if(parser->http_field != NULL) { - parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); - } - } - goto st14; -tr32: -#line 33 "src/parser.rl" - { - if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} } - if(parser->http_field != NULL) { - parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p)); - } - } - goto st14; -tr91: -#line 40 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_CONTENT_LENGTH, PTR_TO(mark), p, 20)) - {p++; cs = 14; goto _out;} - set_content_length(parser, PTR_TO(mark), LEN(mark, p)); - } - goto st14; -tr98: -#line 21 "src/parser.rl" - {MARK(mark, p); } -#line 46 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024)) - {p++; cs = 14; goto _out;} - } - goto st14; -tr101: -#line 46 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024)) - {p++; cs = 14; goto _out;} - } - goto st14; -st14: - if ( ++p == pe ) - goto _test_eof14; -case 14: -#line 368 "src/parser.c" - if ( (*p) == 10 ) - goto st15; - goto st0; -st15: - if ( ++p == pe ) - goto _test_eof15; -case 15: - switch( (*p) ) { - case 13: goto st16; - case 33: goto tr21; - case 67: goto tr22; - case 99: goto tr22; - case 124: goto tr21; - case 126: goto tr21; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto tr21; - } else if ( (*p) >= 35 ) - goto tr21; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto tr21; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto tr21; - } else - goto tr21; - } else - goto tr21; - goto st0; -st16: - if ( ++p == pe ) - goto _test_eof16; -case 16: - if ( (*p) == 10 ) - goto tr23; - goto st0; -tr23: -#line 82 "src/parser.rl" - { - parser->body_start = p - buffer + 1; - {p++; cs = 118; goto _out;} - } - goto st118; -st118: - if ( ++p == pe ) - goto _test_eof118; -case 118: -#line 420 "src/parser.c" - goto st0; -tr21: -#line 23 "src/parser.rl" - { MARK(field_start, p); } - goto st17; -st17: - if ( ++p == pe ) - goto _test_eof17; -case 17: -#line 430 "src/parser.c" - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -tr25: -#line 24 "src/parser.rl" - { - parser->field_len = LEN(field_start, p); - if(parser->field_len > 256) { - parser->overflow_error = TRUE; - {p++; cs = 18; goto _out;} - } - } - goto st18; -tr29: -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st18; -st18: - if ( ++p == pe ) - goto _test_eof18; -case 18: -#line 475 "src/parser.c" - switch( (*p) ) { - case 13: goto tr28; - case 32: goto tr29; - case 67: goto tr30; - case 99: goto tr30; - } - goto tr27; -tr27: -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st19; -st19: - if ( ++p == pe ) - goto _test_eof19; -case 19: -#line 491 "src/parser.c" - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 99: goto st20; - } - goto st19; -tr30: -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st20; -st20: - if ( ++p == pe ) - goto _test_eof20; -case 20: -#line 506 "src/parser.c" - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 79: goto st21; - case 99: goto st20; - case 111: goto st21; - } - goto st19; -st21: - if ( ++p == pe ) - goto _test_eof21; -case 21: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 78: goto st22; - case 99: goto st20; - case 110: goto st22; - } - goto st19; -st22: - if ( ++p == pe ) - goto _test_eof22; -case 22: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 84: goto st23; - case 99: goto st20; - case 116: goto st23; - } - goto st19; -st23: - if ( ++p == pe ) - goto _test_eof23; -case 23: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 69: goto st24; - case 99: goto st20; - case 101: goto st24; - } - goto st19; -st24: - if ( ++p == pe ) - goto _test_eof24; -case 24: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 78: goto st25; - case 99: goto st20; - case 110: goto st25; - } - goto st19; -st25: - if ( ++p == pe ) - goto _test_eof25; -case 25: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 84: goto st26; - case 99: goto st20; - case 116: goto st26; - } - goto st19; -st26: - if ( ++p == pe ) - goto _test_eof26; -case 26: - switch( (*p) ) { - case 13: goto tr32; - case 45: goto st27; - case 67: goto st20; - case 99: goto st20; - } - goto st19; -st27: - if ( ++p == pe ) - goto _test_eof27; -case 27: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 76: goto st28; - case 84: goto st36; - case 99: goto st20; - case 108: goto st28; - case 116: goto st36; - } - goto st19; -st28: - if ( ++p == pe ) - goto _test_eof28; -case 28: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 69: goto st29; - case 99: goto st20; - case 101: goto st29; - } - goto st19; -st29: - if ( ++p == pe ) - goto _test_eof29; -case 29: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 78: goto st30; - case 99: goto st20; - case 110: goto st30; - } - goto st19; -st30: - if ( ++p == pe ) - goto _test_eof30; -case 30: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 71: goto st31; - case 99: goto st20; - case 103: goto st31; - } - goto st19; -st31: - if ( ++p == pe ) - goto _test_eof31; -case 31: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 84: goto st32; - case 99: goto st20; - case 116: goto st32; - } - goto st19; -st32: - if ( ++p == pe ) - goto _test_eof32; -case 32: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 72: goto st33; - case 99: goto st20; - case 104: goto st33; - } - goto st19; -st33: - if ( ++p == pe ) - goto _test_eof33; -case 33: - switch( (*p) ) { - case 13: goto tr32; - case 58: goto st34; - case 67: goto st20; - case 99: goto st20; - } - goto st19; -st34: - if ( ++p == pe ) - goto _test_eof34; -case 34: - switch( (*p) ) { - case 13: goto tr32; - case 32: goto st34; - case 67: goto st20; - case 99: goto st20; - } - if ( 48 <= (*p) && (*p) <= 57 ) - goto tr49; - goto st19; -tr49: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st35; -tr70: -#line 32 "src/parser.rl" - { MARK(mark, p); } -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st35; -st35: - if ( ++p == pe ) - goto _test_eof35; -case 35: -#line 698 "src/parser.c" - switch( (*p) ) { - case 13: goto st0; - case 67: goto st20; - case 99: goto st20; - } - if ( 48 <= (*p) && (*p) <= 57 ) - goto st35; - goto st19; -st36: - if ( ++p == pe ) - goto _test_eof36; -case 36: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 89: goto st37; - case 99: goto st20; - case 121: goto st37; - } - goto st19; -st37: - if ( ++p == pe ) - goto _test_eof37; -case 37: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 80: goto st38; - case 99: goto st20; - case 112: goto st38; - } - goto st19; -st38: - if ( ++p == pe ) - goto _test_eof38; -case 38: - switch( (*p) ) { - case 13: goto tr32; - case 67: goto st20; - case 69: goto st39; - case 99: goto st20; - case 101: goto st39; - } - goto st19; -st39: - if ( ++p == pe ) - goto _test_eof39; -case 39: - switch( (*p) ) { - case 13: goto tr32; - case 58: goto st0; - case 67: goto st20; - case 99: goto st20; - } - goto st19; -st40: - if ( ++p == pe ) - goto _test_eof40; -case 40: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 79: goto st41; - case 99: goto st40; - case 111: goto st41; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st41: - if ( ++p == pe ) - goto _test_eof41; -case 41: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st42; - case 99: goto st40; - case 110: goto st42; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st42: - if ( ++p == pe ) - goto _test_eof42; -case 42: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st43; - case 99: goto st40; - case 116: goto st43; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st43: - if ( ++p == pe ) - goto _test_eof43; -case 43: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st44; - case 99: goto st40; - case 101: goto st44; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st44: - if ( ++p == pe ) - goto _test_eof44; -case 44: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st45; - case 99: goto st40; - case 110: goto st45; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st45: - if ( ++p == pe ) - goto _test_eof45; -case 45: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st46; - case 99: goto st40; - case 116: goto st46; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st46: - if ( ++p == pe ) - goto _test_eof46; -case 46: - switch( (*p) ) { - case 33: goto st17; - case 45: goto st47; - case 46: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 48 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 57 ) { - if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else if ( (*p) >= 65 ) - goto st17; - } else - goto st17; - goto st0; -st47: - if ( ++p == pe ) - goto _test_eof47; -case 47: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 76: goto st48; - case 84: goto st55; - case 99: goto st40; - case 108: goto st48; - case 116: goto st55; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st48: - if ( ++p == pe ) - goto _test_eof48; -case 48: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st49; - case 99: goto st40; - case 101: goto st49; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st49: - if ( ++p == pe ) - goto _test_eof49; -case 49: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st50; - case 99: goto st40; - case 110: goto st50; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st50: - if ( ++p == pe ) - goto _test_eof50; -case 50: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 71: goto st51; - case 99: goto st40; - case 103: goto st51; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st51: - if ( ++p == pe ) - goto _test_eof51; -case 51: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st52; - case 99: goto st40; - case 116: goto st52; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st52: - if ( ++p == pe ) - goto _test_eof52; -case 52: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 72: goto st53; - case 99: goto st40; - case 104: goto st53; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st53: - if ( ++p == pe ) - goto _test_eof53; -case 53: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr68; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -tr68: -#line 24 "src/parser.rl" - { - parser->field_len = LEN(field_start, p); - if(parser->field_len > 256) { - parser->overflow_error = TRUE; - {p++; cs = 54; goto _out;} - } - } - goto st54; -tr69: -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st54; -st54: - if ( ++p == pe ) - goto _test_eof54; -case 54: -#line 1217 "src/parser.c" - switch( (*p) ) { - case 13: goto tr28; - case 32: goto tr69; - case 67: goto tr30; - case 99: goto tr30; - } - if ( 48 <= (*p) && (*p) <= 57 ) - goto tr70; - goto tr27; -st55: - if ( ++p == pe ) - goto _test_eof55; -case 55: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 89: goto st56; - case 99: goto st40; - case 121: goto st56; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st56: - if ( ++p == pe ) - goto _test_eof56; -case 56: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 80: goto st57; - case 99: goto st40; - case 112: goto st57; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st57: - if ( ++p == pe ) - goto _test_eof57; -case 57: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st58; - case 99: goto st40; - case 101: goto st58; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st58: - if ( ++p == pe ) - goto _test_eof58; -case 58: - switch( (*p) ) { - case 33: goto st17; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -tr22: -#line 23 "src/parser.rl" - { MARK(field_start, p); } - goto st59; -st59: - if ( ++p == pe ) - goto _test_eof59; -case 59: -#line 1360 "src/parser.c" - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 79: goto st60; - case 99: goto st40; - case 111: goto st60; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st60: - if ( ++p == pe ) - goto _test_eof60; -case 60: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st61; - case 99: goto st40; - case 110: goto st61; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st61: - if ( ++p == pe ) - goto _test_eof61; -case 61: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st62; - case 99: goto st40; - case 116: goto st62; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st62: - if ( ++p == pe ) - goto _test_eof62; -case 62: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st63; - case 99: goto st40; - case 101: goto st63; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st63: - if ( ++p == pe ) - goto _test_eof63; -case 63: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st64; - case 99: goto st40; - case 110: goto st64; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st64: - if ( ++p == pe ) - goto _test_eof64; -case 64: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st65; - case 99: goto st40; - case 116: goto st65; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st65: - if ( ++p == pe ) - goto _test_eof65; -case 65: - switch( (*p) ) { - case 33: goto st17; - case 45: goto st66; - case 46: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 48 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 57 ) { - if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else if ( (*p) >= 65 ) - goto st17; - } else - goto st17; - goto st0; -st66: - if ( ++p == pe ) - goto _test_eof66; -case 66: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 76: goto st67; - case 84: goto st75; - case 99: goto st40; - case 108: goto st67; - case 116: goto st75; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st67: - if ( ++p == pe ) - goto _test_eof67; -case 67: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st68; - case 99: goto st40; - case 101: goto st68; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st68: - if ( ++p == pe ) - goto _test_eof68; -case 68: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 78: goto st69; - case 99: goto st40; - case 110: goto st69; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st69: - if ( ++p == pe ) - goto _test_eof69; -case 69: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 71: goto st70; - case 99: goto st40; - case 103: goto st70; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st70: - if ( ++p == pe ) - goto _test_eof70; -case 70: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 84: goto st71; - case 99: goto st40; - case 116: goto st71; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st71: - if ( ++p == pe ) - goto _test_eof71; -case 71: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 72: goto st72; - case 99: goto st40; - case 104: goto st72; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st72: - if ( ++p == pe ) - goto _test_eof72; -case 72: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr88; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -tr88: -#line 24 "src/parser.rl" - { - parser->field_len = LEN(field_start, p); - if(parser->field_len > 256) { - parser->overflow_error = TRUE; - {p++; cs = 73; goto _out;} - } - } - goto st73; -tr89: -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st73; -st73: - if ( ++p == pe ) - goto _test_eof73; -case 73: -#line 1820 "src/parser.c" - switch( (*p) ) { - case 13: goto tr28; - case 32: goto tr89; - case 67: goto tr30; - case 99: goto tr30; - } - if ( 48 <= (*p) && (*p) <= 57 ) - goto tr90; - goto tr27; -tr90: -#line 21 "src/parser.rl" - {MARK(mark, p); } -#line 32 "src/parser.rl" - { MARK(mark, p); } - goto st74; -st74: - if ( ++p == pe ) - goto _test_eof74; -case 74: -#line 1840 "src/parser.c" - switch( (*p) ) { - case 13: goto tr91; - case 67: goto st20; - case 99: goto st20; - } - if ( 48 <= (*p) && (*p) <= 57 ) - goto st74; - goto st19; -st75: - if ( ++p == pe ) - goto _test_eof75; -case 75: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 89: goto st76; - case 99: goto st40; - case 121: goto st76; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st76: - if ( ++p == pe ) - goto _test_eof76; -case 76: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 80: goto st77; - case 99: goto st40; - case 112: goto st77; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st77: - if ( ++p == pe ) - goto _test_eof77; -case 77: - switch( (*p) ) { - case 33: goto st17; - case 58: goto tr25; - case 67: goto st40; - case 69: goto st78; - case 99: goto st40; - case 101: goto st78; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -st78: - if ( ++p == pe ) - goto _test_eof78; -case 78: - switch( (*p) ) { - case 33: goto st17; - case 58: goto st79; - case 67: goto st40; - case 99: goto st40; - case 124: goto st17; - case 126: goto st17; - } - if ( (*p) < 45 ) { - if ( (*p) > 39 ) { - if ( 42 <= (*p) && (*p) <= 43 ) - goto st17; - } else if ( (*p) >= 35 ) - goto st17; - } else if ( (*p) > 46 ) { - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st17; - } else if ( (*p) > 90 ) { - if ( 94 <= (*p) && (*p) <= 122 ) - goto st17; - } else - goto st17; - } else - goto st17; - goto st0; -tr99: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st79; -st79: - if ( ++p == pe ) - goto _test_eof79; -case 79: -#line 1983 "src/parser.c" - switch( (*p) ) { - case 13: goto tr98; - case 32: goto tr99; - } - goto tr97; -tr97: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st80; -st80: - if ( ++p == pe ) - goto _test_eof80; -case 80: -#line 1997 "src/parser.c" - if ( (*p) == 13 ) - goto tr101; - goto st80; -tr9: -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 81; goto _out;} - } - goto st81; -tr115: -#line 61 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024)) - {p++; cs = 81; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 81; goto _out;} - } - goto st81; -tr126: -#line 76 "src/parser.rl" - {MARK(query_start, p); } -#line 77 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024)) - {p++; cs = 81; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 81; goto _out;} - } - goto st81; -tr130: -#line 77 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024)) - {p++; cs = 81; goto _out;} - } -#line 71 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024)) - {p++; cs = 81; goto _out;} - } - goto st81; -st81: - if ( ++p == pe ) - goto _test_eof81; -case 81: -#line 2050 "src/parser.c" - switch( (*p) ) { - case 32: goto tr103; - case 37: goto tr104; - case 60: goto st0; - case 62: goto st0; - case 127: goto st0; - } - if ( (*p) > 31 ) { - if ( 34 <= (*p) && (*p) <= 35 ) - goto st0; - } else if ( (*p) >= 0 ) - goto st0; - goto tr102; -tr102: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st82; -st82: - if ( ++p == pe ) - goto _test_eof82; -case 82: -#line 2072 "src/parser.c" - switch( (*p) ) { - case 32: goto tr106; - case 37: goto st83; - case 60: goto st0; - case 62: goto st0; - case 127: goto st0; - } - if ( (*p) > 31 ) { - if ( 34 <= (*p) && (*p) <= 35 ) - goto st0; - } else if ( (*p) >= 0 ) - goto st0; - goto st82; -tr104: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st83; -st83: - if ( ++p == pe ) - goto _test_eof83; -case 83: -#line 2094 "src/parser.c" - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st84; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st84; - } else - goto st84; - goto st0; -st84: - if ( ++p == pe ) - goto _test_eof84; -case 84: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st82; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st82; - } else - goto st82; - goto st0; -tr5: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st85; -st85: - if ( ++p == pe ) - goto _test_eof85; -case 85: -#line 2125 "src/parser.c" - switch( (*p) ) { - case 43: goto st85; - case 58: goto st86; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st85; - } else if ( (*p) > 57 ) { - if ( (*p) > 90 ) { - if ( 97 <= (*p) && (*p) <= 122 ) - goto st85; - } else if ( (*p) >= 65 ) - goto st85; - } else - goto st85; - goto st0; -tr7: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st86; -st86: - if ( ++p == pe ) - goto _test_eof86; -case 86: -#line 2150 "src/parser.c" - switch( (*p) ) { - case 32: goto tr8; - case 34: goto st0; - case 35: goto tr9; - case 37: goto st87; - case 60: goto st0; - case 62: goto st0; - case 127: goto st0; - } - if ( 0 <= (*p) && (*p) <= 31 ) - goto st0; - goto st86; -st87: - if ( ++p == pe ) - goto _test_eof87; -case 87: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st88; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st88; - } else - goto st88; - goto st0; -st88: - if ( ++p == pe ) - goto _test_eof88; -case 88: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st86; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st86; - } else - goto st86; - goto st0; -tr6: -#line 21 "src/parser.rl" - {MARK(mark, p); } - goto st89; -st89: - if ( ++p == pe ) - goto _test_eof89; -case 89: -#line 2197 "src/parser.c" - switch( (*p) ) { - case 32: goto tr114; - case 34: goto st0; - case 35: goto tr115; - case 37: goto st90; - case 59: goto tr117; - case 60: goto st0; - case 62: goto st0; - case 63: goto tr118; - case 127: goto st0; - } - if ( 0 <= (*p) && (*p) <= 31 ) - goto st0; - goto st89; -st90: - if ( ++p == pe ) - goto _test_eof90; -case 90: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st91; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st91; - } else - goto st91; - goto st0; -st91: - if ( ++p == pe ) - goto _test_eof91; -case 91: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st89; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st89; - } else - goto st89; - goto st0; -tr117: -#line 61 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024)) - {p++; cs = 92; goto _out;} - } - goto st92; -st92: - if ( ++p == pe ) - goto _test_eof92; -case 92: -#line 2249 "src/parser.c" - switch( (*p) ) { - case 32: goto tr8; - case 34: goto st0; - case 35: goto tr9; - case 37: goto st93; - case 60: goto st0; - case 62: goto st0; - case 63: goto st95; - case 127: goto st0; - } - if ( 0 <= (*p) && (*p) <= 31 ) - goto st0; - goto st92; -st93: - if ( ++p == pe ) - goto _test_eof93; -case 93: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st94; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st94; - } else - goto st94; - goto st0; -st94: - if ( ++p == pe ) - goto _test_eof94; -case 94: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st92; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st92; - } else - goto st92; - goto st0; -tr118: -#line 61 "src/parser.rl" - { - if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024)) - {p++; cs = 95; goto _out;} - } - goto st95; -st95: - if ( ++p == pe ) - goto _test_eof95; -case 95: -#line 2300 "src/parser.c" - switch( (*p) ) { - case 32: goto tr125; - case 34: goto st0; - case 35: goto tr126; - case 37: goto tr127; - case 60: goto st0; - case 62: goto st0; - case 127: goto st0; - } - if ( 0 <= (*p) && (*p) <= 31 ) - goto st0; - goto tr124; -tr124: -#line 76 "src/parser.rl" - {MARK(query_start, p); } - goto st96; -st96: - if ( ++p == pe ) - goto _test_eof96; -case 96: -#line 2321 "src/parser.c" - switch( (*p) ) { - case 32: goto tr129; - case 34: goto st0; - case 35: goto tr130; - case 37: goto st97; - case 60: goto st0; - case 62: goto st0; - case 127: goto st0; - } - if ( 0 <= (*p) && (*p) <= 31 ) - goto st0; - goto st96; -tr127: -#line 76 "src/parser.rl" - {MARK(query_start, p); } - goto st97; -st97: - if ( ++p == pe ) - goto _test_eof97; -case 97: -#line 2342 "src/parser.c" - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st98; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st98; - } else - goto st98; - goto st0; -st98: - if ( ++p == pe ) - goto _test_eof98; -case 98: - if ( (*p) < 65 ) { - if ( 48 <= (*p) && (*p) <= 57 ) - goto st96; - } else if ( (*p) > 70 ) { - if ( 97 <= (*p) && (*p) <= 102 ) - goto st96; - } else - goto st96; - goto st0; -st99: - if ( ++p == pe ) - goto _test_eof99; -case 99: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st100; - case 95: goto st100; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st100; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st100; - } else - goto st100; - goto st0; -st100: - if ( ++p == pe ) - goto _test_eof100; -case 100: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st101; - case 95: goto st101; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st101; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st101; - } else - goto st101; - goto st0; -st101: - if ( ++p == pe ) - goto _test_eof101; -case 101: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st102; - case 95: goto st102; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st102; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st102; - } else - goto st102; - goto st0; -st102: - if ( ++p == pe ) - goto _test_eof102; -case 102: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st103; - case 95: goto st103; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st103; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st103; - } else - goto st103; - goto st0; -st103: - if ( ++p == pe ) - goto _test_eof103; -case 103: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st104; - case 95: goto st104; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st104; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st104; - } else - goto st104; - goto st0; -st104: - if ( ++p == pe ) - goto _test_eof104; -case 104: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st105; - case 95: goto st105; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st105; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st105; - } else - goto st105; - goto st0; -st105: - if ( ++p == pe ) - goto _test_eof105; -case 105: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st106; - case 95: goto st106; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st106; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st106; - } else - goto st106; - goto st0; -st106: - if ( ++p == pe ) - goto _test_eof106; -case 106: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st107; - case 95: goto st107; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st107; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st107; - } else - goto st107; - goto st0; -st107: - if ( ++p == pe ) - goto _test_eof107; -case 107: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st108; - case 95: goto st108; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st108; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st108; - } else - goto st108; - goto st0; -st108: - if ( ++p == pe ) - goto _test_eof108; -case 108: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st109; - case 95: goto st109; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st109; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st109; - } else - goto st109; - goto st0; -st109: - if ( ++p == pe ) - goto _test_eof109; -case 109: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st110; - case 95: goto st110; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st110; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st110; - } else - goto st110; - goto st0; -st110: - if ( ++p == pe ) - goto _test_eof110; -case 110: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st111; - case 95: goto st111; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st111; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st111; - } else - goto st111; - goto st0; -st111: - if ( ++p == pe ) - goto _test_eof111; -case 111: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st112; - case 95: goto st112; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st112; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st112; - } else - goto st112; - goto st0; -st112: - if ( ++p == pe ) - goto _test_eof112; -case 112: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st113; - case 95: goto st113; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st113; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st113; - } else - goto st113; - goto st0; -st113: - if ( ++p == pe ) - goto _test_eof113; -case 113: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st114; - case 95: goto st114; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st114; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st114; - } else - goto st114; - goto st0; -st114: - if ( ++p == pe ) - goto _test_eof114; -case 114: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st115; - case 95: goto st115; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st115; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st115; - } else - goto st115; - goto st0; -st115: - if ( ++p == pe ) - goto _test_eof115; -case 115: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st116; - case 95: goto st116; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st116; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st116; - } else - goto st116; - goto st0; -st116: - if ( ++p == pe ) - goto _test_eof116; -case 116: - switch( (*p) ) { - case 32: goto tr2; - case 36: goto st117; - case 95: goto st117; - } - if ( (*p) < 48 ) { - if ( 45 <= (*p) && (*p) <= 46 ) - goto st117; - } else if ( (*p) > 57 ) { - if ( 65 <= (*p) && (*p) <= 90 ) - goto st117; - } else - goto st117; - goto st0; -st117: - if ( ++p == pe ) - goto _test_eof117; -case 117: - if ( (*p) == 32 ) - goto tr2; - goto st0; - } - _test_eof2: cs = 2; goto _test_eof; - _test_eof3: cs = 3; goto _test_eof; - _test_eof4: cs = 4; goto _test_eof; - _test_eof5: cs = 5; goto _test_eof; - _test_eof6: cs = 6; goto _test_eof; - _test_eof7: cs = 7; goto _test_eof; - _test_eof8: cs = 8; goto _test_eof; - _test_eof9: cs = 9; goto _test_eof; - _test_eof10: cs = 10; goto _test_eof; - _test_eof11: cs = 11; goto _test_eof; - _test_eof12: cs = 12; goto _test_eof; - _test_eof13: cs = 13; goto _test_eof; - _test_eof14: cs = 14; goto _test_eof; - _test_eof15: cs = 15; goto _test_eof; - _test_eof16: cs = 16; goto _test_eof; - _test_eof118: cs = 118; goto _test_eof; - _test_eof17: cs = 17; goto _test_eof; - _test_eof18: cs = 18; goto _test_eof; - _test_eof19: cs = 19; goto _test_eof; - _test_eof20: cs = 20; goto _test_eof; - _test_eof21: cs = 21; goto _test_eof; - _test_eof22: cs = 22; goto _test_eof; - _test_eof23: cs = 23; goto _test_eof; - _test_eof24: cs = 24; goto _test_eof; - _test_eof25: cs = 25; goto _test_eof; - _test_eof26: cs = 26; goto _test_eof; - _test_eof27: cs = 27; goto _test_eof; - _test_eof28: cs = 28; goto _test_eof; - _test_eof29: cs = 29; goto _test_eof; - _test_eof30: cs = 30; goto _test_eof; - _test_eof31: cs = 31; goto _test_eof; - _test_eof32: cs = 32; goto _test_eof; - _test_eof33: cs = 33; goto _test_eof; - _test_eof34: cs = 34; goto _test_eof; - _test_eof35: cs = 35; goto _test_eof; - _test_eof36: cs = 36; goto _test_eof; - _test_eof37: cs = 37; goto _test_eof; - _test_eof38: cs = 38; goto _test_eof; - _test_eof39: cs = 39; goto _test_eof; - _test_eof40: cs = 40; goto _test_eof; - _test_eof41: cs = 41; goto _test_eof; - _test_eof42: cs = 42; goto _test_eof; - _test_eof43: cs = 43; goto _test_eof; - _test_eof44: cs = 44; goto _test_eof; - _test_eof45: cs = 45; goto _test_eof; - _test_eof46: cs = 46; goto _test_eof; - _test_eof47: cs = 47; goto _test_eof; - _test_eof48: cs = 48; goto _test_eof; - _test_eof49: cs = 49; goto _test_eof; - _test_eof50: cs = 50; goto _test_eof; - _test_eof51: cs = 51; goto _test_eof; - _test_eof52: cs = 52; goto _test_eof; - _test_eof53: cs = 53; goto _test_eof; - _test_eof54: cs = 54; goto _test_eof; - _test_eof55: cs = 55; goto _test_eof; - _test_eof56: cs = 56; goto _test_eof; - _test_eof57: cs = 57; goto _test_eof; - _test_eof58: cs = 58; goto _test_eof; - _test_eof59: cs = 59; goto _test_eof; - _test_eof60: cs = 60; goto _test_eof; - _test_eof61: cs = 61; goto _test_eof; - _test_eof62: cs = 62; goto _test_eof; - _test_eof63: cs = 63; goto _test_eof; - _test_eof64: cs = 64; goto _test_eof; - _test_eof65: cs = 65; goto _test_eof; - _test_eof66: cs = 66; goto _test_eof; - _test_eof67: cs = 67; goto _test_eof; - _test_eof68: cs = 68; goto _test_eof; - _test_eof69: cs = 69; goto _test_eof; - _test_eof70: cs = 70; goto _test_eof; - _test_eof71: cs = 71; goto _test_eof; - _test_eof72: cs = 72; goto _test_eof; - _test_eof73: cs = 73; goto _test_eof; - _test_eof74: cs = 74; goto _test_eof; - _test_eof75: cs = 75; goto _test_eof; - _test_eof76: cs = 76; goto _test_eof; - _test_eof77: cs = 77; goto _test_eof; - _test_eof78: cs = 78; goto _test_eof; - _test_eof79: cs = 79; goto _test_eof; - _test_eof80: cs = 80; goto _test_eof; - _test_eof81: cs = 81; goto _test_eof; - _test_eof82: cs = 82; goto _test_eof; - _test_eof83: cs = 83; goto _test_eof; - _test_eof84: cs = 84; goto _test_eof; - _test_eof85: cs = 85; goto _test_eof; - _test_eof86: cs = 86; goto _test_eof; - _test_eof87: cs = 87; goto _test_eof; - _test_eof88: cs = 88; goto _test_eof; - _test_eof89: cs = 89; goto _test_eof; - _test_eof90: cs = 90; goto _test_eof; - _test_eof91: cs = 91; goto _test_eof; - _test_eof92: cs = 92; goto _test_eof; - _test_eof93: cs = 93; goto _test_eof; - _test_eof94: cs = 94; goto _test_eof; - _test_eof95: cs = 95; goto _test_eof; - _test_eof96: cs = 96; goto _test_eof; - _test_eof97: cs = 97; goto _test_eof; - _test_eof98: cs = 98; goto _test_eof; - _test_eof99: cs = 99; goto _test_eof; - _test_eof100: cs = 100; goto _test_eof; - _test_eof101: cs = 101; goto _test_eof; - _test_eof102: cs = 102; goto _test_eof; - _test_eof103: cs = 103; goto _test_eof; - _test_eof104: cs = 104; goto _test_eof; - _test_eof105: cs = 105; goto _test_eof; - _test_eof106: cs = 106; goto _test_eof; - _test_eof107: cs = 107; goto _test_eof; - _test_eof108: cs = 108; goto _test_eof; - _test_eof109: cs = 109; goto _test_eof; - _test_eof110: cs = 110; goto _test_eof; - _test_eof111: cs = 111; goto _test_eof; - _test_eof112: cs = 112; goto _test_eof; - _test_eof113: cs = 113; goto _test_eof; - _test_eof114: cs = 114; goto _test_eof; - _test_eof115: cs = 115; goto _test_eof; - _test_eof116: cs = 116; goto _test_eof; - _test_eof117: cs = 117; goto _test_eof; - - _test_eof: {} - _out: {} - } -#line 197 "src/parser.rl" - - parser->cs = cs; - parser->nread += p - (buffer + off); - - assert(p <= pe && "buffer overflow after parsing execute"); - assert(parser->nread <= len && "nread longer than length"); - assert(parser->body_start <= len && "body starts after buffer end"); - assert(parser->mark < len && "mark is after buffer end"); - assert(parser->field_len <= len && "field has length longer than whole buffer"); - assert(parser->field_start < len && "field starts after buffer end"); - - if(parser->nread > 1024 * (80 + 32)) - parser->overflow_error = TRUE; - - - /* Ragel 6 does not use write eof; no need for this - if(parser->body_start) { - // final \r\n combo encountered so stop right here - parser->nread++; - %% write eof; - } - */ - - return(parser->nread); -} - -int http_parser_finish(http_parser *parser) -{ - if (http_parser_has_error(parser)) - return -1; - else if (http_parser_is_finished(parser)) - return 1; - else - return 0; -} - -int http_parser_has_error(http_parser *parser) { - return parser->cs == http_parser_error || parser->overflow_error; -} - -int http_parser_is_finished(http_parser *parser) { - return parser->cs >= http_parser_first_final; -} diff --git a/parser.h b/parser.h deleted file mode 100644 index d515281..0000000 --- a/parser.h +++ /dev/null @@ -1,53 +0,0 @@ -/** - * Copyright (c) 2005 Zed A. Shaw - * You can redistribute it and/or modify it under the same terms as Ruby. - */ - -#ifndef http11_parser_h -#define http11_parser_h - -#include - -#if defined(_WIN32) -#include -#endif - -enum { MONGREL_CONTENT_LENGTH - , MONGREL_CONTENT_TYPE - , MONGREL_FRAGMENT - , MONGREL_HTTP_VERSION - , MONGREL_QUERY_STRING - , MONGREL_REQUEST_PATH - , MONGREL_REQUEST_METHOD - , MONGREL_REQUEST_URI - }; - -typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen); -typedef void (*element_cb)(void *data, int type, const char *at, size_t length); - -typedef struct http_parser { - int cs; - int overflow_error; - size_t body_start; - size_t content_length; - size_t nread; - size_t mark; - size_t field_start; - size_t field_len; - size_t query_start; - - void *data; - - field_cb http_field; - element_cb on_element; -} http_parser; - -void http_parser_init(http_parser *parser); -int http_parser_finish(http_parser *parser); -size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off); -int http_parser_has_error(http_parser *parser); -int http_parser_is_finished(http_parser *parser); - -#define http_parser_nread(parser) (parser)->nread - -#endif -- 2.11.4.GIT