ext/unicorn_http/unicorn_http.c

   1 /**
   2  * Copyright (c) 2009 Eric Wong (all bugs are Eric's fault)
   3  * Copyright (c) 2005 Zed A. Shaw
   4  * You can redistribute it and/or modify it under the same terms as Ruby.
   5  */
   6 #include <assert.h>
   7 #include <string.h>
   8 #include "unicorn_http.h"
   9
  10 static struct http_parser *data_get(VALUE self)
  11 {
  12   struct http_parser *http;
  13
  14   Data_Get_Struct(self, struct http_parser, http);
  15   assert(http);
  16   return http;
  17 }
  18
  19 static VALUE mUnicorn;
  20 static VALUE cHttpParser;
  21 static VALUE eHttpParserError;
  22 static VALUE sym_http_body;
  23
  24 #define HTTP_PREFIX "HTTP_"
  25 #define HTTP_PREFIX_LEN (sizeof(HTTP_PREFIX) - 1)
  26
  27 static VALUE g_rack_url_scheme;
  28 static VALUE g_request_method;
  29 static VALUE g_request_uri;
  30 static VALUE g_fragment;
  31 static VALUE g_query_string;
  32 static VALUE g_http_version;
  33 static VALUE g_request_path;
  34 static VALUE g_path_info;
  35 static VALUE g_server_name;
  36 static VALUE g_server_port;
  37 static VALUE g_server_protocol;
  38 static VALUE g_server_protocol_value;
  39 static VALUE g_http_host;
  40 static VALUE g_http_x_forwarded_proto;
  41 static VALUE g_port_80;
  42 static VALUE g_port_443;
  43 static VALUE g_localhost;
  44 static VALUE g_http;
  45
  46 /** Defines common length and error messages for input length validation. */
  47 #define DEF_MAX_LENGTH(N, length) \
  48   static const size_t MAX_##N##_LENGTH = length; \
  49   static const char * const MAX_##N##_LENGTH_ERR = \
  50     "HTTP element " # N  " is longer than the " # length " allowed length."
  51
  52 /**
  53  * Validates the max length of given input and throws an HttpParserError
  54  * exception if over.
  55  */
  56 #define VALIDATE_MAX_LENGTH(len, N) do { \
  57   if (len > MAX_##N##_LENGTH) \
  58     rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR); \
  59 } while (0)
  60
  61 /** Defines global strings in the init method. */
  62 #define DEF_GLOBAL(N, val) do { \
  63   g_##N = rb_obj_freeze(rb_str_new(val, sizeof(val) - 1)); \
  64   rb_global_variable(&g_##N); \
  65 } while (0)
  66
  67 /* Defines the maximum allowed lengths for various input elements.*/
  68 DEF_MAX_LENGTH(FIELD_NAME, 256);
  69 DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
  70 DEF_MAX_LENGTH(REQUEST_URI, 1024 * 12);
  71 DEF_MAX_LENGTH(FRAGMENT, 1024); /* Don't know if this length is specified somewhere or not */
  72 DEF_MAX_LENGTH(REQUEST_PATH, 1024);
  73 DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
  74 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
  75
  76 struct common_field {
  77         const signed long len;
  78         const char *name;
  79         VALUE value;
  80 };
  81
  82 /*
  83  * A list of common HTTP headers we expect to receive.
  84  * This allows us to avoid repeatedly creating identical string
  85  * objects to be used with rb_hash_aset().
  86  */
  87 static struct common_field common_http_fields[] = {
  88 # define f(N) { (sizeof(N) - 1), N, Qnil }
  89         f("ACCEPT"),
  90         f("ACCEPT_CHARSET"),
  91         f("ACCEPT_ENCODING"),
  92         f("ACCEPT_LANGUAGE"),
  93         f("ALLOW"),
  94         f("AUTHORIZATION"),
  95         f("CACHE_CONTROL"),
  96         f("CONNECTION"),
  97         f("CONTENT_ENCODING"),
  98         f("CONTENT_LENGTH"),
  99         f("CONTENT_TYPE"),
 100         f("COOKIE"),
 101         f("DATE"),
 102         f("EXPECT"),
 103         f("FROM"),
 104         f("HOST"),
 105         f("IF_MATCH"),
 106         f("IF_MODIFIED_SINCE"),
 107         f("IF_NONE_MATCH"),
 108         f("IF_RANGE"),
 109         f("IF_UNMODIFIED_SINCE"),
 110         f("KEEP_ALIVE"), /* Firefox sends this */
 111         f("MAX_FORWARDS"),
 112         f("PRAGMA"),
 113         f("PROXY_AUTHORIZATION"),
 114         f("RANGE"),
 115         f("REFERER"),
 116         f("TE"),
 117         f("TRAILER"),
 118         f("TRANSFER_ENCODING"),
 119         f("UPGRADE"),
 120         f("USER_AGENT"),
 121         f("VIA"),
 122         f("X_FORWARDED_FOR"), /* common for proxies */
 123         f("X_FORWARDED_PROTO"), /* common for proxies */
 124         f("X_REAL_IP"), /* common for proxies */
 125         f("WARNING")
 126 # undef f
 127 };
 128
 129 /* this function is not performance-critical */
 130 static void init_common_fields(void)
 131 {
 132   int i;
 133   struct common_field *cf = common_http_fields;
 134   char tmp[256]; /* MAX_FIELD_NAME_LENGTH */
 135   memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN);
 136
 137   for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
 138     /* Rack doesn't like certain headers prefixed with "HTTP_" */
 139     if (!strcmp("CONTENT_LENGTH", cf->name) ||
 140         !strcmp("CONTENT_TYPE", cf->name)) {
 141       cf->value = rb_str_new(cf->name, cf->len);
 142     } else {
 143       memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1);
 144       cf->value = rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len);
 145     }
 146     cf->value = rb_obj_freeze(cf->value);
 147     rb_global_variable(&cf->value);
 148   }
 149 }
 150
 151 static VALUE find_common_field_value(const char *field, size_t flen)
 152 {
 153   int i;
 154   struct common_field *cf = common_http_fields;
 155   for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) {
 156     if (cf->len == flen && !memcmp(cf->name, field, flen))
 157       return cf->value;
 158   }
 159   return Qnil;
 160 }
 161
 162 static void http_field(VALUE req, const char *field,
 163                        size_t flen, const char *value, size_t vlen)
 164 {
 165   VALUE f = Qnil;
 166
 167   VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
 168   VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
 169
 170   f = find_common_field_value(field, flen);
 171
 172   if (f == Qnil) {
 173     /*
 174      * We got a strange header that we don't have a memoized value for.
 175      * Fallback to creating a new string to use as a hash key.
 176      *
 177      * using rb_str_new(NULL, len) here is faster than rb_str_buf_new(len)
 178      * in my testing, because: there's no minimum allocation length (and
 179      * no check for it, either), RSTRING_LEN(f) does not need to be
 180      * written twice, and and RSTRING_PTR(f) will already be
 181      * null-terminated for us.
 182      */
 183     f = rb_str_new(NULL, HTTP_PREFIX_LEN + flen);
 184     memcpy(RSTRING_PTR(f), HTTP_PREFIX, HTTP_PREFIX_LEN);
 185     memcpy(RSTRING_PTR(f) + HTTP_PREFIX_LEN, field, flen);
 186     assert(*(RSTRING_PTR(f) + RSTRING_LEN(f)) == '\0'); /* paranoia */
 187     /* fprintf(stderr, "UNKNOWN HEADER <%s>\n", RSTRING_PTR(f)); */
 188   } else if (f == g_http_host && rb_hash_aref(req, f) != Qnil) {
 189     return;
 190   }
 191
 192   rb_hash_aset(req, f, rb_str_new(value, vlen));
 193 }
 194
 195 static void request_method(VALUE req, const char *at, size_t length)
 196 {
 197   rb_hash_aset(req, g_request_method, rb_str_new(at, length));
 198 }
 199
 200 static void scheme(VALUE req, const char *at, size_t length)
 201 {
 202   rb_hash_aset(req, g_rack_url_scheme, rb_str_new(at, length));
 203 }
 204
 205 static void host(VALUE req, const char *at, size_t length)
 206 {
 207   rb_hash_aset(req, g_http_host, rb_str_new(at, length));
 208 }
 209
 210 static void request_uri(VALUE req, const char *at, size_t length)
 211 {
 212   VALIDATE_MAX_LENGTH(length, REQUEST_URI);
 213
 214   rb_hash_aset(req, g_request_uri, rb_str_new(at, length));
 215
 216   /* "OPTIONS * HTTP/1.1\r\n" is a valid request */
 217   if (length == 1 && *at == '*') {
 218     VALUE val = rb_str_new(NULL, 0);
 219     rb_hash_aset(req, g_request_path, val);
 220     rb_hash_aset(req, g_path_info, val);
 221   }
 222 }
 223
 224 static void fragment(VALUE req, const char *at, size_t length)
 225 {
 226   VALIDATE_MAX_LENGTH(length, FRAGMENT);
 227
 228   rb_hash_aset(req, g_fragment, rb_str_new(at, length));
 229 }
 230
 231 static void request_path(VALUE req, const char *at, size_t length)
 232 {
 233   VALUE val = Qnil;
 234
 235   VALIDATE_MAX_LENGTH(length, REQUEST_PATH);
 236
 237   val = rb_str_new(at, length);
 238   rb_hash_aset(req, g_request_path, val);
 239
 240   /* rack says PATH_INFO must start with "/" or be empty */
 241   if (!(length == 1 && *at == '*'))
 242     rb_hash_aset(req, g_path_info, val);
 243 }
 244
 245 static void query_string(VALUE req, const char *at, size_t length)
 246 {
 247   VALIDATE_MAX_LENGTH(length, QUERY_STRING);
 248
 249   rb_hash_aset(req, g_query_string, rb_str_new(at, length));
 250 }
 251
 252 static void http_version(VALUE req, const char *at, size_t length)
 253 {
 254   rb_hash_aset(req, g_http_version, rb_str_new(at, length));
 255 }
 256
 257 /** Finalizes the request header to have a bunch of stuff that's needed. */
 258 static void header_done(VALUE req, const char *at, size_t length)
 259 {
 260   VALUE server_name = g_localhost;
 261   VALUE server_port = g_port_80;
 262   VALUE temp;
 263
 264   /* rack requires QUERY_STRING */
 265   if (rb_hash_aref(req, g_query_string) == Qnil)
 266     rb_hash_aset(req, g_query_string, rb_str_new(NULL, 0));
 267
 268   /* set rack.url_scheme to "https" or "http", no others are allowed by Rack */
 269   if ((temp = rb_hash_aref(req, g_rack_url_scheme)) == Qnil) {
 270     if ((temp = rb_hash_aref(req, g_http_x_forwarded_proto)) != Qnil &&
 271         RSTRING_LEN(temp) == 5 &&
 272         !memcmp("https", RSTRING_PTR(temp), 5))
 273       server_port = g_port_443;
 274     else
 275       temp = g_http;
 276     rb_hash_aset(req, g_rack_url_scheme, temp);
 277   } else if (RSTRING_LEN(temp) == 5 && !memcmp("https", RSTRING_PTR(temp), 5)) {
 278     server_port = g_port_443;
 279   }
 280
 281   /* parse and set the SERVER_NAME and SERVER_PORT variables */
 282   if ((temp = rb_hash_aref(req, g_http_host)) != Qnil) {
 283     char *colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp));
 284     if (colon) {
 285       long port_start = colon - RSTRING_PTR(temp) + 1;
 286
 287       server_name = rb_str_substr(temp, 0, colon - RSTRING_PTR(temp));
 288       if ((RSTRING_LEN(temp) - port_start) > 0)
 289         server_port = rb_str_substr(temp, port_start, RSTRING_LEN(temp));
 290     } else {
 291       server_name = temp;
 292     }
 293   }
 294   rb_hash_aset(req, g_server_name, server_name);
 295   rb_hash_aset(req, g_server_port, server_port);
 296   rb_hash_aset(req, g_server_protocol, g_server_protocol_value);
 297
 298   /* grab the initial body and stuff it into the hash */
 299   temp = rb_hash_aref(req, g_request_method);
 300   if (temp != Qnil) {
 301     long len = RSTRING_LEN(temp);
 302     char *ptr = RSTRING_PTR(temp);
 303
 304     if (memcmp(ptr, "HEAD", len) && memcmp(ptr, "GET", len))
 305       rb_hash_aset(req, sym_http_body, rb_str_new(at, length));
 306   }
 307 }
 308
 309 static VALUE HttpParser_alloc(VALUE klass)
 310 {
 311   struct http_parser *http;
 312   return Data_Make_Struct(klass, struct http_parser, NULL, NULL, http);
 313 }
 314
 315
 316 /**
 317  * call-seq:
 318  *    parser.new -> parser
 319  *
 320  * Creates a new parser.
 321  */
 322 static VALUE HttpParser_init(VALUE self)
 323 {
 324   http_parser_init(data_get(self));
 325
 326   return self;
 327 }
 328
 329
 330 /**
 331  * call-seq:
 332  *    parser.reset -> nil
 333  *
 334  * Resets the parser to it's initial state so that you can reuse it
 335  * rather than making new ones.
 336  */
 337 static VALUE HttpParser_reset(VALUE self)
 338 {
 339   http_parser_init(data_get(self));
 340
 341   return Qnil;
 342 }
 343
 344
 345 /**
 346  * call-seq:
 347  *    parser.execute(req, data) -> true/false
 348  *
 349  * Takes a Hash and a String of data, parses the String of data filling
 350  * in the Hash returning a boolean to indicate whether or not parsing
 351  * is finished.
 352  *
 353  * This function now throws an exception when there is a parsing error.
 354  * This makes the logic for working with the parser much easier.  You
 355  * will need to wrap the parser with an exception handling block.
 356  */
 357
 358 static VALUE HttpParser_execute(VALUE self, VALUE req, VALUE data)
 359 {
 360   struct http_parser *http = data_get(self);
 361   char *dptr = RSTRING_PTR(data);
 362   long dlen = RSTRING_LEN(data);
 363
 364   if (http->start.offset < dlen) {
 365     http_parser_execute(http, req, dptr, dlen);
 366
 367     VALIDATE_MAX_LENGTH(http->start.offset, HEADER);
 368
 369     if (!http_parser_has_error(http))
 370       return http_parser_is_finished(http) ? Qtrue : Qfalse;
 371
 372     rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 373   }
 374   rb_raise(eHttpParserError, "Requested start is after data buffer end.");
 375 }
 376
 377 void Init_unicorn_http(void)
 378 {
 379   mUnicorn = rb_define_module("Unicorn");
 380
 381   DEF_GLOBAL(rack_url_scheme, "rack.url_scheme");
 382   DEF_GLOBAL(request_method, "REQUEST_METHOD");
 383   DEF_GLOBAL(request_uri, "REQUEST_URI");
 384   DEF_GLOBAL(fragment, "FRAGMENT");
 385   DEF_GLOBAL(query_string, "QUERY_STRING");
 386   DEF_GLOBAL(http_version, "HTTP_VERSION");
 387   DEF_GLOBAL(request_path, "REQUEST_PATH");
 388   DEF_GLOBAL(path_info, "PATH_INFO");
 389   DEF_GLOBAL(server_name, "SERVER_NAME");
 390   DEF_GLOBAL(server_port, "SERVER_PORT");
 391   DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
 392   DEF_GLOBAL(server_protocol_value, "HTTP/1.1");
 393   DEF_GLOBAL(http_x_forwarded_proto, "HTTP_X_FORWARDED_PROTO");
 394   DEF_GLOBAL(port_80, "80");
 395   DEF_GLOBAL(port_443, "443");
 396   DEF_GLOBAL(localhost, "localhost");
 397   DEF_GLOBAL(http, "http");
 398
 399   eHttpParserError = rb_define_class_under(mUnicorn, "HttpParserError", rb_eIOError);
 400
 401   cHttpParser = rb_define_class_under(mUnicorn, "HttpParser", rb_cObject);
 402   rb_define_alloc_func(cHttpParser, HttpParser_alloc);
 403   rb_define_method(cHttpParser, "initialize", HttpParser_init,0);
 404   rb_define_method(cHttpParser, "reset", HttpParser_reset,0);
 405   rb_define_method(cHttpParser, "execute", HttpParser_execute,2);
 406   sym_http_body = ID2SYM(rb_intern("http_body"));
 407   init_common_fields();
 408   g_http_host = find_common_field_value("HOST", 4);
 409   assert(g_http_host != Qnil);
 410 }