ruby/lib/ruby/gems/1.8/gems/thin-1.2.11-x86-mswin32/ext/thin_parser/parser.rl

   1 /**
   2  * Copyright (c) 2005 Zed A. Shaw
   3  * You can redistribute it and/or modify it under the same terms as Ruby.
   4  */
   5 #include "parser.h"
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include <stdlib.h>
   9 #include <ctype.h>
  10 #include <string.h>
  11
  12 #define LEN(AT, FPC) (FPC - buffer - parser->AT)
  13 #define MARK(M,FPC) (parser->M = (FPC) - buffer)
  14 #define PTR_TO(F) (buffer + parser->F)
  15
  16 /** Machine **/
  17
  18 %%{
  19
  20   machine http_parser;
  21
  22   action mark {MARK(mark, fpc); }
  23
  24
  25   action start_field { MARK(field_start, fpc); }
  26   action write_field {
  27     parser->field_len = LEN(field_start, fpc);
  28   }
  29
  30   action start_value { MARK(mark, fpc); }
  31   action write_value {
  32     if (parser->http_field != NULL) {
  33       parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
  34     }
  35   }
  36   action request_method {
  37     if (parser->request_method != NULL) {
  38       parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
  39     }
  40   }
  41   action request_uri {
  42     if (parser->request_uri != NULL) {
  43       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
  44     }
  45   }
  46   action fragment {
  47     if (parser->fragment != NULL) {
  48       parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
  49     }
  50   }
  51
  52   action start_query {MARK(query_start, fpc); }
  53   action query_string {
  54     if (parser->query_string != NULL) {
  55       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
  56     }
  57   }
  58
  59   action http_version {
  60     if (parser->http_version != NULL) {
  61       parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
  62     }
  63   }
  64
  65   action request_path {
  66     if (parser->request_path != NULL) {
  67       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
  68     }
  69   }
  70
  71   action done {
  72     parser->body_start = fpc - buffer + 1;
  73     if (parser->header_done != NULL) {
  74       parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
  75     }
  76     fbreak;
  77   }
  78
  79   include http_parser_common "common.rl";
  80
  81 }%%
  82
  83 /** Data **/
  84 %% write data;
  85
  86 int thin_http_parser_init(http_parser *parser)  {
  87   int cs = 0;
  88   %% write init;
  89   parser->cs = cs;
  90   parser->body_start = 0;
  91   parser->content_len = 0;
  92   parser->mark = 0;
  93   parser->nread = 0;
  94   parser->field_len = 0;
  95   parser->field_start = 0;
  96
  97   return(1);
  98 }
  99
 100
 101 /** exec **/
 102 size_t thin_http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
 103   const char *p, *pe;
 104   int cs = parser->cs;
 105
 106   assert(off <= len && "offset past end of buffer");
 107
 108   p = buffer+off;
 109   pe = buffer+len;
 110
 111   assert(*pe == '\0' && "pointer does not end on NUL");
 112   assert(pe - p == len - off && "pointers aren't same distance");
 113
 114
 115   %% write exec;
 116
 117   parser->cs = cs;
 118   parser->nread += p - (buffer + off);
 119
 120   assert(p <= pe && "buffer overflow after parsing execute");
 121   assert(parser->nread <= len && "nread longer than length");
 122   assert(parser->body_start <= len && "body starts after buffer end");
 123   assert(parser->mark < len && "mark is after buffer end");
 124   assert(parser->field_len <= len && "field has length longer than whole buffer");
 125   assert(parser->field_start < len && "field starts after buffer end");
 126
 127   if(parser->body_start) {
 128     /* final \r\n combo encountered so stop right here */
 129     parser->nread++;
 130   }
 131
 132   return(parser->nread);
 133 }
 134
 135 int thin_http_parser_finish(http_parser *parser)
 136 {
 137   int cs = parser->cs;
 138
 139
 140   parser->cs = cs;
 141
 142   if (thin_http_parser_has_error(parser) ) {
 143     return -1;
 144   } else if (thin_http_parser_is_finished(parser) ) {
 145     return 1;
 146   } else {
 147     return 0;
 148   }
 149 }
 150
 151 int thin_http_parser_has_error(http_parser *parser) {
 152   return parser->cs == http_parser_error;
 153 }
 154
 155 int thin_http_parser_is_finished(http_parser *parser) {
 156   return parser->cs == http_parser_first_final;
 157 }