tlv 0.0.3

data/lib/tlv/raw.rb

@@ -0,0 +1,31 @@
+module TLV
+class TLV
+  class Raw < Field
+    def initialize clazz, desc=nil, name=nil, len=0
+      desc ||= "Value" 
+      super
+    end
+    def define_accessor clazz
+      super
+      name = @name
+      clazz.instance_eval{
+        define_method("#{name}="){|val|
+          val ||= ""
+          raise("must be a String #{val}")  unless val.is_a?(String)
+          self.instance_variable_set("@#{name}", val)
+        }
+        
+        define_method("#{name}") {
+          self.instance_variable_get("@#{name}") || ""
+        }
+      }
+    end
+    def parse tlv, bytes, length
+      val  = bytes[0, length]
+      rest = bytes[length, bytes.length]
+      tlv.send("#{name}=", val)
+      rest
+    end 
+  end
+end
+end # module

data/lib/tlv/tag.rb

@@ -0,0 +1,51 @@
+module TLV
+class TLV
+
+class << self
+  CLASS_MASK      = 0xC0
+  UNIVERSAL_CLASS = 0x00 
+  APPLICATION     = 0x40 
+  CTX_SPECIFIC    = 0x80 
+  PRIVATE         = 0xC0 
+
+  BYTE6           = 0x20
+
+  def universal?
+    ((@tag & CLASS_MASK) == UNIVERSAL_CLASS) if @tag
+  end
+  def application?
+    ((@tag & CLASS_MASK) == APPLICATION) if @tag
+  end
+  def context_specific?
+    ((@tag & CLASS_MASK) == CTX_SPECIFIC) if @tag
+  end
+  def private?
+    ((@tag & CLASS_MASK) == PRIVATE) if @tag
+  end
+  def primitive?
+    if @tag
+      ((@tag & BYTE6) == 0x00) 
+    else
+      true # `tagless` datastructs are by default primitive
+    end
+  end
+  def constructed?
+    ((@tag & BYTE6) == BYTE6) if @tag
+  end
+  # check the tag is approriate length
+  def check_tag
+    if (tag & 0x1f) == 0x1f # last 5 bits set, 2 byte tag
+      raise "Tag too short: #{b2s(tag)} should be 2 bytes" unless tag.length > 1
+      if (tag[1]&0x80) == 0x80
+        raise "Tag length incorrect: #{b2s(tag)} should be 3 bytes" unless tag.length == 3
+      else
+        raise "Tag too long: #{b2s(tag)} should be 2 bytes" if tag.length > 2
+      end
+    else
+      raise "Tag too long: #{b2s(tag)} should be 1 bytes" if tag.length > 1
+    end
+  end
+
+end        
+end
+end # module

data/lib/tlv/tlv.rb

@@ -0,0 +1,144 @@
+
+module TLV
+  
+	def self.b2s bytestr
+    return "" unless bytestr
+    r = bytestr.unpack("H*")[0]
+    r.length > 1 ? r : "  "
+  end
+  def self.s2b string
+    return "" unless string
+    string = string.gsub(/\s+/, "")
+    string = "0" + string unless (string.length % 2 == 0)
+    [string].pack("H*") 
+  end
+
+class TLV 
+
+	def self.s2b str
+		::TLV.s2b str
+	end
+	def self.b2s bytes
+		::TLV.b2s bytes
+	end
+#  def self.register tag, clazz
+#    @tlv_classes ||= {}
+#    @tlv_classes[tag] = clazz
+#  end
+
+  
+  DEBUG = ENV["DEBUG"] 
+
+  # Outputs a warning in case the enironment
+  # variable `DEBUG` is set.
+  def self.warn mes
+    STDERR.puts "[warn] #{mes}" if ENV["DEBUG"]
+  end
+          
+  
+#
+#  class A < Field
+#  end
+#
+#  class AN < Field
+#  end
+#
+#  class ANS < Field
+#  end
+#
+ #
+#  class CN < Field
+#  end
+#
+#  class N < Field
+#  end
+  
+  class << self
+    attr_accessor :tag
+    attr_accessor :display_name
+    # If this TLV is placed into another as a subfield, this will be 
+    # the name of the accessor, default is the rubyfied display_name
+    attr_accessor :accessor_name
+    def tlv tag, display_name, accessor_name=nil
+      @tag = case tag
+             when String
+               TLV.s2b(tag)
+             when Fixnum
+               TLV::s2b("%x" % tag)
+             end
+      def @tag.& flag
+        self[0] & flag
+      end
+      check_tag
+      @display_name = display_name
+      @accessor_name = accessor_name || rubify_a(display_name)
+      TLV.register self
+    end
+    
+    
+
+    def fields
+      @fields ||= (self == TLV ? [] : superclass.fields.dup) 
+    end
+
+    def b len, desc, name=nil
+      raise "invalid len #{len}" unless (len%8 == 0)
+      fields << B.new(self, desc, name, len)
+    end
+    
+    def raw desc=nil, name=nil
+      @is_raw = true
+      fields << Raw.new(self, desc, name)
+    end
+
+    def is_raw?
+      @is_raw == true
+    end
+
+    # for constructed tlv's, add subtags that must be present
+  end # meta class thingie
+
+  def display_name
+     self.class.display_name
+  end
+  def to_s
+    longest = 0
+    fields.each { |field|
+      longest = field.display_name.length if field.display_name.length > longest
+    }
+    fmt = "%#{longest}s : %s\n"
+    str = "#{display_name}"
+    str << " (0x#{TLV.b2s(tag)})" if tag
+    str << "\n"
+
+    str << "-" * (str.length-1) << "\n"
+    fields.each { |field|
+      str << (fmt % [field.display_name, TLV.b2s(self.send(field.name))])
+    }
+    (mandatory+optional).each { |tlv_class|
+      temp_tlv = self.send(tlv_class.accessor_name)
+      temp = temp_tlv.to_s
+      temp.gsub!(/^/, "  ")
+      str << temp
+    }
+    str
+  end
+
+
+  def fields
+    self.class.fields
+  end
+
+  def mandatory
+    self.class.mand_tags
+  end
+  def optional
+    self.class.opt_tags
+  end
+
+  def tag
+    self.class.tag
+  end
+end
+
+end # module

data/lib/tlv/to_bytes.rb

@@ -0,0 +1,76 @@
+module TLV
+class TLV
+  
+  def get_bytes
+    if self.class.primitive?  || (self.is_a?(DGI) && fields.length!=0) || self.class.is_raw?
+      bytes = get_bytes_primitive
+    else
+      bytes = get_bytes_constructed
+    end
+  end      
+  def get_bytes_primitive
+    bytes = ""
+    fields.each { |field|
+      bytes << self.send(field.name)
+    }
+    bytes
+  end
+
+  def get_bytes_constructed
+    bytes = ""
+    mandatory.each {|t|
+      tlv = self.send(t.accessor_name)
+      raise "Mandatory subtag #{t} not set!" unless tlv
+      bytes << tlv.to_b
+    }
+    optional.each { |t|
+      tlv = self.send(t.accessor_name)
+      bytes << tlv.to_b if tlv
+    }
+    bytes
+  end
+
+  def get_len_bytes len
+
+    # one byte max = 127
+    # two          = 255 (2**8)-1
+    # three        = 65535 (2 ** 16) -1
+    # four         = 16777215 (2 ** 32) -1
+    num_len_bytes = case len
+                    when 0..127            : 1
+                    when 128..255          : 2
+                    when 256..65535        : 3 # short        
+                    when 65536..4294967295 : 5 # long, skip 3 byte len, too difficult :)
+                    else
+                            raise "Don't be silly"
+                    end
+    len_bytes     = case num_len_bytes
+                    when 1 : "" << len
+                    when 2 : "\x81" << len 
+                    when 3 : "\x82" << [len].pack("n")
+                    when 5 : "\x84" << [len].pack("N") 
+                    else
+                      raise "Can't happen"
+                    end      
+    return len_bytes 
+  end
+
+  # this provides an opportunity to manipulate the payload 
+  # before it is assembled. Expects a proc taking the bytes of the 
+  # payload and returning the new version of the bytes.
+  def payload_hook= hook
+    @hook = hook
+  end
+
+  def to_b
+    bytes = get_bytes
+    bytes = @hook.call(bytes) if @hook
+    if tag
+      bytes.insert 0, get_len_bytes(bytes.length)
+      bytes.insert 0, tag
+    end
+    bytes
+  end
+end
+end # module
+

data/test/constructed_test.rb

@@ -0,0 +1,106 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/tlv'
+
+class TestTLVConstructed < Test::Unit::TestCase
+	include TLV
+  def setup
+  end
+  
+  class TLVTagTest < TLV
+    tlv "41", "Test TLV"
+    b   8,   "first field",  :first
+    b   8,   "second field", :second
+  end
+  class TLVTestCons < TLV
+    tlv "32", "Test Constructed" 
+    mandatory TLVTagTest, "tlv_tag_test"
+    mandatory :tag => "43",
+              :display_name => "Another Test"
+  end
+
+  class TLVTestCons2 < TLV
+    tlv "32", "Test Constructed 32 2"
+    optional TLVTagTest, "tlv_tag_test"
+    optional :tag => "43",
+             :display_name => "Another Test"
+  end
+
+  class DGITest < DGI
+    tlv "9102", "Random Test Data"
+    mandatory TLVTagTest, :test
+    optional :tag => "43",
+             :display_name => "Another Test"
+  end
+
+  def basics t
+    assert(t.methods.include?("tlv_tag_test" ))
+    assert(t.methods.include?("tlv_tag_test="))
+    assert(t.methods.include?("another_test" ))
+    assert(t.methods.include?("another_test="))
+  end
+  def test_basics
+    t = TLVTestCons.new
+    basics t
+    assert_nothing_raised {
+      t = TLVTestCons::AnotherTest.new 
+    }
+    t = TLVTestCons2.new
+    basics t
+    assert_nothing_raised {
+      t = TLVTestCons2::AnotherTest.new 
+    }
+  end
+ 
+  def test_const_to_b
+    t = TLVTagTest.new
+    t.first  = "\x01"
+    t.second = "\x02"
+
+    t2 = TLVTestCons::AnotherTest.new
+    t2.value = "\x34\x56"
+
+    t3 = TLVTestCons.new
+    t3.tlv_tag_test= t
+    t3.another_test= t2
+    
+    assert_equal(TLV.s2b("32084102010243023456"), t3.to_b)
+
+    bytes = t3.to_b
+    t, rest = TLVTestCons._parse bytes*2
+    assert_equal bytes, rest
+    assert_equal "\x01", t.tlv_tag_test.first
+    assert_equal "\x02", t.tlv_tag_test.second
+    assert_equal "\x34\x56", t.another_test.value
+
+    t, rest = TLV._parse rest
+    assert_equal "\x01", t.tlv_tag_test.first
+    assert_equal "\x02", t.tlv_tag_test.second
+    assert_equal "\x34\x56", t.another_test.value
+  end 
+
+  def test_const_direct_value
+    t = TLVTagTest.new
+    t.first  = "\x01"
+    t.second = "\x02"
+    
+    t2 = TLVTestCons.new
+    t2.tlv_tag_test=t
+    t2.another_test="\x34\x56"
+    
+    assert_equal(TLV.s2b("32084102010243023456"), t2.to_b)
+
+  end
+
+  def test_const_dgi
+    te  = TLVTagTest.new
+    te.first=  "\x01"
+    te.second= "\x02"
+    dgi = DGITest.new
+    dgi.test= te
+    dgi.another_test="\x34\x56"
+
+    assert_equal(TLV.s2b("9102084102010243023456"), dgi.to_b)
+  end
+  
+
+end

data/test/dgi_test.rb

@@ -0,0 +1,122 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/tlv'
+
+class TestDGI < Test::Unit::TestCase
+	include TLV
+  def setup
+  end
+  
+  class TLVTest < DGI
+    tlv "0101", "Test TLV"
+    b   8,   "first field",  :first
+    b   8,   "second field", :second
+  end
+
+  class TLVTest2 < DGI
+    tlv "0102", "Test Rubify"
+    b   8,   "My Test"
+    b   8,   "Oh M@i!"
+  end
+
+  class TLVTest3 < DGI
+    tlv "9F00", "Test Raw"
+    raw
+  end
+  class TLVTestNoTag < DGI
+    b   8,   "first field",  :first
+    b   8,   "second field", :second
+  end
+
+  def basics tlv
+    tlv.first="\x01"
+    tlv.second="\xAA"
+    assert_equal "\x01", tlv.first
+    assert_equal "\xaa", tlv.second
+
+    assert_raise(RuntimeError) {
+      tlv.first="\x02\x03"
+    }
+    assert_raise(RuntimeError) {
+      tlv.first=Time.new
+    }
+    assert_raise(RuntimeError) {
+      tlv.second=1
+    }
+  end
+
+  def test_basics
+    t = TLVTest.new
+    basics t
+    assert_equal "\x01\x01\x02\x01\xaa", t.to_b
+
+  end 
+
+  def test_parse_tag
+
+  end
+
+  def test_length
+    t = TLVTest3.new
+    t.value = ""
+    assert_equal "\x00", t.to_b[2,1]
+    t.value = "1"
+    assert_equal "\x01\x31", t.to_b[2,2]
+    t.value = "1"*127
+    assert_equal "\x7F\x31", t.to_b[2,2]
+    t.value = "1"*128
+    assert_equal "\x80\x31", t.to_b[2,2]
+    t.value = "1"*255
+    assert_equal "\xFf\x00\xff\x31", t.to_b[2,4]
+    t.value = "1"*256
+    assert_equal "\xFF\x01\x00\x31", t.to_b[2,4]
+    
+    assert_raises (RuntimeError) {
+      t.value = "1"*65535
+      assert_equal "\x82\xFF\xFF\x31", t.to_b[2,4]
+    }
+    
+    o = Object.new
+    def o.length
+      return 4294967296
+    end
+    
+    assert_raises (RuntimeError) {
+      t.value=o
+      t.to_b
+    }
+  end
+
+  def test_parse
+    t = TLVTest.new
+    assert_equal "\x00", t.first
+    t.first="\x01"
+    t.second="\xAA"
+    
+    assert "\x01", t.first
+    bytes = t.to_b
+#    t, rest = TLVTest.parse bytes
+#    assert_equal TLVTest, t.class
+#    assert_equal "\x01", t.first
+#    assert_equal "\xAA", t.second
+  end
+  def test_rubify
+    t = TLVTest2.new
+    t.my_test = "\x01"
+    assert_equal "\x01", t.my_test
+    t.oh_mi = "\x02"
+    assert_equal "\x02", t.oh_mi
+  end
+  def test_raw
+    t = TLVTest3.new
+    #puts t.methods.sort
+    t.value= "bumsi"
+    assert_equal "Test Raw", TLVTest3.display_name
+    assert_equal "bumsi", t.value
+    bytes =  t.to_b
+#    t, rest = TLVTest3.parse bytes
+#    assert_equal "bumsi", t.value
+#    assert_equal TLVTest3, t.class
+  end
+
+
+end