mongrel/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     parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
  33   }
  34   action request_method {
  35     parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
  36   }
  37   action request_uri {
  38     parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
  39   }
  40   action fragment {
  41     parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
  42   }
  43
  44   action start_query {MARK(query_start, fpc); }
  45   action query_string {
  46     parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
  47   }
  48
  49   action http_version {
  50     parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
  51   }
  52
  53   action request_path {
  54     parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
  55   }
  56
  57   action done {
  58     parser->body_start = fpc - buffer + 1;
  59     parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
  60     fbreak;
  61   }
  62
  63   include http_parser_common "common.rl";
  64
  65 }%%
  66
  67 /** Data **/
  68 %% write data;
  69
  70 int http_parser_init(http_parser *parser)  {
  71   int cs = 0;
  72   %% write init;
  73   parser->cs = cs;
  74   parser->body_start = 0;
  75   parser->content_len = 0;
  76   parser->mark = 0;
  77   parser->nread = 0;
  78   parser->field_len = 0;
  79   parser->field_start = 0;
  80
  81   return(1);
  82 }
  83
  84
  85 /** exec **/
  86 size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
  87   const char *p, *pe;
  88   int cs = parser->cs;
  89
  90   assert(off <= len && "offset past end of buffer");
  91
  92   p = buffer+off;
  93   pe = buffer+len;
  94
  95   assert(*pe == '\0' && "pointer does not end on NUL");
  96   assert(pe - p == len - off && "pointers aren't same distance");
  97
  98
  99   %% write exec;
 100
 101   parser->cs = cs;
 102   parser->nread += p - (buffer + off);
 103
 104   assert(p <= pe && "buffer overflow after parsing execute");
 105   assert(parser->nread <= len && "nread longer than length");
 106   assert(parser->body_start <= len && "body starts after buffer end");
 107   assert(parser->mark < len && "mark is after buffer end");
 108   assert(parser->field_len <= len && "field has length longer than whole buffer");
 109   assert(parser->field_start < len && "field starts after buffer end");
 110
 111   if(parser->body_start) {
 112     /* final \r\n combo encountered so stop right here */
 113     %% write eof;
 114     parser->nread++;
 115   }
 116
 117   return(parser->nread);
 118 }
 119
 120 int http_parser_finish(http_parser *parser)
 121 {
 122   int cs = parser->cs;
 123
 124   %%write eof;
 125
 126   parser->cs = cs;
 127
 128   if (http_parser_has_error(parser) ) {
 129     return -1;
 130   } else if (http_parser_is_finished(parser) ) {
 131     return 1;
 132   } else {
 133     return 0;
 134   }
 135 }
 136
 137 int http_parser_has_error(http_parser *parser) {
 138   return parser->cs == http_parser_error;
 139 }
 140
 141 int http_parser_is_finished(http_parser *parser) {
 142   return parser->cs == http_parser_first_final;
 143 }