stomp_parser 1.0.0-universal-java

data/ext/java/stomp_parser/JavaParserService.java

@@ -0,0 +1,23 @@
+package stomp_parser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+
+public class JavaParserService implements BasicLibraryService {
+  public boolean basicLoad(Ruby ruby) {
+    RubyModule mStomp = ruby.getClassFromPath("StompParser");
+    RubyClass cJavaParser = ruby.defineClassUnder("JavaParser", ruby.getObject(), JAVA_PARSER_ALLOCATOR, mStomp);
+    cJavaParser.defineAnnotatedMethods(JavaParser.class);
+    return true;
+  }
+
+  private static final ObjectAllocator JAVA_PARSER_ALLOCATOR = new ObjectAllocator() {
+    public IRubyObject allocate(Ruby ruby, RubyClass klass) {
+      return new JavaParser(ruby, klass);
+    }
+  };
+}

data/ext/stomp_parser/c_parser.c.rl

@@ -0,0 +1,225 @@
+#include <ruby.h>
+
+#if DEBUG_H
+#  define DEBUG(fmt, ...) do { fprintf(stderr, fmt "\n", ##__VA_ARGS__); } while(0)
+#else
+#  define DEBUG(...)
+#endif
+
+#define UNUSED(x) (void)(x)
+#define MARK_LEN (p - mark)
+#define MARK_STR_NEW() rb_str_new(mark, MARK_LEN)
+
+#define true 1
+#define false 0
+
+typedef struct {
+  VALUE error;
+  long max_frame_size;
+
+  VALUE chunk;
+  const char *p;
+  int cs;
+  const char *mark;
+  VALUE mark_key;
+  VALUE mark_frame;
+  long mark_frame_size;
+  long mark_content_length;
+} parser_state_t;
+
+VALUE mStompParser = Qnil;
+VALUE cFrame = Qnil;
+VALUE eFrameSizeExceeded = Qnil;
+ID g_new;
+ID g_write_command;
+ID g_write_header;
+ID g_write_body;
+ID g_content_length;
+ID g_build_parse_error;
+ID g_max_frame_size;
+
+%%{
+  machine frame;
+
+  action mark {
+    mark = p;
+  }
+
+  action mark_frame {
+    mark_frame = rb_funcall(cFrame, g_new, 2, Qnil, Qnil);
+    mark_frame_size = 0;
+  }
+
+  action write_command {
+    rb_funcall(mark_frame, g_write_command, 1, MARK_STR_NEW());
+    mark = NULL;
+  }
+
+  action mark_key {
+    mark_key = MARK_STR_NEW();
+    mark = NULL;
+  }
+
+  action write_header {
+    rb_funcall(mark_frame, g_write_header, 2, mark_key, MARK_STR_NEW());
+    mark_key = Qnil;
+    mark = NULL;
+  }
+
+  action finish_headers {
+    VALUE length = rb_funcall(mark_frame, g_content_length, 0);
+    if ( ! NIL_P(length)) {
+      mark_content_length = NUM2LONG(length);
+    } else {
+      mark_content_length = -1;
+    }
+  }
+
+  action write_body {
+    rb_funcall(mark_frame, g_write_body, 1, MARK_STR_NEW());
+    mark = NULL;
+  }
+
+  action consume_null {
+    ((mark_content_length != -1) && (MARK_LEN < mark_content_length))
+  }
+
+  action consume_octet {
+    ((mark_content_length == -1) || (MARK_LEN < mark_content_length))
+  }
+
+  action check_frame_size {
+    mark_frame_size += 1;
+    if (mark_frame_size > max_frame_size) {
+      rb_raise(eFrameSizeExceeded, "");
+    }
+  }
+
+  action finish_frame {
+    rb_yield(mark_frame);
+    mark_frame = Qnil;
+  }
+
+  include frame_common "parser_common.rl";
+
+  write data noprefix;
+}%%
+
+static void parser_free(parser_state_t *state) {
+  // TODO: free memory inside struct!
+  xfree(state);
+}
+
+static void parser_mark(parser_state_t *state) {
+  rb_gc_mark(state->error);
+  rb_gc_mark(state->mark_key);
+  rb_gc_mark(state->mark_frame);
+  rb_gc_mark(state->chunk);
+}
+
+static VALUE parser_alloc(VALUE klass) {
+  parser_state_t *state = ALLOC(parser_state_t);
+  return Data_Wrap_Struct(klass, parser_mark, parser_free, state);
+}
+
+static VALUE parser_initialize(int argc, VALUE *argv, VALUE self) {
+  parser_state_t *state;
+  Data_Get_Struct(self, parser_state_t, state);
+
+  VALUE max_frame_size;
+  rb_scan_args(argc, argv, "01", &max_frame_size);
+
+  if (max_frame_size == Qnil) {
+    max_frame_size = rb_funcall(mStompParser, g_max_frame_size, 0);
+  }
+
+  state->error = Qnil;
+  state->max_frame_size = FIX2LONG(max_frame_size);
+  state->chunk = Qnil;
+  state->cs = start;
+  state->mark = NULL;
+  state->mark_key = Qnil;
+  state->mark_frame = Qnil;
+  state->mark_frame_size = 0;
+  state->mark_content_length = 0;
+
+  return self;
+}
+
+static VALUE parser_parse(VALUE self, VALUE new_chunk) {
+  parser_state_t *state;
+  Data_Get_Struct(self, parser_state_t, state);
+
+  if (NIL_P(state->error)) {
+    VALUE chunk = Qnil;
+    const char *p = NULL;
+    const char *mark = NULL;
+
+    if ( ! NIL_P(state->chunk)) {
+      long offset = RSTRING_LEN(state->chunk);
+      long mark_offset = state->mark - RSTRING_PTR(state->chunk);
+
+      chunk = rb_str_append(state->chunk, new_chunk);
+      p = RSTRING_PTR(chunk) + offset;
+      mark = RSTRING_PTR(chunk) + mark_offset;
+    } else {
+      chunk = new_chunk;
+      p = RSTRING_PTR(chunk);
+    }
+
+    const char *pe = RSTRING_END(chunk);
+    long max_frame_size = state->max_frame_size;
+
+    int cs = state->cs;
+    VALUE mark_key = state->mark_key;
+    VALUE mark_frame = state->mark_frame;
+    long mark_frame_size = state->mark_frame_size;
+    long mark_content_length = state->mark_content_length;
+
+    %% write exec;
+
+    if (mark != NULL) {
+      state->chunk = chunk;
+    } else {
+      state->chunk = Qnil;
+    }
+
+    state->cs = cs;
+    state->mark = mark;
+    state->mark_key = mark_key;
+    state->mark_frame = mark_frame;
+    state->mark_frame_size = mark_frame_size;
+    state->mark_content_length = mark_content_length;
+
+    if (cs == error) {
+      long index = p - RSTRING_PTR(chunk);
+      state->error = rb_funcall(mStompParser, g_build_parse_error, 2, chunk, LONG2NUM(index));
+    }
+  }
+
+  if ( ! NIL_P(state->error)) {
+    rb_exc_raise(state->error);
+  }
+
+  return Qnil;
+}
+
+void Init_c_parser(void) {
+  mStompParser = rb_const_get(rb_cObject, rb_intern("StompParser"));
+  cFrame = rb_const_get(mStompParser, rb_intern("Frame"));
+  eFrameSizeExceeded = rb_const_get(mStompParser, rb_intern("FrameSizeExceeded"));
+
+  g_new = rb_intern("new");
+  g_write_command = rb_intern("write_command");
+  g_write_header = rb_intern("write_header");
+  g_write_body = rb_intern("write_body");
+  g_content_length = rb_intern("content_length");
+  g_build_parse_error = rb_intern("build_parse_error");
+  g_max_frame_size = rb_intern("max_frame_size");
+
+  VALUE cParser = rb_define_class_under(mStompParser, "CParser", rb_cObject);
+  rb_define_alloc_func(cParser, parser_alloc);
+
+  rb_define_method(cParser, "initialize", parser_initialize, -1);
+  rb_define_method(cParser, "parse", parser_parse, 1);
+}

data/ext/stomp_parser/extconf.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "mkmf"
+
+$CFLAGS << " -O3"
+
+should_build = true
+should_build &&= have_header "ruby.h"
+should_build &&= defined?(RUBY_ENGINE) && %w[ruby rbx].include?(RUBY_ENGINE)
+
+if should_build
+  create_makefile("stomp_parser/c_parser")
+else
+  dummy_makefile(".")
+end

data/lib/stomp_parser.rb

@@ -0,0 +1,46 @@
+require "stomp_parser/version"
+require "stomp_parser/error"
+require "stomp_parser/frame"
+require "stomp_parser/ruby_parser"
+
+case RUBY_ENGINE
+when "ruby", "rbx"
+  require "stomp_parser/c_parser"
+when "jruby"
+  require "stomp_parser/java_parser"
+end
+
+module StompParser
+  Parser = if defined?(CParser)
+    CParser
+  elsif defined?(JavaParser)
+    JavaParser
+  else
+    RubyParser
+  end
+
+  @max_frame_size = 1024 * 10 # 10KB
+
+  class << self
+    attr_accessor :max_frame_size
+
+    # Create a parse error from a string chunk and an index.
+    #
+    # @api private
+    # @param [String] chunk
+    # @param [Integer] index
+    # @return [ParseError]
+    def build_parse_error(chunk, index)
+      ctx = 7
+      min = [0, index - ctx].max
+      len = ctx + 1 + ctx
+      context = chunk.byteslice(min, len).force_encoding("BINARY")
+
+      idx = index - min
+      chr = context[idx]
+      context[idx] = " -->#{chr}<-- "
+
+      ParseError.new("unexpected #{chr} in chunk (#{context.inspect})")
+    end
+  end
+end

data/lib/stomp_parser/error.rb

@@ -0,0 +1,18 @@
+module StompParser
+  class Error < StandardError
+  end
+
+  # Errors raised by the Parser.
+  class ParseError < Error
+  end
+
+  # Raised when the Parser has reached the
+  # limit for how large a Frame may be.
+  #
+  # Protects against malicious clients trying to
+  # fill the available memory by sending very large
+  # frames, for example by sending an unlimited
+  # amount of headers.
+  class FrameSizeExceeded < ParseError
+  end
+end

data/lib/stomp_parser/frame.rb

@@ -0,0 +1,133 @@
+module StompParser
+  class Frame
+    HEADER_TRANSLATIONS = {
+      '\\r' => "\r",
+      '\\n' => "\n",
+      '\\c' => ":",
+      '\\\\' => '\\',
+    }.freeze
+    HEADER_TRANSLATIONS_KEYS = Regexp.union(HEADER_TRANSLATIONS.keys).freeze
+    HEADER_REVERSE_TRANSLATIONS = HEADER_TRANSLATIONS.invert
+    HEADER_REVERSE_TRANSLATIONS_KEYS = Regexp.union(HEADER_REVERSE_TRANSLATIONS.keys).freeze
+    EMPTY = "".force_encoding("UTF-8").freeze
+
+    # @return [String]
+    attr_reader :command
+
+    # @return [Hash<String, String>]
+    attr_reader :headers
+
+    # @return [String]
+    attr_reader :body
+
+    # Construct a frame from a command, optional headers, and a body.
+    #
+    # @param [String] command
+    # @param [Hash<String, String>] headers
+    # @param [String] body
+    def initialize(command, headers = {}, body)
+      @command = command || EMPTY
+      @headers = headers
+      @body = body || EMPTY
+    end
+
+    # Content length of this frame, according to headers.
+    #
+    # @raise [ArgumentError] if content-length is not a valid integer
+    # @return [Integer, nil]
+    def content_length
+      if headers.has_key?("content-length")
+        begin
+          Integer(headers["content-length"])
+        rescue ArgumentError
+          raise Error, "invalid content length #{headers["content-length"].inspect}"
+        end
+      end
+    end
+
+    def content_type
+      headers["content-type"]
+    end
+
+    # @raise [ArgumentError] if encoding does not exist
+    # @return [Encoding] body encoding, according to headers.
+    def content_encoding
+      if content_type
+        mime_type, charset = content_type.to_s.split(";")
+        mime_type = mime_type.to_s
+        charset = charset.to_s[/\Acharset=(.*)/, 1].to_s
+
+        if charset.empty? and mime_type.to_s.start_with?("text/")
+          Encoding::UTF_8
+        elsif charset.empty?
+          Encoding::BINARY
+        else
+          Encoding.find(charset)
+        end
+      else
+        Encoding::BINARY
+      end
+    end
+
+    # Change the command of this frame.
+    #
+    # @param [String] command
+    def write_command(command)
+      @command = command
+    end
+
+    # Write a single header to this frame.
+    #
+    # @param [String] key
+    # @param [String] value
+    def write_header(key, value)
+      # @see http://stomp.github.io/stomp-specification-1.2.html#Repeated_Header_Entries
+      key = translate_header(key)
+      @headers[key] = translate_header(value) unless @headers.has_key?(key)
+    end
+
+    # Write the body to this frame.
+    #
+    # @param [String] body
+    def write_body(body)
+      @body = body.force_encoding(content_encoding)
+    end
+
+    # @return [String] a string-representation of this frame.
+    def to_str
+      frame = "".force_encoding("UTF-8")
+      frame << command << "\n"
+
+      outgoing_headers = headers.dup
+      outgoing_headers["content-length"] = body.bytesize
+      outgoing_headers.each do |key, value|
+        frame << serialize_header(key) << ":" << serialize_header(value) << "\n"
+      end
+      frame << "\n"
+
+      frame << body << "\x00"
+      frame
+    end
+    alias_method :to_s, :to_str
+
+    def [](key)
+      @headers[key]
+    end
+
+    def destination
+      self["destination"]
+    end
+
+    private
+
+    # @see http://stomp.github.io/stomp-specification-1.2.html#Value_Encoding
+    def translate_header(value)
+      value.gsub(HEADER_TRANSLATIONS_KEYS, HEADER_TRANSLATIONS).force_encoding(Encoding::UTF_8) unless value.empty?
+    end
+
+    # inverse of #translate_header
+    def serialize_header(value)
+      value.to_s.gsub(HEADER_REVERSE_TRANSLATIONS_KEYS, HEADER_REVERSE_TRANSLATIONS)
+    end
+  end
+end