diff options
Diffstat (limited to 'ext/unicorn/http11/http11.c')
-rw-r--r-- | ext/unicorn/http11/http11.c | 340 |
1 files changed, 132 insertions, 208 deletions
diff --git a/ext/unicorn/http11/http11.c b/ext/unicorn/http11/http11.c index d5c364a..cd7a8f7 100644 --- a/ext/unicorn/http11/http11.c +++ b/ext/unicorn/http11/http11.c @@ -1,4 +1,5 @@ /** + * Copyright (c) 2009 Eric Wong (all bugs are Eric's fault) * Copyright (c) 2005 Zed A. Shaw * You can redistribute it and/or modify it under the same terms as Ruby. */ @@ -8,6 +9,16 @@ #include <string.h> #include "http11_parser.h" +static http_parser *data_get(VALUE self) +{ + http_parser *http; + + Data_Get_Struct(self, http_parser, http); + if (!http) + rb_raise(rb_eArgError, "NULL found for http when shouldn't be."); + return http; +} + #ifndef RSTRING_PTR #define RSTRING_PTR(s) (RSTRING(s)->ptr) #endif @@ -18,40 +29,50 @@ static VALUE mUnicorn; static VALUE cHttpParser; static VALUE eHttpParserError; +static VALUE sym_http_body; #define HTTP_PREFIX "HTTP_" #define HTTP_PREFIX_LEN (sizeof(HTTP_PREFIX) - 1) +static VALUE global_rack_url_scheme; static VALUE global_request_method; static VALUE global_request_uri; static VALUE global_fragment; static VALUE global_query_string; static VALUE global_http_version; -static VALUE global_content_length; -static VALUE global_http_content_length; static VALUE global_request_path; -static VALUE global_content_type; -static VALUE global_http_content_type; -static VALUE global_http_body; -static VALUE global_gateway_interface; -static VALUE global_gateway_interface_value; +static VALUE global_path_info; static VALUE global_server_name; static VALUE global_server_port; static VALUE global_server_protocol; static VALUE global_server_protocol_value; static VALUE global_http_host; +static VALUE global_http_x_forwarded_proto; static VALUE global_port_80; +static VALUE global_port_443; static VALUE global_localhost; +static VALUE global_http; /** Defines common length and error messages for input length validation. */ -#define DEF_MAX_LENGTH(N,length) const size_t MAX_##N##_LENGTH = length; const char *MAX_##N##_LENGTH_ERR = "HTTP element " # N " is longer than the " # length " allowed length." +#define DEF_MAX_LENGTH(N, length) \ + static const size_t MAX_##N##_LENGTH = length; \ + static const char * const MAX_##N##_LENGTH_ERR = \ + "HTTP element " # N " is longer than the " # length " allowed length." -/** Validates the max length of given input and throws an HttpParserError exception if over. */ -#define VALIDATE_MAX_LENGTH(len, N) if(len > MAX_##N##_LENGTH) { rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR); } +/** + * Validates the max length of given input and throws an HttpParserError + * exception if over. + */ +#define VALIDATE_MAX_LENGTH(len, N) do { \ + if (len > MAX_##N##_LENGTH) \ + rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR); \ +} while (0) /** Defines global strings in the init method. */ -#define DEF_GLOBAL(N, val) global_##N = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&global_##N) - +#define DEF_GLOBAL(N, val) do { \ + global_##N = rb_obj_freeze(rb_str_new(val, sizeof(val) - 1)); \ + rb_global_variable(&global_##N); \ +} while (0) /* Defines the maximum allowed lengths for various input elements.*/ DEF_MAX_LENGTH(FIELD_NAME, 256); @@ -109,26 +130,13 @@ static struct common_field common_http_fields[] = { f("USER_AGENT"), f("VIA"), f("X_FORWARDED_FOR"), /* common for proxies */ + f("X_FORWARDED_PROTO"), /* common for proxies */ f("X_REAL_IP"), /* common for proxies */ f("WARNING") # undef f }; -/* - * qsort(3) and bsearch(3) improve average performance slightly, but may - * not be worth it for lack of portability to certain platforms... - */ -#if defined(HAVE_QSORT_BSEARCH) -/* sort by length, then by name if there's a tie */ -static int common_field_cmp(const void *a, const void *b) -{ - struct common_field *cfa = (struct common_field *)a; - struct common_field *cfb = (struct common_field *)b; - signed long diff = cfa->len - cfb->len; - return diff ? diff : memcmp(cfa->name, cfb->name, cfa->len); -} -#endif /* HAVE_QSORT_BSEARCH */ - +/* this function is not performance-critical */ static void init_common_fields(void) { int i; @@ -137,32 +145,21 @@ static void init_common_fields(void) memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN); for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) { - memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1); - cf->value = rb_obj_freeze(rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len)); + /* Rack doesn't like certain headers prefixed with "HTTP_" */ + if (!strcmp("CONTENT_LENGTH", cf->name) || + !strcmp("CONTENT_TYPE", cf->name)) { + cf->value = rb_str_new(cf->name, cf->len); + } else { + memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1); + cf->value = rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len); + } + cf->value = rb_obj_freeze(cf->value); rb_global_variable(&cf->value); } - -#if defined(HAVE_QSORT_BSEARCH) - qsort(common_http_fields, - ARRAY_SIZE(common_http_fields), - sizeof(struct common_field), - common_field_cmp); -#endif /* HAVE_QSORT_BSEARCH */ } static VALUE find_common_field_value(const char *field, size_t flen) { -#if defined(HAVE_QSORT_BSEARCH) - struct common_field key; - struct common_field *found; - key.name = field; - key.len = (signed long)flen; - found = (struct common_field *)bsearch(&key, common_http_fields, - ARRAY_SIZE(common_http_fields), - sizeof(struct common_field), - common_field_cmp); - return found ? found->value : Qnil; -#else /* !HAVE_QSORT_BSEARCH */ int i; struct common_field *cf = common_http_fields; for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) { @@ -170,21 +167,17 @@ static VALUE find_common_field_value(const char *field, size_t flen) return cf->value; } return Qnil; -#endif /* !HAVE_QSORT_BSEARCH */ } static void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen) { VALUE req = (VALUE)data; - VALUE v = Qnil; VALUE f = Qnil; VALIDATE_MAX_LENGTH(flen, FIELD_NAME); VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE); - v = rb_str_new(value, vlen); - f = find_common_field_value(field, flen); if (f == Qnil) { @@ -203,9 +196,11 @@ static void http_field(void *data, const char *field, memcpy(RSTRING_PTR(f) + HTTP_PREFIX_LEN, field, flen); assert(*(RSTRING_PTR(f) + RSTRING_LEN(f)) == '\0'); /* paranoia */ /* fprintf(stderr, "UNKNOWN HEADER <%s>\n", RSTRING_PTR(f)); */ + } else if (f == global_http_host && rb_hash_aref(req, f) != Qnil) { + return; } - rb_hash_aset(req, f, v); + rb_hash_aset(req, f, rb_str_new(value, vlen)); } static void request_method(void *data, const char *at, size_t length) @@ -217,6 +212,16 @@ static void request_method(void *data, const char *at, size_t length) rb_hash_aset(req, global_request_method, val); } +static void scheme(void *data, const char *at, size_t length) +{ + rb_hash_aset((VALUE)data, global_rack_url_scheme, rb_str_new(at, length)); +} + +static void host(void *data, const char *at, size_t length) +{ + rb_hash_aset((VALUE)data, global_http_host, rb_str_new(at, length)); +} + static void request_uri(void *data, const char *at, size_t length) { VALUE req = (VALUE)data; @@ -226,6 +231,13 @@ static void request_uri(void *data, const char *at, size_t length) val = rb_str_new(at, length); rb_hash_aset(req, global_request_uri, val); + + /* "OPTIONS * HTTP/1.1\r\n" is a valid request */ + if (length == 1 && *at == '*') { + val = rb_str_new(NULL, 0); + rb_hash_aset(req, global_request_path, val); + rb_hash_aset(req, global_path_info, val); + } } static void fragment(void *data, const char *at, size_t length) @@ -248,6 +260,10 @@ static void request_path(void *data, const char *at, size_t length) val = rb_str_new(at, length); rb_hash_aset(req, global_request_path, val); + + /* rack says PATH_INFO must start with "/" or be empty */ + if (!(length == 1 && *at == '*')) + rb_hash_aset(req, global_path_info, val); } static void query_string(void *data, const char *at, size_t length) @@ -268,46 +284,49 @@ static void http_version(void *data, const char *at, size_t length) rb_hash_aset(req, global_http_version, val); } -/** Finalizes the request header to have a bunch of stuff that's - needed. */ - +/** Finalizes the request header to have a bunch of stuff that's needed. */ static void header_done(void *data, const char *at, size_t length) { VALUE req = (VALUE)data; - VALUE temp = Qnil; - VALUE ctype = Qnil; - VALUE clen = Qnil; - char *colon = NULL; - - clen = rb_hash_aref(req, global_http_content_length); - if(clen != Qnil) { - rb_hash_aset(req, global_content_length, clen); + VALUE server_name = global_localhost; + VALUE server_port = global_port_80; + VALUE temp; + + /* rack requires QUERY_STRING */ + if (rb_hash_aref(req, global_query_string) == Qnil) + rb_hash_aset(req, global_query_string, rb_str_new(NULL, 0)); + + /* set rack.url_scheme to "https" or "http", no others are allowed by Rack */ + if ((temp = rb_hash_aref(req, global_rack_url_scheme)) == Qnil) { + if ((temp = rb_hash_aref(req, global_http_x_forwarded_proto)) != Qnil && + RSTRING_LEN(temp) == 5 && + !memcmp("https", RSTRING_PTR(temp), 5)) + server_port = global_port_443; + else + temp = global_http; + rb_hash_aset(req, global_rack_url_scheme, temp); + } else if (RSTRING_LEN(temp) == 5 && !memcmp("https", RSTRING_PTR(temp), 5)) { + server_port = global_port_443; } - ctype = rb_hash_aref(req, global_http_content_type); - if(ctype != Qnil) { - rb_hash_aset(req, global_content_type, ctype); - } + /* parse and set the SERVER_NAME and SERVER_PORT variables */ + if ((temp = rb_hash_aref(req, global_http_host)) != Qnil) { + char *colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp)); + if (colon) { + long port_start = colon - RSTRING_PTR(temp) + 1; - rb_hash_aset(req, global_gateway_interface, global_gateway_interface_value); - if((temp = rb_hash_aref(req, global_http_host)) != Qnil) { - colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp)); - if(colon != NULL) { - rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING_PTR(temp))); - rb_hash_aset(req, global_server_port, - rb_str_substr(temp, colon - RSTRING_PTR(temp)+1, - RSTRING_LEN(temp))); + server_name = rb_str_substr(temp, 0, colon - RSTRING_PTR(temp)); + if ((RSTRING_LEN(temp) - port_start) > 0) + server_port = rb_str_substr(temp, port_start, RSTRING_LEN(temp)); } else { - rb_hash_aset(req, global_server_name, temp); - rb_hash_aset(req, global_server_port, global_port_80); + server_name = temp; } - } else { - rb_hash_aset(req, global_server_name, global_localhost); - rb_hash_aset(req, global_server_port, global_port_80); } + rb_hash_aset(req, global_server_name, server_name); + rb_hash_aset(req, global_server_port, server_port); /* grab the initial body and stuff it into the hash */ - rb_hash_aset(req, global_http_body, rb_str_new(at, length)); + rb_hash_aset(req, sym_http_body, rb_str_new(at, length)); rb_hash_aset(req, global_server_protocol, global_server_protocol_value); } @@ -325,14 +344,6 @@ static VALUE HttpParser_alloc(VALUE klass) VALUE obj; http_parser *hp = ALLOC_N(http_parser, 1); TRACE(); - hp->http_field = http_field; - hp->request_method = request_method; - hp->request_uri = request_uri; - hp->fragment = fragment; - hp->request_path = request_path; - hp->query_string = query_string; - hp->http_version = http_version; - hp->header_done = header_done; http_parser_init(hp); obj = Data_Wrap_Struct(klass, NULL, HttpParser_free, hp); @@ -349,9 +360,7 @@ static VALUE HttpParser_alloc(VALUE klass) */ static VALUE HttpParser_init(VALUE self) { - http_parser *http = NULL; - DATA_GET(self, http_parser, http); - http_parser_init(http); + http_parser_init(data_get(self)); return self; } @@ -366,9 +375,7 @@ static VALUE HttpParser_init(VALUE self) */ static VALUE HttpParser_reset(VALUE self) { - http_parser *http = NULL; - DATA_GET(self, http_parser, http); - http_parser_init(http); + http_parser_init(data_get(self)); return Qnil; } @@ -376,140 +383,58 @@ static VALUE HttpParser_reset(VALUE self) /** * call-seq: - * parser.finish -> true/false - * - * Finishes a parser early which could put in a "good" or bad state. - * You should call reset after finish it or bad things will happen. - */ -static VALUE HttpParser_finish(VALUE self) -{ - http_parser *http = NULL; - DATA_GET(self, http_parser, http); - http_parser_finish(http); - - return http_parser_is_finished(http) ? Qtrue : Qfalse; -} - - -/** - * call-seq: - * parser.execute(req_hash, data, start) -> Integer + * parser.execute(req_hash, data) -> true/false * - * Takes a Hash and a String of data, parses the String of data filling in the Hash - * returning an Integer to indicate how much of the data has been read. No matter - * what the return value, you should call HttpParser#finished? and HttpParser#error? - * to figure out if it's done parsing or there was an error. + * Takes a Hash and a String of data, parses the String of data filling + * in the Hash returning a boolean to indicate whether or not parsing + * is finished. * - * This function now throws an exception when there is a parsing error. This makes - * the logic for working with the parser much easier. You can still test for an - * error, but now you need to wrap the parser with an exception handling block. - * - * The third argument allows for parsing a partial request and then continuing - * the parsing from that position. It needs all of the original data as well - * so you have to append to the data buffer as you read. - */ -static VALUE HttpParser_execute(VALUE self, VALUE req_hash, - VALUE data, VALUE start) -{ - http_parser *http = NULL; - int from = 0; - char *dptr = NULL; - long dlen = 0; - - DATA_GET(self, http_parser, http); - - from = FIX2INT(start); - dptr = RSTRING_PTR(data); - dlen = RSTRING_LEN(data); - - if(from >= dlen) { - rb_raise(eHttpParserError, "Requested start is after data buffer end."); - } else { - http->data = (void *)req_hash; - http_parser_execute(http, dptr, dlen, from); - - VALIDATE_MAX_LENGTH(http_parser_nread(http), HEADER); - - if(http_parser_has_error(http)) { - rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails."); - } else { - return INT2FIX(http_parser_nread(http)); - } - } -} - - - -/** - * call-seq: - * parser.error? -> true/false - * - * Tells you whether the parser is in an error state. + * This function now throws an exception when there is a parsing error. + * This makes the logic for working with the parser much easier. You + * will need to wrap the parser with an exception handling block. */ -static VALUE HttpParser_has_error(VALUE self) -{ - http_parser *http = NULL; - DATA_GET(self, http_parser, http); - - return http_parser_has_error(http) ? Qtrue : Qfalse; -} - -/** - * call-seq: - * parser.finished? -> true/false - * - * Tells you whether the parser is finished or not and in a good state. - */ -static VALUE HttpParser_is_finished(VALUE self) +static VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data) { - http_parser *http = NULL; - DATA_GET(self, http_parser, http); + http_parser *http = data_get(self); + char *dptr = RSTRING_PTR(data); + long dlen = RSTRING_LEN(data); - return http_parser_is_finished(http) ? Qtrue : Qfalse; -} + if (http->nread < dlen) { + http->data = (void *)req_hash; + http_parser_execute(http, dptr, dlen); + VALIDATE_MAX_LENGTH(http->nread, HEADER); -/** - * call-seq: - * parser.nread -> Integer - * - * Returns the amount of data processed so far during this processing cycle. It is - * set to 0 on initialize or reset calls and is incremented each time execute is called. - */ -static VALUE HttpParser_nread(VALUE self) -{ - http_parser *http = NULL; - DATA_GET(self, http_parser, http); + if (!http_parser_has_error(http)) + return http_parser_is_finished(http) ? Qtrue : Qfalse; - return INT2FIX(http->nread); + rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails."); + } + rb_raise(eHttpParserError, "Requested start is after data buffer end."); } -void Init_http11() +void Init_http11(void) { - mUnicorn = rb_define_module("Unicorn"); + DEF_GLOBAL(rack_url_scheme, "rack.url_scheme"); DEF_GLOBAL(request_method, "REQUEST_METHOD"); DEF_GLOBAL(request_uri, "REQUEST_URI"); DEF_GLOBAL(fragment, "FRAGMENT"); DEF_GLOBAL(query_string, "QUERY_STRING"); DEF_GLOBAL(http_version, "HTTP_VERSION"); DEF_GLOBAL(request_path, "REQUEST_PATH"); - DEF_GLOBAL(content_length, "CONTENT_LENGTH"); - DEF_GLOBAL(http_content_length, "HTTP_CONTENT_LENGTH"); - DEF_GLOBAL(http_body, "HTTP_BODY"); - DEF_GLOBAL(content_type, "CONTENT_TYPE"); - DEF_GLOBAL(http_content_type, "HTTP_CONTENT_TYPE"); - DEF_GLOBAL(gateway_interface, "GATEWAY_INTERFACE"); - DEF_GLOBAL(gateway_interface_value, "CGI/1.2"); + DEF_GLOBAL(path_info, "PATH_INFO"); DEF_GLOBAL(server_name, "SERVER_NAME"); DEF_GLOBAL(server_port, "SERVER_PORT"); DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL"); DEF_GLOBAL(server_protocol_value, "HTTP/1.1"); - DEF_GLOBAL(http_host, "HTTP_HOST"); + DEF_GLOBAL(http_x_forwarded_proto, "HTTP_X_FORWARDED_PROTO"); DEF_GLOBAL(port_80, "80"); + DEF_GLOBAL(port_443, "443"); DEF_GLOBAL(localhost, "localhost"); + DEF_GLOBAL(http, "http"); eHttpParserError = rb_define_class_under(mUnicorn, "HttpParserError", rb_eIOError); @@ -517,10 +442,9 @@ void Init_http11() rb_define_alloc_func(cHttpParser, HttpParser_alloc); rb_define_method(cHttpParser, "initialize", HttpParser_init,0); rb_define_method(cHttpParser, "reset", HttpParser_reset,0); - rb_define_method(cHttpParser, "finish", HttpParser_finish,0); - rb_define_method(cHttpParser, "execute", HttpParser_execute,3); - rb_define_method(cHttpParser, "error?", HttpParser_has_error,0); - rb_define_method(cHttpParser, "finished?", HttpParser_is_finished,0); - rb_define_method(cHttpParser, "nread", HttpParser_nread,0); + rb_define_method(cHttpParser, "execute", HttpParser_execute,2); + sym_http_body = ID2SYM(rb_intern("http_body")); init_common_fields(); + global_http_host = find_common_field_value("HOST", 4); + assert(global_http_host != Qnil); } |