bencode_ext 0.1.2 → 0.2.0

data/Rakefile

@@ -14,7 +14,6 @@ Jeweler::Tasks.new do |gem|
   gem.required_ruby_version = '~>1.9.2'
   gem.add_dependency 'rake-compiler', '~>0.7.5'
   gem.add_development_dependency "jeweler", "~> 1.5.2"
-  gem.extensions << "ext/bencode_ext/extconf.rb"
 end
 Jeweler::RubygemsDotOrgTasks.new
 Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/bencode_ext.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bencode_ext}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["naquad"]
-  s.date = %q{2011-01-01}
+  s.date = %q{2011-01-14}
   s.description = %q{BEncodeExt is implementation of Bencode reader/writer (BitTorent encoding) in C.}
   s.email = %q{naquad@gmail.com}
-  s.extensions = ["ext/bencode_ext/extconf.rb", "ext/bencode_ext/extconf.rb"]
+  s.extensions = ["ext/bencode_ext/extconf.rb"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.rdoc"

data/ext/bencode_ext/bencode.c

@@ -23,88 +23,28 @@
 
 #include "bencode.h"
 
-#define NEXT_CHAR ++*str; --*len;
-#define END_CHECK_SKIP(t) {if(!*len)\
-                            rb_raise(DecodeError, "Unpexpected " #t " end!");\
-                           if(**str != 'e')\
-                            rb_raise(DecodeError, "Mailformed " #t " at %d byte: %c", rlen - *len, **str);\
-                           NEXT_CHAR;}
-
 static long parse_num(char** str, long* len){
   long t = 1, ret = 0;
 
   if(**str == '-'){
     t = -1;
-    NEXT_CHAR;
+    ++*str;
+    --*len;
   }
 
   while(*len && **str >= '0' && **str <= '9'){
     ret = ret * 10 + (**str - '0');
-    NEXT_CHAR;
+    ++*str;
+    --*len;
   }
 
   return ret * t;
 }
 
-static VALUE _decode(char** str, long* len, long rlen){
-  if(!*len)
-    return Qnil;
-
-  switch(**str){
-    case 'l':{
-      VALUE ret = rb_ary_new();
-      NEXT_CHAR;
-
-      while(**str != 'e' && *len)
-        rb_ary_push(ret, _decode(str, len, rlen));
-
-      END_CHECK_SKIP(list);
-      return ret;
-    }
-    case 'd':{
-      VALUE ret = rb_hash_new();
-      NEXT_CHAR;
-
-      while(**str != 'e' && *len){
-        long t = *len;
-        VALUE k = _decode(str, len, rlen);
-
-        if(TYPE(k) != T_STRING)
-          rb_raise(DecodeError, "Dictionary key is not a string at %d!", rlen - t);
-
-        rb_hash_aset(ret, k, _decode(str, len, rlen));
-      }
-
-      END_CHECK_SKIP(dictionary);
-      return ret;
-    }
-    case 'i':{
-      long t;
-      NEXT_CHAR;
-      t = parse_num(str, len);
-      END_CHECK_SKIP(integer);
-      return LONG2FIX(t);
-    }
-    case '0'...'9':{
-      VALUE ret;
-      long slen = parse_num(str, len);
-
-      if(slen < 0 || (*len && **str != ':'))
-        rb_raise(DecodeError, "Invalid string length specification at %d: %c", rlen - *len, **str);
-
-      if(!*len || *len < slen + 1)
-        rb_raise(DecodeError, "Unexpected string end!");
-
-      ret = rb_str_new(++*str, slen);
-      *str += slen;
-      *len -= slen + 1;
-      return ret;
-    }
-    default:
-      rb_raise(DecodeError, "Unknown element type at %d byte: %c", rlen - *len, **str);
-      return Qnil;
-  }
-}
+#define NEXT_CHAR ++str; --len;
+#define ELEMENT_SCALAR 0
+#define ELEMENT_STRUCT 1
+#define ELEMENT_END 2
 
 /*
  * Document-method: BEncode.decode
@@ -118,25 +58,104 @@ static VALUE _decode(char** str, long* len, long rlen){
  *
  * Examples:
  *
- *    'i1e' => 1
- *    'i-1e' => -1
- *    '6:string' => 'string'
+ *    BEncode.decode('i1e') => 1
+ *    BEncode.decode('i-1e') => -1
+ *    BEncode.decode('6:string') => 'string'
  */
 
-static VALUE decode(VALUE self, VALUE str){
-  long rlen, len;
-  char* ptr;
-  VALUE ret;
+static VALUE decode(VALUE self, VALUE encoded){
+  long  len, rlen;
+  char* str;
+  VALUE ret, container_stack, current_container, key, crt;
 
-  if(!rb_obj_is_kind_of(str, rb_cString))
+  if(!rb_obj_is_kind_of(encoded, rb_cString))
     rb_raise(rb_eTypeError, "String expected");
 
-  rlen = len = RSTRING_LEN(str);
-  ptr = RSTRING_PTR(str);
-  ret = _decode(&ptr, &len, len);
+  len = rlen = RSTRING_LEN(encoded);
+  if(!len)
+    return Qnil;
+
+  str = RSTRING_PTR(encoded);
+  container_stack = rb_ary_new();
+  current_container = ret = key = Qnil;
+
+  while(len){
+    int state = ELEMENT_SCALAR;
+    switch(*str){
+      case 'l':
+      case 'd':
+        crt = *str == 'l' ? rb_ary_new() : rb_hash_new();
+        NEXT_CHAR;
+        if(NIL_P(current_container)){
+          ret = current_container = crt;
+          continue;
+        }
+        state = ELEMENT_STRUCT;
+        break;
+      case 'i':
+        NEXT_CHAR;
+        crt = LONG2FIX(parse_num(&str, &len));
+
+        if(!len)
+          rb_raise(DecodeError, "Unpexpected integer end!");
+        if(*str != 'e')
+          rb_raise(DecodeError, "Mailformed integer at %d byte: %c", rlen - len, *str);
+
+        NEXT_CHAR;
+        break;
+      case '0'...'9':{
+        long slen = parse_num(&str, &len);
+
+        if(slen < 0 || (len && *str != ':'))
+          rb_raise(DecodeError, "Invalid string length specification at %d: %c", rlen - len, *str);
+
+        if(!len || len < slen + 1)
+          rb_raise(DecodeError, "Unexpected string end!");
+
+        crt = rb_str_new(++str, slen);
+        str += slen;
+        len -= slen + 1;
+        break;
+      }
+      case 'e':
+        state = ELEMENT_END;
+        NEXT_CHAR;
+        break;
+      default:
+        rb_raise(DecodeError, "Unknown element type at %d: %c!", rlen - len, *str);
+    }
+
+    if(state == ELEMENT_END){
+      if(NIL_P(current_container))
+        rb_raise(DecodeError, "Unexpected container end at %d!", rlen - len);
+      current_container = rb_ary_pop(container_stack);
+    }else if(NIL_P(current_container)){
+      if(NIL_P(ret))
+        ret = crt;
+      break;
+    }else{
+      if(TYPE(current_container) == T_ARRAY){
+        rb_ary_push(current_container, crt);
+      }else if(NIL_P(key)){
+        if(TYPE(crt) != T_STRING)
+          rb_raise(DecodeError, "Dictionary key must be a string (at %d)!", rlen - len);
+        key = crt;
+      }else{
+        rb_hash_aset(current_container, key, crt);
+        key = Qnil;
+      }
+
+      if(state == ELEMENT_STRUCT){
+        rb_ary_push(container_stack, current_container);
+        if(max_depth > -1 && max_depth < RARRAY_LEN(container_stack) + 1)
+          rb_raise(DecodeError, "Structure is too deep!");
+        current_container = crt;
+      }
+    }
+  }
 
   if(len)
-    rb_raise(DecodeError, "String has garbage on the end (starts at %d).", rlen - len);
+    rb_raise(DecodeError, "String has garbage on the end (starts at %d: %s).", rlen - len);
 
   return ret;
 }
@@ -257,9 +276,53 @@ static VALUE mod_encode(VALUE self, VALUE x){
   return encode(x);
 }
 
+/*
+ * Document-method: max_depth
+ * call-seq:
+ *    BEncode.max_depth
+ *
+ * Get maximum depth of parsed structure.
+ */
+
+static VALUE get_max_depth(VALUE self){
+  return LONG2FIX(max_depth);
+}
+
+/*
+ * Document-method: max_depth=
+ * call-seq:
+ *    BEncode.max_depth = _integer_
+ *
+ * Sets maximum depth of parsed structure.
+ * Expects integer greater or equal to 0.
+ * By default this value is 5000.
+ * Assigning nil will disable depth check.
+ */
+
+static VALUE set_max_depth(VALUE self, VALUE depth){
+  long t;
+
+  if(NIL_P(depth)){
+    max_depth = -1;
+    return depth;
+  }
+
+  if(!rb_obj_is_kind_of(depth, rb_cInteger))
+    rb_raise(rb_eArgError, "Integer expected!");
+
+  t = NUM2LONG(depth);
+  if(t < 0)
+    rb_raise(rb_eArgError, "Depth must be between 0 and 5000000");
+
+  max_depth = t;
+  return depth;
+}
+
 void Init_bencode_ext(){
   readId = rb_intern("read");
+  max_depth = 5000;
   BEncode = rb_define_module("BEncode");
+
   /*
    * Document-class: BEncode::DecodeError
    * Exception for indicating decoding errors.
@@ -275,6 +338,8 @@ void Init_bencode_ext(){
   rb_define_singleton_method(BEncode, "decode", decode, 1);
   rb_define_singleton_method(BEncode, "encode", mod_encode, 1);
   rb_define_singleton_method(BEncode, "decode_file", decode_file, 1);
+  rb_define_singleton_method(BEncode, "max_depth", get_max_depth, 0);
+  rb_define_singleton_method(BEncode, "max_depth=", set_max_depth, 1);
 
   rb_define_method(BEncode, "bencode", encode, 0);
   rb_define_method(rb_cString, "bdecode", str_bdecode, 0);

data/ext/bencode_ext/bencode.h

@@ -9,7 +9,6 @@ static VALUE EncodeError;
 static VALUE readId;
 
 static long parse_num(char**, long*);
-static VALUE _decode(char**, long*, long);
 static VALUE decode(VALUE, VALUE);
 static VALUE encode(VALUE);
 static int hash_traverse(VALUE, VALUE, VALUE);
@@ -17,6 +16,9 @@ static VALUE str_bdecode(VALUE);
 static VALUE mod_encode(VALUE, VALUE);
 static VALUE _decode_file(VALUE);
 static VALUE decode_file(VALUE, VALUE);
+static VALUE get_max_depth(VALUE);
+static VALUE set_max_depth(VALUE, VALUE);
+static long max_depth;
 void Init_bencode_ext();
 
 #endif

data/ext/bencode_ext/extconf.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/ruby -w
 
 require 'mkmf'
+$CFLAGS='-g'
+$LDFLAGS='-g'
 create_makefile('bencode_ext')

data/test/test_bencode_ext.rb

@@ -9,6 +9,7 @@ class TestBencodeExt < Test::Unit::TestCase
     assert_equal('li1ei2ee', [1, 2].bencode)
     assert_equal('d3:keyi10ee', {:key => 10}.bencode)
     assert_equal('ld1:ki1eed1:ki2eed1:kd1:v3:123eee', [{:k => 1}, {:k => 2}, {:k => {:v => '123'}}].bencode)
+    assert_equal('llli1eei1eei1ee', [[[1],1],1].bencode)
 
     assert_raises(BEncode::EncodeError) { STDERR.bencode }
   end
@@ -20,9 +21,21 @@ class TestBencodeExt < Test::Unit::TestCase
     assert_equal([1, 2], 'li1ei2ee'.bdecode)
     assert_equal({'key' => 10}, 'd3:keyi10ee'.bdecode)
     assert_equal([{'k' => 1}, {'k' => 2}, {'k' => {'v' => '123'}}], 'ld1:ki1eed1:ki2eed1:kd1:v3:123eee'.bdecode)
+    assert_equal([[[1],1],1], 'llli1eei1eei1ee'.bdecode)
 
     assert_raises(BEncode::DecodeError) {'33:unpexpected_end'.bdecode }
     assert_raises(BEncode::DecodeError) { 'i1x'.bdecode }
+    assert_raises(ArgumentError) { BEncode.max_depth = 1.1 }
+    assert_raises(ArgumentError) { BEncode.max_depth = -5 }
+    assert_raises(BEncode::DecodeError) do
+      BEncode.max_depth = 1
+      'lli1eee'.bdecode
+    end
+    assert_nothing_raised(BEncode::DecodeError) do
+      BEncode.max_depth = 0
+      'i1e'.bdecode
+    end
+
     assert_nil(''.bdecode)
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - naquad
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-01 00:00:00 +02:00
+date: 2011-01-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,7 +53,6 @@ executables: []
 
 extensions: 
 - ext/bencode_ext/extconf.rb
-- ext/bencode_ext/extconf.rb
 extra_rdoc_files: 
 - LICENSE.txt
 - README.rdoc