multipart_parser 0.0.1

data/ext/multipart_parser/multipart_parser_c.c

@@ -0,0 +1,302 @@
+/* Based on node-formidable by Felix Geisendörfer 
+ * Igor Afonov - afonov@gmail.com - 2012
+ * MIT License - http://www.opensource.org/licenses/mit-license.php
+ * Modified Benjamin Bryant - https://github.com/bhbryant/multipart_parser - 2015
+ */
+
+#include "multipart_parser_c.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+static void multipart_log(const char * format, ...)
+{
+#ifdef DEBUG_MULTIPART
+    va_list args;
+    va_start(args, format);
+
+    fprintf(stderr, "[HTTP_MULTIPART_PARSER] %s:%d: ", __FILE__, __LINE__);
+    vfprintf(stderr, format, args);
+    fprintf(stderr, "\n");
+#endif
+}
+
+#define NOTIFY_CB(FOR)                                                 \
+do {                                                                   \
+  if (settings->on_##FOR) {                                         \
+    if (settings->on_##FOR(p) != 0) {                               \
+      return i;                                                        \
+    }                                                                  \
+  }                                                                    \
+} while (0)
+
+#define EMIT_DATA_CB(FOR, ptr, len)                                    \
+do {                                                                   \
+  if (settings->on_##FOR) {                                         \
+    if (settings->on_##FOR(p, ptr, len) != 0) {                     \
+      return i;                                                        \
+    }                                                                  \
+  }                                                                    \
+} while (0)
+
+
+#define LF 10
+#define CR 13
+
+
+
+enum state {
+  s_uninitialized = 1,
+  s_start,
+  s_start_boundary,
+  s_header_field_start,
+  s_header_field,
+  s_headers_almost_done,
+  s_header_value_start,
+  s_header_value,
+  s_header_value_almost_done,
+  s_part_data_start,
+  s_part_data,
+  s_part_data_almost_boundary,
+  s_part_data_boundary,
+  s_part_data_almost_end,
+  s_part_complete,
+  s_part_data_final_hyphen,
+  s_end
+};
+
+multipart_parser_c* multipart_parser_c_init
+    (const char *boundary, size_t boundary_length) {
+
+
+  multipart_parser_c* p = malloc(sizeof(multipart_parser_c) +
+                                  (2 * sizeof(char)) + boundary_length +
+                                  (2 * sizeof(char)) + boundary_length + 9 );  
+
+
+  p->multipart_boundary[0] = '-';
+  p->multipart_boundary[1] = '-';
+  strcpy(&(p->multipart_boundary[2]), boundary);
+
+
+  p->boundary_length =  (2 * sizeof(char)) + boundary_length; 
+  
+  p->lookbehind = (p->multipart_boundary + p->boundary_length + 1);
+
+  p->index = 0;
+  p->state = s_start;
+ 
+
+  return p;
+}
+
+void multipart_parser_c_free(multipart_parser_c* p) {
+  free(p);
+}
+
+void multipart_parser_c_set_data(multipart_parser_c *p, void *data) {
+    p->data = data;
+}
+
+void *multipart_parser_c_get_data(multipart_parser_c *p) {
+    return p->data;
+}
+
+size_t multipart_parser_c_execute(multipart_parser_c* p, const multipart_parser_c_settings* settings, const char *buf, size_t len) {
+  size_t i = 0;
+  size_t mark = 0;
+  char c, cl;
+  int is_last = 0;
+
+  while(i < len) {
+    c = buf[i];
+    is_last = (i == (len - 1));
+    switch (p->state) {
+      case s_start:
+        multipart_log("s_start");
+        p->index = 0;
+        NOTIFY_CB(message_begin);
+        p->state = s_start_boundary;
+
+      /* fallthrough */
+      case s_start_boundary:
+        multipart_log("s_start_boundary");
+        if (p->index == p->boundary_length) {
+          if (c != CR) {
+            return i;
+          }
+          p->index++;
+          break;
+        } else if (p->index == (p->boundary_length + 1)) {
+          if (c != LF) {
+            return i;
+          }
+          p->index = 0;
+          NOTIFY_CB(part_begin);
+          p->state = s_header_field_start;
+          break;
+        }
+        if (c != p->multipart_boundary[p->index]) {
+          return i;
+        }
+        p->index++;
+        break;
+
+      case s_header_field_start:
+        multipart_log("s_header_field_start");
+        mark = i;
+        p->state = s_header_field;
+
+      /* fallthrough */
+      case s_header_field:
+        multipart_log("s_header_field");
+        if (c == CR) {
+          p->state = s_headers_almost_done;
+          break;
+        }
+
+        if (c == ':') {
+          EMIT_DATA_CB(header_field, buf + mark, i - mark);
+          p->state = s_header_value_start;
+          break;
+        }
+
+        cl = tolower(c);
+        if ((c != '-') && (cl < 'a' || cl > 'z')) {
+          multipart_log("invalid character in header name");
+          return i;
+        }
+        if (is_last)
+            EMIT_DATA_CB(header_field, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_headers_almost_done:
+        multipart_log("s_headers_almost_done");
+        if (c != LF) {
+          return i;
+        }
+
+        p->state = s_part_data_start;
+        break;
+
+      case s_header_value_start:
+        multipart_log("s_header_value_start");
+        if (c == ' ') {
+          break;
+        }
+
+        mark = i;
+        p->state = s_header_value;
+
+      /* fallthrough */
+      case s_header_value:
+        multipart_log("s_header_value");
+        if (c == CR) {
+          EMIT_DATA_CB(header_value, buf + mark, i - mark);
+          p->state = s_header_value_almost_done;
+          break;
+        }
+        if (is_last)
+            EMIT_DATA_CB(header_value, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_header_value_almost_done:
+        multipart_log("s_header_value_almost_done");
+        if (c != LF) {
+          return i;
+        }
+        p->state = s_header_field_start;
+        break;
+
+      case s_part_data_start:
+        multipart_log("s_part_data_start");
+        NOTIFY_CB(headers_complete);
+        mark = i;
+        p->state = s_part_data;
+
+      /* fallthrough */
+      case s_part_data:
+        multipart_log("s_part_data");
+        if (c == CR) {
+            EMIT_DATA_CB(part_data, buf + mark, i - mark);
+            mark = i;
+            p->state = s_part_data_almost_boundary;
+            p->lookbehind[0] = CR;
+            break;
+        }
+        if (is_last)
+            EMIT_DATA_CB(part_data, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_part_data_almost_boundary:
+        multipart_log("s_part_data_almost_boundary");
+        if (c == LF) {
+            p->state = s_part_data_boundary;
+            p->lookbehind[1] = LF;
+            p->index = 0;
+            break;
+        }
+        EMIT_DATA_CB(part_data, p->lookbehind, 1);
+        p->state = s_part_data;
+        mark = i --;
+        break;
+
+      case s_part_data_boundary:
+        multipart_log("s_part_data_boundary");
+        if (p->multipart_boundary[p->index] != c) {
+          EMIT_DATA_CB(part_data, p->lookbehind, 2 + p->index);
+          p->state = s_part_data;
+          mark = i --;
+          break;
+        }
+        p->lookbehind[2 + p->index] = c;
+        if ((++ p->index) == p->boundary_length) {
+            NOTIFY_CB(part_complete);
+            p->state = s_part_data_almost_end;
+        }
+        break;
+
+      case s_part_data_almost_end:
+        multipart_log("s_part_data_almost_end");
+        if (c == '-') {
+            p->state = s_part_data_final_hyphen;
+            break;
+        }
+        if (c == CR) {
+            p->state = s_part_complete;
+            break;
+        }
+        return i;
+   
+      case s_part_data_final_hyphen:
+        multipart_log("s_part_data_final_hyphen");
+        if (c == '-') {
+            NOTIFY_CB(message_complete);
+            p->state = s_end;
+            break;
+        }
+        return i;
+
+      case s_part_complete:
+        multipart_log("s_part_complete");
+        if (c == LF) {
+            p->state = s_header_field_start;
+            NOTIFY_CB(part_begin);
+            break;
+        }
+        return i;
+
+      case s_end:
+        multipart_log("s_end: %02X", (int) c);
+        break;
+
+      default:
+        multipart_log("Multipart parser unrecoverable error");
+        return 0;
+    }
+    ++ i;
+  }
+
+  return len;
+}

data/ext/multipart_parser/multipart_parser_c.h

@@ -0,0 +1,67 @@
+/* Based on node-formidable by Felix Geisendörfer 
+ * Igor Afonov - afonov@gmail.com - 2012
+ * MIT License - http://www.opensource.org/licenses/mit-license.php
+ * Modified Benjamin Bryant - https://github.com/bhbryant/multipart_parser - 2015
+ */
+#ifndef _multipart_parser_c_h
+#define _multipart_parser_c_h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdlib.h>
+#include <ctype.h>
+
+typedef struct multipart_parser_c multipart_parser_c;
+typedef struct multipart_parser_c_settings multipart_parser_c_settings;
+typedef struct multipart_parser_c_state multipart_parser_c_state;
+
+typedef int (*multipart_data_cb) (multipart_parser_c*, const char *at, size_t length);
+typedef int (*multipart_notify_cb) (multipart_parser_c*);
+
+struct multipart_parser_c_settings {
+  multipart_data_cb on_header_field;
+  multipart_data_cb on_header_value;
+  multipart_data_cb on_part_data;
+
+  multipart_notify_cb on_message_begin;
+  multipart_notify_cb on_part_begin;
+  multipart_notify_cb on_headers_complete;
+  multipart_notify_cb on_part_complete;
+  multipart_notify_cb on_message_complete;
+};
+
+struct multipart_parser_c {
+  void * data;
+
+  size_t index;
+  size_t boundary_length;
+
+  unsigned char state;
+
+
+  void * context; /* modified from original code to allow pointer wrapper to be passed to callbacks */
+
+  char* lookbehind;
+  char multipart_boundary[1];
+
+};
+
+/*modified from original code to move settings as an agument to execute fuction */
+multipart_parser_c* multipart_parser_c_init(const char *boundary, size_t boundary_length);
+
+void multipart_parser_c_free(multipart_parser_c* p);
+
+/* modified from original code to allow take settings as argument */
+size_t multipart_parser_c_execute(multipart_parser_c* p, const multipart_parser_c_settings* settings, const char *buf, size_t len);
+
+void multipart_parser_c_set_data(multipart_parser_c* p, void* data);
+void * multipart_parser_c_get_data(multipart_parser_c* p);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/lib/multipart_parser/version.rb

@@ -0,0 +1,3 @@
+class MultipartParser
+  VERSION = "0.0.1"
+end

data/lib/multipart_parser.rb

@@ -0,0 +1,21 @@
+require "multipart_parser/version"
+require "multipart_parser/multipart_parser"
+
+class MultipartParser
+
+  class << self
+
+    #Multiple headers are listed as arrays
+    attr_reader :default_header_value_type 
+
+    def default_header_value_type=(val)
+      if (val != :mixed && val != :strings && val != :arrays)
+        raise ArgumentError, "Invalid header value type"
+      end
+      @default_header_value_type = val
+    end
+  end
+
+end
+
+MultipartParser.default_header_value_type = :mixed

data/multipart_parser.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multipart_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "multipart_parser"
+  spec.version       = MultipartParser::VERSION
+  spec.authors       = ["Benjamin Bryant"]
+  spec.extensions    = ["ext/multipart_parser/extconf.rb"]
+  spec.summary       = %q{multipart/form-data parser}
+  spec.description   = %q{Ruby bindings for https://github.com/iafonov/multipart-parser-c}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec"
+end

data/spec/multipart_parser_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe MultipartParser do  
+
+  let(:handler) {  proc {} }
+
+  def execute(parser)
+    parser << "--Boundary+17376C87E2579930\r\nContent-Disposition: form-data; name=ID; paramName=TEST_PARAM_1\r\nContent-Transfer-Encoding: binary\r\nContent-Type: text/plain\r\n\r\nfirst frame\r\n";
+    parser << "--Boundary+17376C87E2579930\r\nContent-Disposition: form-data; name=ID; paramName=TEST_PARAM_2\r\nContent-Transfer-Encoding: binary\r\nContent-Type: text/plain\r\n\r\nsecond frame\r\n";
+    parser << "--Boundary+17376C87E2579930--\r\n"
+  end
+
+
+
+  context "with assigned callbacks" do
+    let(:parser) { MultipartParser.new "Boundary+17376C87E2579930" }
+
+    it "emits message_begin" do
+      parser.on_message_begin = handler
+
+      expect(handler).to receive(:call).once
+
+      execute(parser)
+    end
+
+    it "emits part_begin" do
+      parser.on_part_begin = handler
+
+      expect(handler).to receive(:call).twice
+      
+      execute(parser)
+    end
+
+    it "parse multipart headers" do
+      parser.on_headers_complete = handler
+
+
+      expect(handler).to receive(:call).with({"Content-Disposition"=>"form-data; name=ID; paramName=TEST_PARAM_1", "Content-Transfer-Encoding"=>"binary", "Content-Type"=>"text/plain"})
+      expect(handler).to receive(:call).with({"Content-Disposition"=>"form-data; name=ID; paramName=TEST_PARAM_2", "Content-Transfer-Encoding"=>"binary", "Content-Type"=>"text/plain"})
+
+      execute(parser)
+    end
+
+    it "parses multipart data" do
+     
+      parser.on_data = handler
+
+      expect(handler).to receive(:call).with("first frame")
+      expect(handler).to receive(:call).with("second frame")
+
+      execute(parser)
+    end
+
+    it "emits part_complete" do
+      parser.on_part_complete = handler
+
+      expect(handler).to receive(:call).twice
+      
+      execute(parser)
+    end
+
+    it "emits message_complete" do
+      parser.on_message_complete = handler
+
+      expect(handler).to receive(:call).once
+
+      execute(parser)
+    end
+
+
+  end
+
+  context "with callback object" do
+    let(:callback_obj) { double("Callback")}
+    let(:parser) { MultipartParser.new "Boundary+17376C87E2579930", callback_obj }
+
+
+    it "emits message_begin" do
+      expect(callback_obj).to receive(:on_message_begin).once
+
+      execute(parser)
+    end
+
+    it "emits part_begin" do
+      expect(callback_obj).to receive(:on_part_begin).twice
+      
+      execute(parser)
+    end
+
+
+    it "parse multipart headers" do
+      expect(callback_obj).to receive(:on_headers_complete).with({"Content-Disposition"=>"form-data; name=ID; paramName=TEST_PARAM_1", "Content-Transfer-Encoding"=>"binary", "Content-Type"=>"text/plain"})
+      expect(callback_obj).to receive(:on_headers_complete).with({"Content-Disposition"=>"form-data; name=ID; paramName=TEST_PARAM_2", "Content-Transfer-Encoding"=>"binary", "Content-Type"=>"text/plain"})
+
+      execute(parser)
+    end
+
+
+    it "parses multipart data" do
+
+      expect(callback_obj).to receive(:on_data).with("first frame")
+      expect(callback_obj).to receive(:on_data).with("second frame")
+
+      execute(parser)
+    end
+
+    it "emits part_complete" do
+      expect(callback_obj).to receive(:on_part_complete).twice
+      
+      execute(parser)
+    end
+
+    it "emits message_complete" do
+      expect(callback_obj).to receive(:on_message_complete).once
+
+      execute(parser)
+    end
+
+  end
+
+  it "allows the type of the header values to be configured" do
+    
+    parser = MultipartParser.new("Boundary+17376C87E2579930", nil, :arrays)
+    parser.on_headers_complete = handler
+
+    expect(handler).to receive(:call).with({"Content-Disposition"=>["form-data; name=ID_A", "form-data; name=ID_B"], "Content-Type"=>["text/plain"]})
+
+    parser << "--Boundary+17376C87E2579930\r\nContent-Disposition: form-data; name=ID_A\r\nContent-Disposition: form-data; name=ID_B\r\nContent-Type: text/plain\r\n\r\ntext\r\n"
+     
+  end
+
+  it "allows the default header value type to be set" do
+    value_type = MultipartParser.default_header_value_type
+
+    MultipartParser.default_header_value_type = :arrays
+
+    parser = MultipartParser.new("Boundary+17376C87E2579930")
+
+
+    parser.on_headers_complete = handler
+
+    expect(handler).to receive(:call).with({"Content-Disposition"=>["form-data; name=ID_A", "form-data; name=ID_B"], "Content-Type"=>["text/plain"]})
+
+    parser << "--Boundary+17376C87E2579930\r\nContent-Disposition: form-data; name=ID_A\r\nContent-Disposition: form-data; name=ID_B\r\nContent-Type: text/plain\r\n\r\ntext\r\n"
+
+    ## reset
+    MultipartParser.default_header_value_type = value_type
+  end
+
+  it 'has a version number' do
+    expect(MultipartParser::VERSION).not_to be nil
+  end
+
+  specify { expect { MultipartParser.new }.to raise_error(ArgumentError) }
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'multipart_parser'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: multipart_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Benjamin Bryant
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby bindings for https://github.com/iafonov/multipart-parser-c
+email: 
+executables: []
+extensions:
+- ext/multipart_parser/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/multipart_parser/ext_help.h
+- ext/multipart_parser/extconf.rb
+- ext/multipart_parser/multipart_parser.c
+- ext/multipart_parser/multipart_parser_c.c
+- ext/multipart_parser/multipart_parser_c.h
+- lib/multipart_parser.rb
+- lib/multipart_parser/version.rb
+- multipart_parser.gemspec
+- spec/multipart_parser_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: multipart/form-data parser
+test_files:
+- spec/multipart_parser_spec.rb
+- spec/spec_helper.rb