http11_parser.java.rl - puma-3.10.0 Documentation

package org.jruby.puma;

import org.jruby.util.ByteList;

public class Http11Parser {

    Machine

%%{

    machine puma_parser;

    action mark {parser.mark = fpc; }

    action start_field { parser.field_start = fpc; }
    action snake_upcase_field {    FIXME stub    }
    action write_field {
      parser.field_len = fpc-parser.field_start;
    }

    action start_value { parser.mark = fpc; }
    action write_value {
      if(parser.http_field != null) {
        parser.http_field.call(parser.data, parser.field_start, parser.field_len, parser.mark, fpc-parser.mark);
      }
    }
    action request_method {
      if(parser.request_method != null)
        parser.request_method.call(parser.data, parser.mark, fpc-parser.mark);
    }
    action request_uri {
      if(parser.request_uri != null)
        parser.request_uri.call(parser.data, parser.mark, fpc-parser.mark);
    }
    action fragment {
      if(parser.fragment != null)
        parser.fragment.call(parser.data, parser.mark, fpc-parser.mark);
    }

    action start_query {parser.query_start = fpc; }
    action query_string {
      if(parser.query_string != null)
        parser.query_string.call(parser.data, parser.query_start, fpc-parser.query_start);
    }

    action http_version {
      if(parser.http_version != null)
        parser.http_version.call(parser.data, parser.mark, fpc-parser.mark);
    }

    action request_path {
      if(parser.request_path != null)
        parser.request_path.call(parser.data, parser.mark, fpc-parser.mark);
    }

    action done {
      parser.body_start = fpc + 1;
      if(parser.header_done != null)
        parser.header_done.call(parser.data, fpc + 1, pe - fpc - 1);
      fbreak;
    }

    include puma_parser_common "http11_parser_common.rl";

}%%

/** Data **/ %% write data;

     public static interface ElementCB {
       public void call(Object data, int at, int length);
     }

     public static interface FieldCB {
       public void call(Object data, int field, int flen, int value, int vlen);
     }

     public static class HttpParser {
        int cs;
        int body_start;
        int content_len;
        int nread;
        int mark;
        int field_start;
        int field_len;
        int query_start;

        Object data;
        ByteList buffer;

        public FieldCB http_field;
        public ElementCB request_method;
        public ElementCB request_uri;
        public ElementCB fragment;
        public ElementCB request_path;
        public ElementCB query_string;
        public ElementCB http_version;
        public ElementCB header_done;

        public void init() {
            cs = 0;

            %% write init;

            body_start = 0;
            content_len = 0;
            mark = 0;
            nread = 0;
            field_len = 0;
            field_start = 0;
        }
     }

     public final HttpParser parser = new HttpParser();

     public int execute(ByteList buffer, int off) {
       int p, pe;
       int cs = parser.cs;
       int len = buffer.length();
       assert off<=len : "offset past end of buffer";

       p = off;
       pe = len;
       // get a copy of the bytes, since it may not start at 0
       // FIXME: figure out how to just use the bytes in-place
       byte[] data = buffer.bytes();
       parser.buffer = buffer;

       %% write exec;

       parser.cs = cs;
       parser.nread += (p - off);

       assert p <= pe                  : "buffer overflow after parsing execute";
       assert parser.nread <= len      : "nread longer than length";
       assert parser.body_start <= len : "body starts after buffer end";
       assert parser.mark < len        : "mark is after buffer end";
       assert parser.field_len <= len  : "field has length longer than whole buffer";
       assert parser.field_start < len : "field starts after buffer end";

       return parser.nread;
     }

     public int finish() {
      if(has_error()) {
        return -1;
      } else if(is_finished()) {
        return 1;
      } else {
        return 0;
      }
    }

    public boolean has_error() {
      return parser.cs == puma_parser_error;
    }

    public boolean is_finished() {
      return parser.cs == puma_parser_first_final;
    }

}