packetgen 3.1.3 → 3.1.8

data/lib/packetgen/proto.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
-
 require 'socket'
 
 module PacketGen

data/lib/packetgen/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
@@ -10,6 +12,7 @@ module PacketGen
 end
 
 require_relative 'types/length_from'
+require_relative 'types/fieldable'
 require_relative 'types/int'
 require_relative 'types/enum'
 require_relative 'types/string'

data/lib/packetgen/types/abstract_tlv.rb

@@ -1,16 +1,16 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
-
 module PacketGen
   module Types
     # This class is an abstract class to define type-length-value data.
     #
-    # This class supersede {TLV} class, which is not well defined on some corner
+    # This class supersedes {TLV} class, which is not well defined on some corner
     # cases.
     #
     # ===Usage
@@ -33,7 +33,7 @@ module PacketGen
     #   tlv.value       #=> "abcd"
     #
     # ===Advanced usage
-    # Each field's type may be change at generating TLV class:
+    # Each field's type may be changed at generating TLV class:
     #   MyTLV = PacketGen::Types::AbstractTLV.create(type_class: PacketGen::Types::Int16,
     #                                                length_class: PacketGen::Types::Int16,
     #                                                value_class: PacketGen::Header::IP::Addr)
@@ -58,9 +58,12 @@ module PacketGen
     # @since 3.1.0
     # @since 3.1.1 add +:aliases+ keyword to {#initialize}
     class AbstractTLV < Types::Fields
+      include Fieldable
+
       class <<self
         # @return [Hash]
         attr_accessor :aliases
+        attr_accessor :header_in_length
       end
       self.aliases = {}
 
@@ -68,12 +71,17 @@ module PacketGen
       # @param [Class] type_class Class to use for +type+
       # @param [Class] length_class Class to use for +length+
       # @param [Class] value_class Class to use for +value+
+      # @param [Boolean] header_in_length if +true +, +type+ and +length+ fields are
+      #   included in length
       # @return [Class]
-      def self.create(type_class: Int8Enum, length_class: Int8, value_class: String, aliases: {})
+      # @since 3.1.4 Add +header_in_length+ parameter
+      def self.create(type_class: Int8Enum, length_class: Int8, value_class: String,
+                      aliases: {}, header_in_length: false)
         raise Error, '.create cannot be called on a subclass of PacketGen::Types::AbstractTLV' unless self.equal? AbstractTLV
 
         klass = Class.new(self)
         klass.aliases = aliases
+        klass.header_in_length = header_in_length
 
         if type_class < Enum
           klass.define_field :type, type_class, enum: {}
@@ -117,6 +125,7 @@ module PacketGen
       # @option options [Integer] :length
       # @option options [Object] :value
       def initialize(options={})
+        @header_in_length = self.class.header_in_length
         self.class.aliases.each do |al, orig|
           options[orig] = options[al] if options.key?(al)
         end
@@ -136,7 +145,7 @@ module PacketGen
         idx += self[:type].sz
         self[:length].read str[idx, self[:length].sz]
         idx += self[:length].sz
-        self[:value].read str[idx, self.length]
+        self[:value].read str[idx, real_length]
         self
       end
 
@@ -147,6 +156,7 @@ module PacketGen
       def value=(val)
         self[:value].from_human val
         self.length = self[:value].sz
+        self.length += self[:type].sz + self[:length].sz if @header_in_length
         val
       end
 
@@ -161,7 +171,17 @@ module PacketGen
       # @return [String]
       def to_human
         my_value = self[:value].is_a?(String) ? self[:value].inspect : self[:value].to_human
-        "type:%s,length:%u,value:#{my_value}" % [human_type, length]
+        'type:%s,length:%u,value:%s' % [human_type, length, my_value]
+      end
+
+      private
+
+      def real_length
+        if @header_in_length
+          self.length - self[:type].sz - self[:length].sz
+        else
+          self.length
+        end
       end
     end
   end

data/lib/packetgen/types/array.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
-
 require 'forwardable'
 
 module PacketGen
@@ -27,6 +27,9 @@ module PacketGen
     # @author Sylvain Daubert
     class Array
       extend Forwardable
+      include Enumerable
+      include Fieldable
+      include LengthFrom
 
       # @!method [](index)
       #   Return the element at +index+.
@@ -54,9 +57,6 @@ module PacketGen
       def_delegators :@array, :[], :clear, :each, :empty?, :first, :last, :size
       alias length size
 
-      include Enumerable
-      include LengthFrom
-
       # Separator used in {#to_human}.
       # May be ovverriden by subclasses
       HUMAN_SEPARATOR = ','
@@ -106,7 +106,7 @@ module PacketGen
       # @return [void]
       def clear!
         @array.clear
-        @counter.read(0) if @counter
+        @counter&.read(0)
       end
 
       # Delete an object from this array. Update associated counter if any
@@ -150,7 +150,7 @@ module PacketGen
       # @return [Array] self
       def <<(obj)
         push obj
-        @counter.read(@counter.to_i + 1) if @counter
+        @counter&.read(@counter.to_i + 1)
         self
       end
 
@@ -160,14 +160,11 @@ module PacketGen
       def read(str)
         clear
         return self if str.nil?
-        return self if @counter && @counter.to_i.zero?
+        return self if @counter&.to_i&.zero?
 
         str = read_with_length_from(str)
-        klass = self.class.set_of_klass
         until str.empty?
-          obj = klass.new.read(str)
-          real_klass = real_type(obj)
-          obj = real_klass.new.read(str) unless real_klass == klass
+          obj = create_object_from_str(str)
           @array << obj
           str.slice!(0, obj.sz)
           break if @counter && self.size == @counter.to_i
@@ -203,9 +200,7 @@ module PacketGen
 
       def record_from_hash(hsh)
         obj_klass = self.class.set_of_klass
-        unless obj_klass
-          raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of'
-        end
+        raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of' unless obj_klass
 
         obj = obj_klass.new(hsh) if obj_klass
         klass = real_type(obj)
@@ -215,6 +210,18 @@ module PacketGen
       def real_type(obj)
         obj.class
       end
+
+      def create_object_from_str(str)
+        klass = self.class.set_of_klass
+        obj = klass.new.read(str)
+        real_klass = real_type(obj)
+
+        if real_klass == klass
+          obj
+        else
+          real_klass.new.read(str)
+        end
+      end
     end
 
     # Specialized array to handle serie of {Int8}.

data/lib/packetgen/types/cstring.rb

@@ -1,20 +1,35 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
+require 'forwardable'
 
 module PacketGen
   module Types
     # This class handles null-terminated strings (aka C strings).
     # @author Sylvain Daubert
-    class CString < ::String
+    # @since 3.1.6 no more a subclass or regular String
+    class CString
+      extend Forwardable
+      include Fieldable
+
+      def_delegators :@string, :[], :length, :size, :inspect, :==,
+                     :unpack, :force_encoding, :encoding, :index, :empty?,
+                     :encode, :slice, :slice!
+
+      # @return [::String]
+      attr_reader :string
+      # @return [Integer]
+      attr_reader :static_length
+
       # @param [Hash] options
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        super()
+        register_internal_string(+'')
         @static_length = options[:static_length]
       end
 
@@ -22,38 +37,49 @@ module PacketGen
       # @return [String] self
       def read(str)
         s = str.to_s
-        s = s[0, @static_length] if @static_length.is_a? Integer
-        idx = s.index(0.chr)
-        s = s[0, idx] unless idx.nil?
-        self.replace s
+        s = s[0, static_length] if static_length?
+        register_internal_string s
+        remove_null_character
         self
       end
 
       # get null-terminated string
       # @return [String]
       def to_s
-        if defined?(@static_length) && @static_length.is_a?(Integer)
-          if self.size >= @static_length
-            s = self[0, @static_length]
-            s[-1] = "\x00".encode(s.encoding)
-            PacketGen.force_binary s
-          else
-            PacketGen.force_binary(self + "\0" * (@static_length - self.length))
-          end
+        if static_length?
+          s = string[0, static_length - 1]
+          s << "\x00" * (static_length - s.length)
         else
-          PacketGen.force_binary(self + +"\x00".encode(self.encoding))
+          s = "#{string}\x00"
         end
+        PacketGen.force_binary(s)
+      end
+
+      # Append the given string to CString
+      # @param [#to_s] str
+      # @return [self]
+      def <<(str)
+        @string << str.to_s
+        remove_null_character
+        self
       end
 
       # @return [Integer]
       def sz
-        if @static_length.is_a? Integer
-          @static_length
+        if static_length?
+          static_length
         else
           to_s.size
         end
       end
 
+      # Say if a static length is defined
+      # @return [Boolean]
+      # @since 3.1.6
+      def static_length?
+        !static_length.nil?
+      end
+
       # Populate CString from a human readable string
       # @param [String] str
       # @return [self]
@@ -63,8 +89,19 @@ module PacketGen
 
       # @return [String]
       def to_human
-        idx = self.index(+"\x00".encode(self.encoding)) || self.sz
-        self[0, idx]
+        string
+      end
+
+      private
+
+      def register_internal_string(str)
+        @string = str
+        PacketGen.force_binary(@string)
+      end
+
+      def remove_null_character
+        idx = string.index(0.chr)
+        register_internal_string(string[0, idx]) unless idx.nil?
       end
     end
   end

data/lib/packetgen/types/enum.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
-
 module PacketGen
   module Types
     # @abstract Base enum class to handle binary integers with limited
@@ -55,6 +55,7 @@ module PacketGen
                  nil
                when ::String
                  raise ArgumentError, "#{value.inspect} not in enumeration" unless @enum.key? value
+
                  @enum[value]
                else
                  value.to_i
@@ -70,6 +71,10 @@ module PacketGen
       def to_human
         @enum.key(to_i) || "<unknown:#{@value}>"
       end
+
+      def format_inspect
+        format_str % [to_human, to_i]
+      end
     end
 
     # Enumeration on one byte. See {Enum}.

data/lib/packetgen/types/fieldable.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Types
+    # Mixin to define minimal API for a class to be embbeded as a field in
+    # {Fields} type.
+    #
+    # == Optional methods
+    # These methods may, optionally, be defined by fieldable types:
+    # * +from_human+ to load data from a human-readable string.
+    # @author Sylvain Daubert
+    # @since 3.1.6
+    module Fieldable
+      # Get type name
+      # @return [String]
+      def type_name
+        self.class.to_s.split('::').last
+      end
+
+      # rubocop:disable Lint/UselessMethodDefinition
+      # These methods are defined for documentation.
+
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Fields] self
+      # @abstract subclass should overload it.
+      def read(str)
+        super
+      end
+
+      # Return object as a binary string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_s
+        super
+      end
+
+      # Size of object as binary string
+      # @return [Integer]
+      def sz
+        to_s.size
+      end
+
+      # Return a human-readbale string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_human
+        super
+      end
+
+      # rubocop:enable Lint/UselessMethodDefinition
+
+      # Format object when inspecting a {Field} object
+      # @return [String]
+      def format_inspect
+        to_human
+      end
+    end
+  end
+end