codec 0.0.12 → 1.0.0

data/lib/codec/logger.rb

@@ -1,5 +1,5 @@
 module Codec
-  Logger = Log4r::Logger.new 'codec_logger'
+  Logger = Log4r::Logger.new self.name
   Logger.outputters = Log4r::Outputter.stderr
   Logger.level=Log4r::INFO
-end
+end

data/lib/codec/packed.rb

@@ -1,109 +1,58 @@
 module Codec
   class Packed < Base
-    def get_pck_length(length)
-      ((length + 1) / 2)
+    def initialize(length, isNumeric = true, isLeftPadded=false, isFPadded = false)
+      @length = length
+      @isNum = isNumeric
+      @fPad = isFPadded
+      @lPad = isLeftPadded
     end
     
-    def get_length(field)
-      if @length > 0
-        return @length 
-      else
-        return field.get_value.to_s.length
-      end
-    end	
-    
-    def encode_with_length(field)
-      return get_length(field),encode(field)
-    end
-    
-    def decode_with_length(buf,length)
-      l = eval_length(buf,get_pck_length(length))
-      return build_field(buf,l),buf[l,buf.length]
-    end
-    
-    def decode(buf)
-      return decode_with_length(buf,@length)
-    end
-  end
+    # No more required encode return the field length for upper codec layer
+    # def get_length(field)
+    #   if @length > 0
+    #     return @length 
+    #   else
+    #     return field.get_value.to_s.length
+    #   end
+    # end	
 
-  class Numpck < Packed
-    def decode_with_length(buf,length)
-      l = eval_length(buf,get_pck_length(length))
-      f = Field.new(@id)
-      val = buf[0,l].unpack("H*").first
-      if @length.odd?
-        val = val[1,val.length]
+    def check_length(buf,length)
+	    raise "Length is nil" if length.nil?
+      if(length != 0)
+	      if buf.length < length
+	        raise BufferUnderflow, "Not enough data for decoding (#{length}/#{buf.length})"
+	      end
+        return length
       else
-        val = val[1,val.length] if length.odd?
+        return buf.length
       end
-      f.set_value(val.to_i)
-      return f,buf[l,buf.length]
-    end
+    end    
     
-    def encode(field)
-      out = field.get_value.to_s
-      if @length > 0
-        out = out.rjust(@length,"0")
-        raise TooLongDataException if out.length > @length
-      end
-      l = out.length
-      out.prepend("0") if out.length.odd?
-      out = [out].pack("H*")
-      return out
-    end
-  end
-  
-  class Strpck < Packed
-    def decode_with_length(buf,length)
-      l = eval_length(buf,get_pck_length(length))
-      f = Field.new(@id)
-      val = buf[0,l].unpack("H*").first
-      if @length.odd?
-        val.chop! 
-      else
-        val.chop! if length.odd?
-      end
-      f.set_value(val)
-      return f,buf[l,buf.length]
+    def decode(buf,f, length = nil)
+      length ||= @length
+      l = check_length(buf,(length + 1) / 2)
+      val = buf.slice!(0...l).unpack("H*").first
+      # remove padding if odd length
+      ( @lPad ? val.chop! : val.slice!(0) ) if @length.odd? || length.odd?
+      val = val.to_i if @isNum
+      f.set_value(val)   
     end
-    
-    def encode(field)
+
+    def encode(buf, field)
       out = field.get_value.to_s
+      Logger.debug{ "Encode packed #{out} on #{@length} [#{@isNum}|#{@fPad}|#{@lPad}]" }
+      padding = (@fPad ? "F" : "0")
       if @length > 0
-        out = out.ljust(@length,"F")
-        raise TooLongDataException if out.length > @length
-      end
-      l = out.length
-      out += "F" if out.length.odd?
-      out = [out].pack("H*")
-      return out
-    end
-  end
-  
-  class Nstpck < Packed
-    def decode_with_length(buf,length)
-      l = eval_length(buf,get_pck_length(length))
-      f = Field.new(@id)
-      val = buf[0,l].unpack("H*").first
-      if @length.odd?
-        val = val[1,val.length]
-      else
-        val = val[1,val.length] if length.odd?
-      end
-      f.set_value(val)
-      return f,buf[l,buf.length]
-    end
-    
-    def encode(field)
-      out = field.get_value
-      if @length > 0
-        out = out.rjust(@length,"0")
+        out = (@lPad ? out.ljust(@length,padding) : out.rjust(@length,padding))
         raise TooLongDataException if out.length > @length
       end
       l = out.length
-      out.prepend("0") if out.length.odd?
+      # handle padding if odd length
+      (@lPad ? out << padding : out.prepend(padding) )if out.length.odd?
+      Logger.debug{ "before packing : #{out}" }
       out = [out].pack("H*")
-      return out
+      buf << out
+      return l
     end
   end
   

data/lib/codec/prefix.rb

@@ -1,60 +1,51 @@
 module Codec
   class Prefixedlength < Base
-    def initialize(id,length,content)
+    def initialize(length,content)
       # TODO : Check that value_codec has a null length attribute
       @length_codec = length
       @value_codec = content
-      @id = id
     end
 	
     def get_length(length_field)
     	length_field.get_value.to_i
     end
 	
-    def decode(buffer)
-      l, buf = @length_codec.decode(buffer)
-	    len = get_length(l)
+    def decode(buffer, f, length=nil)
+      Logger.warn {"Call decode with length on Prefixedlength codec should never happen"} unless length.nil?
+      len_field = Field.new
+      @length_codec.decode(buffer,len_field)
+	    len = get_length(len_field)
 	    if len == 0
-	      f = Field.new
-		    f.set_id(@id)
-		    f.set_value(nil)
-		    return f,buf
+		    f.set_value("")
 	    else
 	      begin
-		      f,remain = @value_codec.decode_with_length(buf,len)
+		      @value_codec.decode(buffer, f, len)
 		    rescue => e
-		      Logger.error "Error in #{@id} decoder \n #{e.message}\n#{e.backtrace.join(10.chr)}"
+		      Logger.error "Error when decoding field #{f.get_id} \n #{e.message}\n#{e.backtrace.join(10.chr)}"
 		      raise ParsingException.new e.message
 		    end
-        
-        f.set_id(@id)
-        return f,remain
 	    end
     end
-	
-	  def build_field(buf,length)
-	    begin
-	      f,r = decode(buf[0,length])
-	    rescue BufferUnderflow => e
-	      raise ParsingException.new e.message
-	    end
-	    Logger.error "Error remain data in Prefixedlength" if r != ""
-	    return f
-	  end
     
-    def encode(field)
-      l, val = @value_codec.encode_with_length(field)
-      length = @length_codec.encode(Field.new.set_value(l))
-      out = length + val
-      return out
+    def encode(buf, field)
+      out = ""
+      content_buf = ""
+      len = @value_codec.encode(content_buf, field)
+      @length_codec.encode(out, Field.new.set_value(len))
+      out << content_buf
+      buf << out
+      return out.length
     end
   end
 
   class Headerlength < Prefixedlength
-    def initialize(id,header,content,length_path)
+    def initialize(header,header_id,content,content_id,length_path,total_length = false)
+      @header_id = header_id
+      @content_id = content_id
       @path = length_path # length attribute contain the path for length field in header
       @separator = @path.slice!(0).chr # first character contain the separator
-      super(id,header,content)
+      @total_length = total_length # indicate that length in header is equal to (header + content) length
+      super(header,content)
     end
 	
 	  def get_length(header_field)
@@ -66,68 +57,77 @@ module Codec
 	  	  length_field.get_value.to_i
 	  	end
 	  end
-
-	  def decode(buffer)
-	    f = Field.new
-	    f.set_id(@id)
-	    head, buf = @length_codec.decode(buffer)
-	    head.set_id(@length_codec.id)
+    
+	  def decode(buffer, f, length=nil)
+      f.set_value("") # reinit field value
+      buffer = buffer.slice!(0...length) if length && length > 0
+      initial_len = buffer.size
+      head = Field.new(@header_id)
+      content = Field.new(@content_id)
+	    @length_codec.decode(buffer,head)
+      h_len = initial_len - buffer.size
 	    f.add_sub_field(head)
 	    len = get_length(head)
-	    if len == 0
-	      return f,buf
-	    else
-        len -= (buffer.length - buf.length) if @header_length_include
-	      val,remain = @value_codec.decode_with_length(buf,len)
-        val.set_id(@value_codec.id)
-	  	  f.add_sub_field(val)
-        return f,remain
+	    if len > 0
+        len -= h_len if @total_length
+	      @value_codec.decode(buffer, content, len)
+	  	  f.add_sub_field(content)
 	    end
 	  end
     
-    def encode(field)
+    def encode(buf, field)
       # encode content
-      content_field = field.get_sub_field(@value_codec.id)
-      length, content = @value_codec.encode_with_length(content_field)
-      head_field = field.get_sub_field(@length_codec.id)
-      raise EncodingException.new "Missing header for encoding #{@id}" if head_field.empty?
+      content_buf = ""
+      length = 0
+      content = field.get_sub_field(@content_id)
+      length  = @value_codec.encode(content_buf, content) unless content.nil?
+      head = field.get_sub_field(@header_id)
+      raise EncodingException.new "Missing header for encoding #{@id}" if head.empty?
       # update length field in header if length !=0
-      head_field.set_value(length,@path,@separator) if length !=0
+      head.set_value(length,@path,@separator) if length !=0
       # encode header
-      header =  @length_codec.encode(head_field)
-      return header + content
+      head_buf =  ""
+      h_len = @length_codec.encode(head_buf,head)
+      # TODO : optimize computation for header length 
+      if length != 0 && @total_length # re-encode header with total length
+        length = head_buf.length + content_buf.length
+        head.set_value(length,@path,@separator)
+        head_buf = ""
+        @length_codec.encode(head_buf,head)
+      end
+      buf << head_buf
+      buf << content_buf
+      return head_buf.length + content_buf.length
     end
   end  
-
-  class Headerfulllength < Headerlength
-    # TODO : to implement
-  end
   
   class Tagged < Base
-    def initialize(id,tag_codec)
+    def initialize(tag_codec)
       @subCodecs = {}
       @tag_codec = tag_codec
-	    @id = id
     end
-    
-    def decode(buffer)
-      tag,buf = @tag_codec.decode(buffer)
+
+    def decode(buffer, field, length = nil)
+      buffer = buffer.slice!(0...length) if length && length > 0
+      tag = Field.new("TAG")
+      @tag_codec.decode(buffer,tag)
+      field.set_id(tag.get_value.to_s)
       if @subCodecs[tag.get_value.to_s].nil?
-        raise ParsingException.new "Unknown tag #{tag.get_value.to_s} for #{@id} decoder"
+        raise ParsingException.new "Unknown tag #{tag.get_value.to_s} when decoding #{field.get_id}"
       end
-      f,buf = @subCodecs[tag.get_value.to_s].decode(buf)
-      f.set_id(tag.get_value.to_s)
-      return f,buf
+      @subCodecs[tag.get_value.to_s].decode(buffer,field)
     end
     
-    def encode(field)
-      head = Field.new(@tag_codec.id, field.get_id)
-      out = @tag_codec.encode(head)
+    def encode(buffer, field)
+      head = Field.new("tag", field.get_id)
+      out = ""
+      @tag_codec.encode(out, head)
       if @subCodecs[field.get_id].nil?
         raise EncodingException.new "Unknown tag #{field.get_id} for #{@id} encoder"
       end
-      out += @subCodecs[field.get_id].encode(field)
-      return out
+      @subCodecs[field.get_id].encode(out, field)
+      buffer << out
+      return out.length
     end
   end
 end

data/lib/codec/tlv.rb

@@ -1,120 +1,162 @@
 module Codec
   class Tlv < Prefixedlength
-    def initialize(id,length,header,content)
-      super(id,length,content)
-      unless  header.kind_of?(Codec::Base)
-        raise InitializeException," Invalid tag codec for Tlv class"
-      end
+    def initialize(length,header,content)
+      super(length,content)
       @tag_codec = header
       @subCodecs = {}
     end
-    
-    def decode_with_length(buf,length)
-      l = eval_length(buf,length)
-      f,r = decode(buf[0,l])
-      Logger.warn("Remain data in a tlv buffer :[#{r.unpack("H*").first}]") if r.nil? || r.length > 0
-      return f,buf[l,buf.length]
+
+    def check_length(buf,length)
+	    raise "Length is nil" if length.nil?
+      if(length != 0)
+	      if buf.length < length
+	        raise BufferUnderflow, "Not enough data for decoding (#{length}/#{buf.length})"
+	      end
+        return length
+      else
+        return buf.length
+      end    
     end
     
-    def encode(field)
+    def encode(buf, field)
       out = ""
       fields = field.get_value
       fields.each do |sf|
-        out += @tag_codec.encode(Field.new('*',sf.get_id))
+        @tag_codec.encode(out, Field.new('*',sf.get_id))
         if @subCodecs[sf.get_id]
-          content = @subCodecs[sf.get_id].encode(sf)
-          length_buffer = @length_codec.encode(Field.new('*',content.length))
-          out += length_buffer + content
+          content = ""
+          len = @subCodecs[sf.get_id].encode(content, sf)
+          @length_codec.encode(out, Field.new('*',len))
+          out << content
         else
-          out += super(sf)
+          super(out, sf)
         end
       end
-      return out
+      buf << out
+      return out.length
     end
-  
-    def decode(buffer)
-      msg = Field.new(@id)
-      while(buffer.length > 0)
-        begin
-          tag,buffer = @tag_codec.decode(buffer)
-        rescue => e
-          val = Field.new("ERR")
-          val.set_value("[#{buffer.unpack("H*").first}]")
-          msg.add_sub_field(val)
-          Logger.error("in #{@id} tlv codec: #{e.message}\n #{e.backtrace.join(10.chr)}")
-          Logger.error("Decoding failed for #{id} : #{msg.to_yaml}")
-          return msg,""
-        end
-        begin
-          if @subCodecs[tag.get_value.to_s].nil?
-            val,buffer = super(buffer)
+    
+    def decode(buffer, msg, length = nil)
+      unless length.nil?
+        l = check_length(buffer,length)
+        buffer = buffer.slice!(0...l)
+      end
+      
+      tag = Field.new
+      begin
+        until buffer.empty?
+          begin
+            @tag_codec.decode(buffer,tag)
+          rescue
+            raise ParsingException, "Tlv Codec still remaining data but failed to decode tag when decoding field #{msg.get_id}"
+          end
+          Logger.debug { "Decoding tag #{tag.get_value.to_s}"}
+          sf = Field.new(tag.get_value.to_s)
+          subcodec = @subCodecs[tag.get_value.to_s]
+          if subcodec.nil?
+            Logger.debug { "using default codec for tag #{tag.get_value.to_s}"}
+            super(buffer,sf)
           else
-            l,buf = @length_codec.decode(buffer)
-            val,buffer = @subCodecs[tag.get_value.to_s].decode_with_length(buf,l.get_value.to_i)
+            Logger.debug { "using predefined codec for tag #{tag.get_value.to_s}"}
+            len_field = Field.new("len")
+            @length_codec.decode(buffer,len_field)
+            subcodec.decode(buffer,sf,len_field.get_value.to_i)
           end
-        rescue BufferUnderflow => e
-          val = Field.new
-          val.set_value("Buffer underflow when parsing this tag : #{e.message} [#{buffer.unpack("H*").first}]")
-          buffer = ""
-        rescue 
-          val = Field.new
-          val.set_value("Parsing error [#{buffer.unpack("H*").first}]")
-          buffer = ""
+          Logger.debug { "Add field #{sf} to tlv"}
+          msg.add_sub_field(sf)
         end
-        
-        val.set_id(tag.get_value.to_s)
-        msg.add_sub_field(val)
+      rescue BufferUnderflow => e
+        raise ParsingException, "Tlv Codec failed to decode field #{msg.get_id}"
+        val = Field.new
+        val.set_value("Buffer underflow when parsing tlv #{msg.get_id} [#{buffer.unpack("H*").first}]")
+        buffer.clear
+      end
+      unless buffer.empty? || length.nil?
+        Logger.warn("Remain data in a tlv buffer :[#{buffer.unpack("H*").first}]") 
       end
-      return msg,buffer
     end
   end
   
   class Bertlv < Base
-    def initialize(id)
-      @id = id
+  
+    def initialize
       @length = 0
     end
+
+    def decode(buf,msg,length=nil)
+      length ||= buf.length
+      buffer = buf.slice!(0...length)
+      until buffer.empty?
+        sf = Field.new(tag_decode(buffer))
+        val = value_decode(buffer, length_decode(buffer))
+        sf.set_value(val)
+    	  msg.add_sub_field(sf)
+      end
+    end
+    
+    def encode(buf, field)
+      out = ""
+      subfields = field.get_value
+      unless subfields.kind_of?(Array)
+        raise EncodingException, "Invalid field #{field.to_yaml} for BER Tlv encoding"
+      end
+      
+      while subfields.size > 0
+        subfield = subfields.shift
+        out << tag_encode(subfield.get_id)
+        # TODO : Handle value that is not String
+        value = value_encode(subfield.get_value)
+        out << length_encode(value.length)
+        out << value
+      end
+      buf << out
+      return out.length
+    end
+    
+    private    
     
-    def tag_decode(buffer)
-      buf = buffer.dup
+    def tag_decode(buf)
       # removing trailling bytes
-      begin ; b = buf.slice!(0).getbyte(0) ; end while (b == 0 || b == 255)
+      b = 0
+      while (b == 0 || b == 255)
+        b = buf.slice!(0).bytes.first
+      end 
       tag = b.chr
       if (b & 0x1F == 0x1F) 
         begin 
-          nb = buf.slice!(0).getbyte(0)
-    	    tag += nb.chr
+          nb = buf.slice!(0).bytes.first
+    	    tag << nb.chr
     	  end while nb & 0x80 == 0x80
       end
-      return tag.unpack("H*").first.upcase, buf
+      return tag.unpack("H*").first.upcase
     end
 
     def tag_encode(tag)
       buf = [tag].pack("H*")
-      check_tag, remain = tag_decode(buf)
-      if tag != check_tag || remain != ""
+      pack_tag = buf.dup
+      check_tag = tag_decode(buf)
+      unless tag == check_tag && buf.empty?
         raise EncodingException, "Invalid BER tag [#{tag}]"
       end
-      return buf
+      return pack_tag
     end
     
-    def length_decode(buffer)
-     buf = buffer.dup
-     b = buf.slice!(0).getbyte(0)
+    def length_decode(buf)
+     b = buf.slice!(0).bytes.first
      if b & 0x80 == 0x80
-       # Compute lenght of encoding length sample if first byte is 83 then lenth is encode 
+       # Compute lenght of encoding length 
+       # Sample if first byte is 83 then lenth is encode 
        # on 3 bytes
        loencl = b & 0x7F 
-       lb = buf[0,loencl]
-       buf = buf[loencl,buf.length]
+       lb = buf.slice!(0...loencl)
        length = 0
-       while(lb.length > 0)
+       lb.bytes.each do |len_byte|
          length *= 256
-    	   length += lb.slice!(0).getbyte(0)
+    	   length += len_byte
        end
-       return length,buf
+       return length
      else
-       return b,buf
+       return b
      end
     end
 
@@ -123,59 +165,22 @@ module Codec
       if out.length > 127
        raise EncodingException,"Invalid length for BER Tlv #{length}"
       elsif out.length > 1
-        out = (128 + out.length).chr + out
+        out.prepend((128 + out.length).chr)
       end
       return out
     end
     
-    def value_decode(buf,length)
+    def value_decode(buf, length)
       if length > buf.length
         raise BufferUnderflow.new "Not enough data for parsing BER TLV 
            #{@id} length value #{length} remaining only #{buf.length}"
       end
-      value = buf[0,length]
-      buf = buf[length,buf.length]
-      return value.unpack("H*").first.upcase,buf
+      value = buf.slice!(0...length)
+      return value.unpack("H*").first.upcase
     end
   
     def value_encode(unpack_buffer)
       [unpack_buffer].pack("H*")
     end
-    
-    def build_field(buf,length)
-      msg = Field.new(@id)
-      buffer = buf[0,length]
-      while buffer.length > 0
-        tag,buffer = tag_decode(buffer)
-        f = Field.new(tag)
-        value_length,buffer = length_decode(buffer)
-        value, buffer = value_decode(buffer,value_length)
-    	  f.set_value(value)
-    	  msg.add_sub_field(f)
-      end
-      return msg
-    end
-  
-    def decode(buffer)
-      return build_field(buffer,buffer.length),""
-    end
-    
-    def encode(field)
-      out = ""
-      subfields = field.get_value
-      unless subfields.kind_of?(Array)
-        raise EncodingException, "Invalid field #{field.to_yaml} for BER Tlv encoding"
-      end
-      
-      while subfields.size > 0
-        subfield = subfields.shift
-        out += tag_encode(subfield.get_id)
-        # TODO : Handle value that is not String
-        value = value_encode(subfield.get_value)
-        out += length_encode(value.length)
-        out += value
-      end
-      return out
-    end
   end
 end