/**
* Copyright (c) 2009, 2010 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 1.8 * or the GPLv2 or later. */
include “ruby.h” include “ext_help.h” include <assert.h> include <stdlib.h> include <string.h> include <sys/types.h> include <limits.h> include “c_util.h”
static VALUE eParserError; static ID id_uminus, id_sq, id_sq_set; static VALUE g_rack_url_scheme,
g_80, g_443, g_http, g_https, g_HTTP_HOST, g_HTTP_CONNECTION, g_HTTP_TRAILER, g_HTTP_TRANSFER_ENCODING, g_HTTP_VERSION, g_CONTENT_LENGTH, g_CONTENT_TYPE, g_FRAGMENT, g_PATH_INFO, g_QUERY_STRING, g_REQUEST_METHOD, g_REQUEST_PATH, g_REQUEST_URI, g_SERVER_NAME, g_SERVER_PORT, g_SERVER_PROTOCOL;
static VALUE e413, e414;
/** Defines common length and error messages for input length validation. */ define DEF_MAX_LENGTH(N, length) \
static const size_t MAX_##N##_LENGTH = length; \ static const char MAX_##N##_LENGTH_ERR[] = \ "HTTP element " # N " is longer than the " # length " allowed length."
/**
* Validates the max length of given input and throws an ParserError * exception if over. */
define VALIDATE_MAX_LENGTH(len, N) do { \
if (len > MAX_##N##_LENGTH) \ rb_raise(eParserError, MAX_##N##_LENGTH_ERR); \
} while (0)
define VALIDATE_MAX_URI_LENGTH(len, N) do { \
if (len > MAX_##N##_LENGTH) \ rb_raise(e414, MAX_##N##_LENGTH_ERR); \
} while (0)
/* Defines the maximum allowed lengths for various input elements.*/ DEF_MAX_LENGTH(FIELD_NAME, 256); DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024); DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32))); DEF_MAX_LENGTH(REQUEST_URI, 1024 * 15); DEF_MAX_LENGTH(REQUEST_PATH, 4096); /* common PATH_MAX on modern systems */ DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
struct http_parser {
int cs; /* Ragel internal state */ unsigned int is_request:1; unsigned int has_query:1; unsigned int has_scheme:1; unsigned int chunked:1; unsigned int has_body:1; unsigned int in_body:1; unsigned int has_trailer:1; unsigned int in_trailer:1; unsigned int in_chunk:1; unsigned int persistent:1; unsigned int has_header:1; unsigned int body_eof_seen:1; unsigned int is_https:1; unsigned int padding:19; unsigned int mark; unsigned int offset; union { /* these 2 fields don't nest */ unsigned int field; unsigned int query; } start; union { unsigned int field_len; /* only used during header processing */ unsigned int dest_offset; /* only used during body processing */ } s; VALUE cont; /* Qfalse: unset, Qnil: ignored header, T_STRING: append */ union { /* String or Qnil */ VALUE status; /* status string for responses */ VALUE host; /* Host: header for requests */ } v; union { off_t content; off_t chunk; } len;
};
static unsigned int ulong2uint(unsigned long n) {
unsigned int i = (unsigned int)n; if (sizeof(unsigned int) != sizeof(unsigned long)) { if ((unsigned long)i != n) { rb_raise(rb_eRangeError, "too large to be 32-bit uint: %lu", n); } } return i;
}
define REMAINING (unsigned long)(pe - p) define LEN(AT, FPC) (ulong2uint(FPC - buffer) - hp->AT) define MARK(M,FPC) (hp->M = ulong2uint((FPC) - buffer)) define PTR_TO(F) (buffer + hp->F) define STR_NEW(M,FPC) rb_str_new(PTR_TO(M), LEN(M, FPC)) define STRIPPED_STR_NEW(M,FPC) stripped_str_new(PTR_TO(M), LEN(M, FPC))
/* Downcases a single ASCII character. Locale-agnostic. */ static void downcase_char(char *c) {
if (*c >= 'A' && *c <= 'Z') *c |= 0x20;
}
static int is_lws(char c) {
return (c == ' ' || c == '\t');
}
/* this will dedupe under Ruby 2.5+ (December 2017) */ static VALUE str_dd_freeze(VALUE str) {
if (STR_UMINUS_DEDUPE) return rb_funcall(str, id_uminus, 0); /* freeze,since it speeds up MRI slightly */ OBJ_FREEZE(str); return str;
}
static VALUE str_new_dd_freeze(const char *ptr, long len) {
return str_dd_freeze(rb_str_new(ptr, len));
}
static VALUE stripped_str_new(const char *str, long len) {
long end; for (end = len - 1; end >= 0 && is_lws(str[end]); end--); return rb_str_new(str, end + 1);
}
static VALUE request_host_val(struct http_parser *hp) {
assert(hp->is_request == 1 && "not a request"); return NIL_P(hp->v.host) ? Qfalse : hp->v.host;
}
static void set_server_vars(struct http_parser *hp, VALUE env, VALUE host) {
char *host_ptr = RSTRING_PTR(host); long host_len = RSTRING_LEN(host); char *colon; VALUE server_name = host; VALUE server_port = hp->has_scheme ? (hp->is_https ? g_443 : g_80) : Qfalse; if (*host_ptr == '[') { /* ipv6 address format */ char *rbracket = memchr(host_ptr + 1, ']', host_len - 1); if (rbracket) colon = (rbracket[1] == ':') ? rbracket + 1 : NULL; else colon = memchr(host_ptr + 1, ':', host_len - 1); } else { colon = memchr(host_ptr, ':', host_len); } if (colon) { long port_start = colon - host_ptr + 1; long port_len = host_len - port_start; server_name = rb_str_substr(host, 0, colon - host_ptr); server_name = str_dd_freeze(server_name); if (port_len > 0) { server_port = rb_str_substr(host, port_start, port_len); server_port = str_dd_freeze(server_port); } } rb_hash_aset(env, g_SERVER_NAME, server_name); if (server_port != Qfalse) rb_hash_aset(env, g_SERVER_PORT, server_port);
}
static void finalize_header(struct http_parser *hp, VALUE hdr) {
if (hp->has_trailer && !hp->chunked) rb_raise(eParserError, "trailer but not chunked"); if (hp->is_request) { if (hp->chunked) { if (hp->len.chunk >= 0) rb_raise(eParserError, "Content-Length set with chunked encoding"); else hp->len.chunk = 0; } else if (hp->len.content < 0) { hp->len.content = 0; } if (!hp->has_query) rb_hash_aset(hdr, g_QUERY_STRING, rb_str_new(NULL, 0)); if (hp->has_header) { VALUE host = request_host_val(hp); if (host != Qfalse) set_server_vars(hp, hdr, host); } }
}
/*
* handles values of the "Connection:" header, keepalive is implied * for HTTP/1.1 but needs to be explicitly enabled with HTTP/1.0 * Additionally, we require GET/HEAD requests to support keepalive. */
static void hp_keepalive_connection(struct http_parser *hp, VALUE val) {
/* REQUEST_METHOD is always set before any headers */ if (STR_CSTR_CASE_EQ(val, "keep-alive")) { /* basically have HTTP/1.0 masquerade as HTTP/1.1+ */ hp->persistent = 1; } else if (STR_CSTR_CASE_EQ(val, "close")) { /* * it doesn't matter what HTTP version or request method we have, * if a server says "Connection: close", we disable keepalive */ hp->persistent = 0; } else { /* * server could've sent anything, ignore it for now. Maybe * "hp->persistent = 0;" just in case? * Raising an exception might be too mean... */ }
}
static void request_method(VALUE env, const char *ptr, size_t len) {
rb_hash_aset(env, g_REQUEST_METHOD, str_new_dd_freeze(ptr, len));
}
static void url_scheme(struct http_parser *hp, VALUE env, const char *ptr, size_t len) {
VALUE val; hp->has_scheme = 1; /* Ragel machine downcases and enforces this as "http" or "https" */ if (len == 5) { hp->is_https = 1; assert(CONST_MEM_EQ("https", ptr, len) && "len == 5 but not 'https'"); val = g_https; } else { assert(CONST_MEM_EQ("http", ptr, len) && "len != 4 but not 'http'"); val = g_http; } rb_hash_aset(env, g_rack_url_scheme, val);
}
static void request_host(struct http_parser *hp, VALUE env, const char *ptr, size_t len) {
VALUE val = rb_str_new(ptr, len); rb_hash_aset(env, g_HTTP_HOST, val); hp->v.host = val;
}
static void set_fragment(VALUE env, const char *ptr, size_t len) {
VALUE val = rb_str_new(ptr, len); rb_hash_aset(env, g_FRAGMENT, val);
}
static void request_uri(VALUE env, const char *ptr, size_t len) {
VALUE val; VALIDATE_MAX_URI_LENGTH(len, REQUEST_URI); val = rb_str_new(ptr, len); rb_hash_aset(env, g_REQUEST_URI, val); /* * rack says PATH_INFO must start with "/" or be empty, * but "OPTIONS *" is a valid request */ if (CONST_MEM_EQ("*", ptr, len)) { val = rb_str_new(NULL, 0); rb_hash_aset(env, g_PATH_INFO, val); rb_hash_aset(env, g_REQUEST_PATH, val); }
}
static void query_string(struct http_parser *hp, VALUE env, const char *ptr, size_t len) {
VALIDATE_MAX_URI_LENGTH(len, QUERY_STRING); hp->has_query = 1; rb_hash_aset(env, g_QUERY_STRING, rb_str_new(ptr, len));
}
static void request_path(VALUE env, const char *ptr, size_t len) {
VALUE val; VALIDATE_MAX_URI_LENGTH(len, REQUEST_PATH); val = rb_str_new(ptr, len); rb_hash_aset(env, g_REQUEST_PATH, val); rb_hash_aset(env, g_PATH_INFO, val);
}
static void http_version(struct http_parser *hp, VALUE env, const char *ptr, size_t len) {
if (CONST_MEM_EQ("HTTP/1.1", ptr, len)) { /* HTTP/1.1 implies keepalive unless "Connection: close" is set */ hp->persistent = 1; } if (hp->is_request) { VALUE v = str_new_dd_freeze(ptr, len); hp->has_header = 1; rb_hash_aset(env, g_SERVER_PROTOCOL, v); rb_hash_aset(env, g_HTTP_VERSION, v); }
}
static void status_phrase(struct http_parser *hp, VALUE hdr, const char *ptr, size_t len) {
long nr; hp->v.status = str_new_dd_freeze(ptr, len); /* RSTRING_PTR is null terminated, ptr is not */ nr = strtol(RSTRING_PTR(hp->v.status), NULL, 10); if (nr < 100 || nr > 999) rb_raise(eParserError, "invalid status: %s", RSTRING_PTR(hp->v.status)); if ( !((nr >= 100 && nr <= 199) || nr == 204 || nr == 304) ) hp->has_body = 1;
}
static inline void invalid_if_trailer(struct http_parser *hp) {
if (hp->in_trailer) rb_raise(eParserError, "invalid Trailer");
}
static void write_cont_value(struct http_parser *hp,
char *buffer, const char *p)
{
char *vptr; long end; long len = LEN(mark, p); long cont_len; if (hp->cont == Qfalse) rb_raise(eParserError, "invalid continuation line"); if (NIL_P(hp->cont)) return; /* we're ignoring this header (probably Status:) */ assert(TYPE(hp->cont) == T_STRING && "continuation line is not a string"); assert(hp->mark > 0 && "impossible continuation line offset"); if (len == 0) return; cont_len = RSTRING_LEN(hp->cont); if (cont_len > 0) { --hp->mark; len = LEN(mark, p); } vptr = PTR_TO(mark); /* normalize tab to space */ if (cont_len > 0) { assert(is_lws(*vptr) && "invalid leading white space"); *vptr = ' '; } for (end = len - 1; end >= 0 && is_lws(vptr[end]); end--); rb_str_buf_cat(hp->cont, vptr, end + 1);
}
static void write_response_value(struct http_parser *hp, VALUE hdr,
const char *buffer, const char *p)
{
VALUE f, v; VALUE hclass; const char *fptr = PTR_TO(start.field); size_t flen = hp->s.field_len; const char *vptr; size_t vlen; hp->has_header = 1; /* Rack does not like Status headers, so we never send them */ if (CSTR_CASE_EQ(fptr, flen, "status")) { hp->cont = Qnil; return; } vptr = PTR_TO(mark); vlen = LEN(mark, p); VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE); VALIDATE_MAX_LENGTH(flen, FIELD_NAME); f = str_new_dd_freeze(fptr, (long)flen); v = stripped_str_new(vptr, (long)vlen); /* needs more tests for error-checking here */ /* * TODO: * some of these tests might be too strict for real-world HTTP servers, * report real-world examples as we find them: */ if (STR_CSTR_CASE_EQ(f, "connection")) { hp_keepalive_connection(hp, v); } else if (STR_CSTR_CASE_EQ(f, "content-length")) { if (!hp->has_body) rb_raise(eParserError, "Content-Length with no body expected"); if (hp->chunked) rb_raise(eParserError, "Content-Length when chunked Transfer-Encoding is set"); hp->len.content = parse_length(vptr, vlen); if (hp->len.content < 0) rb_raise(eParserError, "invalid Content-Length"); invalid_if_trailer(hp); } else if (STR_CSTR_CASE_EQ(f, "transfer-encoding")) { if (STR_CSTR_CASE_EQ(v, "chunked")) { if (!hp->has_body) rb_raise(eParserError, "chunked Transfer-Encoding with no body expected"); if (hp->len.content >= 0) rb_raise(eParserError, "chunked Transfer-Encoding when Content-Length is set"); hp->len.chunk = 0; hp->chunked = 1; } invalid_if_trailer(hp); } else if (STR_CSTR_CASE_EQ(f, "trailer")) { if (!hp->has_body) rb_raise(eParserError, "trailer with no body"); hp->has_trailer = 1; invalid_if_trailer(hp); } hclass = CLASS_OF(hdr); if (hclass == rb_cArray) { rb_ary_push(hdr, rb_ary_new3(2, f, v)); hp->cont = v; } else { /* hash-ish, try rb_hash_* first and fall back to slow rb_funcall */ VALUE e; /* try to read the existing value */ if (hclass == rb_cHash) e = rb_hash_aref(hdr, f); else e = rb_funcall(hdr, id_sq, 1, f); if (NIL_P(e)) { if (hclass == rb_cHash) rb_hash_aset(hdr, f, v); else rb_funcall(hdr, id_sq_set, 2, f, v); hp->cont = v; } else { /* * existing value, append to it, Rack 1.x uses newlines to represent * repeated cookies: * { 'Set-Cookie' => "a=b\nc=d" } * becomes: * "Set-Cookie: a=b\r\nSet-Cookie: c=d\r\n" */ rb_str_buf_cat(e, "\n", 1); hp->cont = rb_str_buf_append(e, v); } }
}
static VALUE req_field(const char *ptr, size_t len) {
size_t pfxlen = sizeof("HTTP_") - 1; VALUE str = rb_str_new(NULL, pfxlen + len); char *dst = RSTRING_PTR(str); memcpy(dst, "HTTP_", pfxlen); memcpy(dst + pfxlen, ptr, len); assert(*(dst + RSTRING_LEN(str)) == '\0' && "string didn't end with \\0"); /* paranoia */ return str;
}
static void snake_upcase(char *ptr, size_t len) {
char *c; for (c = ptr; len--; c++) { if (*c >= 'a' && *c <= 'z') *c &= ~0x20; else if (*c == '-') *c = '_'; }
}
static void write_request_value(struct http_parser *hp, VALUE env,
char *buffer, const char *p)
{
char *fptr = PTR_TO(start.field); size_t flen = hp->s.field_len; char *vptr = PTR_TO(mark); size_t vlen = LEN(mark, p); VALUE key, val; VALUE existing; VALIDATE_MAX_LENGTH(flen, FIELD_NAME); VALIDATE_MAX_LENGTH(LEN(mark, p), FIELD_VALUE); snake_upcase(fptr, flen); /* * ignore "Version" headers since they conflict with the HTTP_VERSION * rack env variable. */ if (CONST_MEM_EQ("VERSION", fptr, flen)) { hp->cont = Qnil; return; } val = vlen == 0 ? rb_str_new(0, 0) : stripped_str_new(vptr, vlen); if (CONST_MEM_EQ("CONNECTION", fptr, flen)) { key = g_HTTP_CONNECTION; hp_keepalive_connection(hp, val); } else if (CONST_MEM_EQ("CONTENT_LENGTH", fptr, flen)) { key = g_CONTENT_LENGTH; hp->len.content = parse_length(vptr, vlen); if (hp->len.content < 0) rb_raise(eParserError, "invalid Content-Length"); if (hp->len.content != 0) hp->has_body = 1; invalid_if_trailer(hp); } else if (CONST_MEM_EQ("CONTENT_TYPE", fptr, flen)) { key = g_CONTENT_TYPE; } else if (CONST_MEM_EQ("TRANSFER_ENCODING", fptr, flen)) { key = g_HTTP_TRANSFER_ENCODING; if (STR_CSTR_CASE_EQ(val, "chunked")) { hp->chunked = 1; hp->has_body = 1; } invalid_if_trailer(hp); } else if (CONST_MEM_EQ("TRAILER", fptr, flen)) { key = g_HTTP_TRAILER; hp->has_trailer = 1; invalid_if_trailer(hp); } else if (CONST_MEM_EQ("HOST", fptr, flen)) { key = g_HTTP_HOST; if (NIL_P(hp->v.host)) hp->v.host = val; } else { key = req_field(fptr, flen); if (!HASH_ASET_DEDUPE) key = str_dd_freeze(key); } existing = rb_hash_aref(env, key); if (NIL_P(existing)) { hp->cont = rb_hash_aset(env, key, val); /* * Ignore repeated Host headers and favor host set by absolute URIs. * absoluteURI Request-URI takes precedence over * the Host: header (ref: rfc 2616, section 5.2.1) */ } else if (key == g_HTTP_HOST) { hp->cont = Qnil; } else { rb_str_buf_cat(existing, ",", 1); hp->cont = rb_str_buf_append(existing, val); }
}
static void write_value(struct http_parser *hp, VALUE hdr,
char *buf, const char *p)
{
hp->is_request ? write_request_value(hp, hdr, buf, p) : write_response_value(hp, hdr, buf, p);
}
/** Machine **/
%%{
machine http_parser; action mark {MARK(mark, fpc); } action snake_upcase_field { snake_upcase_char(deconst(fpc)); } action downcase_char { downcase_char(deconst(fpc)); } action request_method { request_method(hdr, PTR_TO(mark), LEN(mark, fpc)); } action url_scheme { url_scheme(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); } action host { request_host(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); } action request_uri { request_uri(hdr, PTR_TO(mark), LEN(mark, fpc)); } action fragment { set_fragment(hdr, PTR_TO(mark), LEN(mark, fpc)); } action start_query { MARK(start.query, fpc); } action query_string { query_string(hp, hdr, PTR_TO(start.query), LEN(start.query, fpc)); } action request_path { request_path(hdr, PTR_TO(mark), LEN(mark, fpc)); } action start_field { MARK(start.field, fpc); } action write_field { hp->s.field_len = LEN(start.field, fpc); } action start_value { MARK(mark, fpc); } action write_value { write_value(hp, hdr, buffer, fpc); } action write_cont_value { write_cont_value(hp, buffer, fpc); } action http_version { http_version(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); } action status_phrase { status_phrase(hp, hdr, PTR_TO(mark), LEN(mark, fpc)); } action add_to_chunk_size { hp->len.chunk = step_incr(hp->len.chunk, fc, 16); if (hp->len.chunk < 0) rb_raise(eParserError, "invalid chunk size"); } action header_done { finalize_header(hp, hdr); cs = http_parser_first_final; if (hp->chunked) cs = http_parser_en_ChunkedBody; /* * go back to Ruby so we can call the Rack application, we'll reenter * the parser iff the body needs to be processed. */ goto post_exec; } action end_trailers { cs = http_parser_first_final; goto post_exec; } action end_chunked_body { hp->in_trailer = 1; cs = http_parser_en_Trailers; ++p; assert(p <= pe && "buffer overflow after chunked body"); goto post_exec; } action skip_chunk_data { skip_chunk_data_hack: { size_t nr = MIN((size_t)hp->len.chunk, REMAINING); memcpy(RSTRING_PTR(hdr) + hp->s.dest_offset, fpc, nr); hp->s.dest_offset += nr; hp->len.chunk -= nr; p += nr; assert(hp->len.chunk >= 0 && "negative chunk length"); if ((size_t)hp->len.chunk > REMAINING) { hp->in_chunk = 1; goto post_exec; } else { fhold; fgoto chunk_end; } }} include kcar_http_common "kcar_http_common.rl";
}%%
/** Data **/ %% write data;
static void http_parser_init(struct http_parser *hp) {
int cs = 0; memset(hp, 0, sizeof(struct http_parser)); hp->cont = Qfalse; /* zero on MRI, should be optimized away by above */ hp->v.status = Qnil; hp->len.content = -1; %% write init; hp->cs = cs;
}
/** exec **/ static void http_parser_execute(struct http_parser *hp,
VALUE hdr, char *buffer, size_t len)
{
const char *p, *pe; int cs = hp->cs; size_t off = hp->offset; if (cs == http_parser_first_final) return; assert(off <= len && "offset past end of buffer"); p = buffer+off; pe = buffer+len; assert((void *)(pe - p) == (void *)(len - off) && "pointers aren't same distance"); if (hp->in_chunk) { hp->in_chunk = 0; goto skip_chunk_data_hack; } %% write exec;
post_exec: /* “_out:” also goes here */
if (hp->cs != http_parser_error) hp->cs = cs; hp->offset = ulong2uint(p - buffer); assert(p <= pe && "buffer overflow after parsing execute"); assert(hp->offset <= len && "offset longer than length");
}
static void kcar_mark(void *ptr) {
struct http_parser *hp = ptr; rb_gc_mark(hp->cont); rb_gc_mark(hp->v.status);
}
static size_t kcar_memsize(const void *ptr) {
return sizeof(struct http_parser);
}
static const rb_data_type_t kcar_type = {
"kcar_parser", { kcar_mark, RUBY_TYPED_DEFAULT_FREE, kcar_memsize, /* reserved */ }, /* parent, data, [ flags ] */
};
static VALUE kcar_alloc(VALUE klass) {
struct http_parser *hp; return TypedData_Make_Struct(klass, struct http_parser, &kcar_type, hp);
}
static struct http_parser *data_get(VALUE self) {
struct http_parser *hp; TypedData_Get_Struct(self, struct http_parser, &kcar_type, hp); assert(hp && "failed to extract http_parser struct"); return hp;
}
/**
* call-seq: * Kcar::Parser.new => parser * * Creates a new parser. * * Document-method: reset * * call-seq: * parser.reset => parser * * Resets the parser so it can be reused by another client */
static VALUE initialize(VALUE self) {
http_parser_init(data_get(self)); return self;
}
static void advance_str(VALUE str, off_t nr) {
long len = RSTRING_LEN(str); if (len == 0) return; rb_str_modify(str); assert(nr <= len && "trying to advance past end of buffer"); len -= nr; if (len > 0) /* unlikely, len is usually 0 */ memmove(RSTRING_PTR(str), RSTRING_PTR(str) + nr, len); rb_str_set_len(str, len);
}
/**
* call-seq: * parser.body_bytes_left => nil or Integer * * Returns the number of bytes left to run through Parser#filter_body. * This will initially be the value of the "Content-Length" HTTP header * after header parsing is complete and will decrease in value as * Parser#filter_body is called for each chunk. This should return * zero for responses with no body. * * This will return nil on "Transfer-Encoding: chunked" responses as * well as HTTP/1.0 responses where Content-Length is not set */
static VALUE body_bytes_left(VALUE self) {
struct http_parser *hp = data_get(self); if (hp->chunked) return Qnil; if (hp->len.content >= 0) return OFFT2NUM(hp->len.content); return Qnil;
}
/**
* call-seq: * parser.body_bytes_left = Integer * * Sets the number of bytes left to download for HTTP responses * with "Content-Length". This raises RuntimeError for chunked * responses. */
static VALUE body_bytes_left_set(VALUE self, VALUE bytes) {
struct http_parser *hp = data_get(self); if (hp->chunked) rb_raise(rb_eRuntimeError, "body_bytes_left= is not for chunked bodies"); hp->len.content = NUM2OFFT(bytes); if (hp->len.content == 0) hp->body_eof_seen = 1; return bytes;
}
/**
* Document-method: chunked * call-seq: * parser.chunked? => true or false * * This is used to detect if a response uses chunked Transfer-Encoding or not. */
static VALUE chunked(VALUE self) {
struct http_parser *hp = data_get(self); return hp->chunked ? Qtrue : Qfalse;
}
static void check_buffer_size(long dlen) {
if ((uint64_t)dlen > UINT_MAX) rb_raise(rb_eRangeError, "headers too large to process (%ld bytes)", dlen);
}
static void parser_execute(struct http_parser *hp, VALUE hdr, VALUE buf) {
char *ptr; long len; Check_Type(buf, T_STRING); rb_str_modify(buf); ptr = RSTRING_PTR(buf); len = RSTRING_LEN(buf); check_buffer_size(len); http_parser_execute(hp, hdr, ptr, len); if (hp->cs == http_parser_error) rb_raise(eParserError, "Invalid HTTP format, parsing fails.");
}
/**
* Document-method: headers * call-seq: * parser.headers(hdr, data) => hdr or nil * * Takes a Hash and a String of data, parses the String of data filling * in the Hash returning the Hash if parsing is finished, nil otherwise * When returning the hdr Hash, it may modify data to point to where * body processing should begin. * * Raises ParserError if there are parsing errors. */
static VALUE headers(VALUE self, VALUE hdr, VALUE data) {
struct http_parser *hp = data_get(self); if (hp->is_request) rb_raise(rb_eRuntimeError, "parser is handling a request, not response"); parser_execute(hp, hdr, data); VALIDATE_MAX_LENGTH(hp->offset, HEADER); if (hp->cs == http_parser_first_final || hp->cs == http_parser_en_ChunkedBody) { advance_str(data, hp->offset + 1); hp->offset = 0; if (hp->in_trailer) return hdr; else return rb_ary_new3(2, hp->v.status, hdr); } return Qnil;
}
static VALUE request(VALUE self, VALUE env, VALUE buf) {
struct http_parser *hp = data_get(self); hp->is_request = 1; Check_Type(buf, T_STRING); parser_execute(hp, env, buf); if (hp->cs == http_parser_first_final || hp->cs == http_parser_en_ChunkedBody) { advance_str(buf, hp->offset + 1); hp->offset = 0; if (hp->in_trailer) hp->body_eof_seen = 1; return env; } return Qnil; /* incomplete */
}
static int chunked_eof(struct http_parser *hp) {
return ((hp->cs == http_parser_first_final) || hp->in_trailer);
}
/**
* call-seq: * parser.body_eof? => true or false * * Detects if we're done filtering the body or not. This can be used * to detect when to stop calling Parser#filter_body. */
static VALUE body_eof(VALUE self) {
struct http_parser *hp = data_get(self); if (!hp->has_header && hp->persistent) return Qtrue; if (hp->chunked) return chunked_eof(hp) ? Qtrue : Qfalse; if (!hp->has_body) return Qtrue; return hp->len.content == 0 ? Qtrue : Qfalse;
}
/**
* call-seq: * parser.keepalive? => true or false * * This should be used to detect if a request can really handle * keepalives and pipelining. Currently, the rules are: * * 1. MUST be HTTP/1.1 +or+ HTTP/1.0 with "Connection: keep-alive" * 2. MUST NOT have "Connection: close" set * 3. If there is a response body, either a) Content-Length is set * or b) chunked encoding is used */
static VALUE keepalive(VALUE self) {
struct http_parser *hp = data_get(self); if (hp->persistent) { if (hp->has_header && hp->has_body) { if (hp->chunked || (hp->len.content >= 0)) { if (!hp->is_request) return Qtrue; else return hp->body_eof_seen ? Qtrue : Qfalse; } /* unknown Content-Length and not chunked, we must assume close */ return Qfalse; } else { /* 100 Continue, 304 Not Modified, etc... */ return Qtrue; } } return Qfalse;
}
/**
* call-seq: * parser.filter_body(dst, src) => nil/dst * * Takes a String of +src+, will modify src if dechunking is done. * Returns +nil+ if there is more +src+ left to process. Returns * +dst+ if body processing is complete. When returning +dst+, * it may modify +src+ so the start of the string points to where * the body ended so that trailer processing can begin. * * Raises ParserError if there are dechunking errors. * Basically this is a glorified memcpy(3) that copies +src+ * into +dst+ while filtering it through the dechunker. */
static VALUE filter_body(VALUE self, VALUE dst, VALUE src) {
struct http_parser *hp = data_get(self); char *sptr; long slen; sptr = RSTRING_PTR(src); slen = RSTRING_LEN(src); check_buffer_size(slen); StringValue(dst); rb_str_modify(dst); OBJ_TAINT(dst); /* keep weirdo $SAFE users happy */ /* * for now, only support filter_body for identity requests, * not responses; it's rather inefficient to blindly memcpy * giant request bodies; on the other hand, it simplifies * server-side code. */ if (hp->is_request && !hp->chunked) { /* no need to enter the Ragel machine for unchunked transfers */ assert(hp->len.content >= 0 && "negative Content-Length"); if (hp->len.content > 0) { long nr = MIN(slen, hp->len.content); rb_str_resize(dst, nr); memcpy(RSTRING_PTR(dst), sptr, nr); hp->len.content -= nr; if (hp->len.content == 0) hp->body_eof_seen = 1; advance_str(src, nr); } return dst; } if (!hp->chunked) rb_raise(rb_eRuntimeError, "filter_body is only for chunked bodies"); rb_str_resize(dst, slen); /* we can never copy more than slen bytes */ if (!chunked_eof(hp)) { hp->s.dest_offset = 0; http_parser_execute(hp, dst, sptr, slen); if (hp->cs == http_parser_error) rb_raise(eParserError, "Invalid HTTP format, parsing fails."); assert(hp->s.dest_offset <= hp->offset && "destination buffer overflow"); advance_str(src, hp->offset); rb_str_set_len(dst, hp->s.dest_offset); if (RSTRING_LEN(dst) == 0 && chunked_eof(hp)) { assert(hp->len.chunk == 0 && "chunk at EOF but more to parse"); } else { dst = Qnil; } } hp->offset = 0; /* for trailer parsing */ return dst;
}
void Init_kcar_ext(void) {
VALUE mKcar = rb_define_module("Kcar"); VALUE cParser = rb_define_class_under(mKcar, "Parser", rb_cObject); /* * Document-class: Kcar::ParserError * * This is raised if there are parsing errors. */ eParserError = rb_define_class_under(mKcar, "ParserError", rb_eIOError); e413 = rb_define_class_under(mKcar, "RequestEntityTooLargeError", eParserError); e414 = rb_define_class_under(mKcar, "RequestURITooLongError", eParserError); rb_define_alloc_func(cParser, kcar_alloc); rb_define_method(cParser, "initialize", initialize, 0); rb_define_method(cParser, "reset", initialize, 0); rb_define_method(cParser, "request", request, 2); rb_define_method(cParser, "headers", headers, 2); rb_define_method(cParser, "trailers", headers, 2); rb_define_method(cParser, "filter_body", filter_body, 2); rb_define_method(cParser, "body_bytes_left", body_bytes_left, 0); rb_define_method(cParser, "body_bytes_left=", body_bytes_left_set, 1); rb_define_method(cParser, "body_eof?", body_eof, 0); rb_define_method(cParser, "keepalive?", keepalive, 0); rb_define_method(cParser, "chunked?", chunked, 0); /* * The maximum size a single chunk when using chunked transfer encoding. * This is only a theoretical maximum used to detect errors in clients, * it is highly unlikely to encounter clients that send more than * several kilobytes at once. */ rb_define_const(cParser, "CHUNK_MAX", OFFT2NUM(UH_OFF_T_MAX)); /* * The maximum size of the body as specified by Content-Length. * This is only a theoretical maximum, the actual limit is subject * to the limits of the file system used for +Dir.tmpdir+. */ rb_define_const(cParser, "LENGTH_MAX", OFFT2NUM(UH_OFF_T_MAX)); id_sq = rb_intern("[]"); id_sq_set = rb_intern("[]="); id_uminus = rb_intern("-@"); /* TODO: gperf to make a perfect hash of common strings */
define C(var, cstr) do { \
var = str_new_dd_freeze((cstr), sizeof(cstr) - 1); \ rb_gc_register_mark_object((var)); \
} while (0);
C(g_CONTENT_LENGTH, "CONTENT_LENGTH"); C(g_CONTENT_TYPE, "CONTENT_TYPE"); C(g_FRAGMENT, "FRAGMENT"); C(g_HTTP_HOST, "HTTP_HOST"); C(g_HTTP_CONNECTION, "HTTP_CONNECTION"); C(g_HTTP_TRAILER, "HTTP_TRAILER"); C(g_HTTP_TRANSFER_ENCODING, "HTTP_TRANSFER_ENCODING"); C(g_HTTP_VERSION, "HTTP_VERSION"); C(g_PATH_INFO, "PATH_INFO"); C(g_QUERY_STRING, "QUERY_STRING"); C(g_REQUEST_METHOD, "REQUEST_METHOD"); C(g_REQUEST_PATH, "REQUEST_PATH"); C(g_REQUEST_URI, "REQUEST_URI"); C(g_SERVER_NAME, "SERVER_NAME"); C(g_SERVER_PORT, "SERVER_PORT"); C(g_SERVER_PROTOCOL, "SERVER_PROTOCOL"); C(g_rack_url_scheme, "rack.url_scheme"); C(g_http, "http"); C(g_https, "https"); C(g_80, "80"); C(g_443, "443");
undef C }