packetfu 1.1.8 → 1.1.9

data/lib/packetfu/protos/udp/header.rb

@@ -1,107 +1,108 @@
+# -*- coding: binary -*-
 module PacketFu
 
-	# UDPHeader is a complete UDP struct, used in UDPPacket. Many Internet-critical protocols
-	# rely on UDP, such as DNS and World of Warcraft.
-	#
-	# For more on UDP packets, see http://www.networksorcery.com/enp/protocol/udp.htm
-	#
-	# ==== Header Definition
-	#  Int16   :udp_src
-	#  Int16   :udp_dst
-	#  Int16   :udp_len  Default: calculated
-	#  Int16   :udp_sum  Default: 0. Often calculated. 
-	#  String  :body
-	class UDPHeader < Struct.new(:udp_src, :udp_dst, :udp_len, :udp_sum, :body)
+  # UDPHeader is a complete UDP struct, used in UDPPacket. Many Internet-critical protocols
+  # rely on UDP, such as DNS and World of Warcraft.
+  #
+  # For more on UDP packets, see http://www.networksorcery.com/enp/protocol/udp.htm
+  #
+  # ==== Header Definition
+  #  Int16   :udp_src
+  #  Int16   :udp_dst
+  #  Int16   :udp_len  Default: calculated
+  #  Int16   :udp_sum  Default: 0. Often calculated. 
+  #  String  :body
+  class UDPHeader < Struct.new(:udp_src, :udp_dst, :udp_len, :udp_sum, :body)
 
-		include StructFu
+    include StructFu
 
-		def initialize(args={})
-			super(
-				Int16.new(args[:udp_src]),
-				Int16.new(args[:udp_dst]),
-				Int16.new(args[:udp_len] || udp_calc_len),
-				Int16.new(args[:udp_sum]),
-				StructFu::String.new.read(args[:body])
-			)
-		end
+    def initialize(args={})
+      super(
+        Int16.new(args[:udp_src]),
+        Int16.new(args[:udp_dst]),
+        Int16.new(args[:udp_len] || udp_calc_len),
+        Int16.new(args[:udp_sum]),
+        StructFu::String.new.read(args[:body])
+      )
+    end
 
-		# Returns the object in string form.
-		def to_s
-			self.to_a.map {|x| x.to_s}.join
-		end
+    # Returns the object in string form.
+    def to_s
+      self.to_a.map {|x| x.to_s}.join
+    end
 
-		# Reads a string to populate the object.
-		def read(str)
-			force_binary(str)
-			return self if str.nil?
-			self[:udp_src].read(str[0,2])
-			self[:udp_dst].read(str[2,2])
-			self[:udp_len].read(str[4,2])
-			self[:udp_sum].read(str[6,2])
-			self[:body].read(str[8,str.size])
-			self
-		end
+    # Reads a string to populate the object.
+    def read(str)
+      force_binary(str)
+      return self if str.nil?
+      self[:udp_src].read(str[0,2])
+      self[:udp_dst].read(str[2,2])
+      self[:udp_len].read(str[4,2])
+      self[:udp_sum].read(str[6,2])
+      self[:body].read(str[8,str.size])
+      self
+    end
 
-		# Setter for the UDP source port.
-		def udp_src=(i); typecast i; end
-		# Getter for the UDP source port.
-		def udp_src; self[:udp_src].to_i; end
-		# Setter for the UDP destination port.
-		def udp_dst=(i); typecast i; end
-		# Getter for the UDP destination port.
-		def udp_dst; self[:udp_dst].to_i; end
-		# Setter for the length field. Usually should be recalc()'ed instead.
-		def udp_len=(i); typecast i; end
-		# Getter for the length field.
-		def udp_len; self[:udp_len].to_i; end
-		# Setter for the checksum. Usually should be recalc()'ed instad.
-		def udp_sum=(i); typecast i; end
-		# Getter for the checksum.
-		def udp_sum; self[:udp_sum].to_i; end
+    # Setter for the UDP source port.
+    def udp_src=(i); typecast i; end
+    # Getter for the UDP source port.
+    def udp_src; self[:udp_src].to_i; end
+    # Setter for the UDP destination port.
+    def udp_dst=(i); typecast i; end
+    # Getter for the UDP destination port.
+    def udp_dst; self[:udp_dst].to_i; end
+    # Setter for the length field. Usually should be recalc()'ed instead.
+    def udp_len=(i); typecast i; end
+    # Getter for the length field.
+    def udp_len; self[:udp_len].to_i; end
+    # Setter for the checksum. Usually should be recalc()'ed instad.
+    def udp_sum=(i); typecast i; end
+    # Getter for the checksum.
+    def udp_sum; self[:udp_sum].to_i; end
 
-		# Returns the true length of the UDP packet.
-		def udp_calc_len
-			body.to_s.size + 8
-		end
+    # Returns the true length of the UDP packet.
+    def udp_calc_len
+      body.to_s.size + 8
+    end
 
-		# Recalculates calculated fields for UDP.
-		def udp_recalc(args=:all)
-			arg = arg.intern if arg.respond_to? :intern
-			case args
-			when :udp_len
-				self.udp_len = udp_calc_len
-			when :all
-				self.udp_recalc(:udp_len)
-			else
-				raise ArgumentError, "No such field `#{arg}'"
-			end
-		end
+    # Recalculates calculated fields for UDP.
+    def udp_recalc(args=:all)
+      arg = arg.intern if arg.respond_to? :intern
+      case args
+      when :udp_len
+        self.udp_len = udp_calc_len
+      when :all
+        self.udp_recalc(:udp_len)
+      else
+        raise ArgumentError, "No such field `#{arg}'"
+      end
+    end
 
-		# Equivalent to udp_src.to_i
-		def udp_sport
-			self.udp_src
-		end
+    # Equivalent to udp_src.to_i
+    def udp_sport
+      self.udp_src
+    end
 
-		# Equivalent to udp_src=
-		def udp_sport=(arg)
-			self.udp_src=(arg)
-		end
+    # Equivalent to udp_src=
+    def udp_sport=(arg)
+      self.udp_src=(arg)
+    end
 
-		# Equivalent to udp_dst
-		def udp_dport
-			self.udp_dst
-		end
-		
-		# Equivalent to udp_dst=
-		def udp_dport=(arg)
-			self.udp_dst=(arg)
-		end
+    # Equivalent to udp_dst
+    def udp_dport
+      self.udp_dst
+    end
+    
+    # Equivalent to udp_dst=
+    def udp_dport=(arg)
+      self.udp_dst=(arg)
+    end
 
-		# Readability aliases
+    # Readability aliases
 
-		def udp_sum_readable
-			"0x%04x" % udp_sum
-		end
+    def udp_sum_readable
+      "0x%04x" % udp_sum
+    end
 
-	end
+  end
 end

data/lib/packetfu/protos/udp/mixin.rb

@@ -1,7 +1,8 @@
+# -*- coding: binary -*-
 module PacketFu
-	# This Mixin simplifies access to the UDPHeaders. Mix this in with your 
-	# packet interface, and it will add methods that essentially delegate to
-	# the 'udp_header' method (assuming that it is a UDPHeader object)
+  # This Mixin simplifies access to the UDPHeaders. Mix this in with your 
+  # packet interface, and it will add methods that essentially delegate to
+  # the 'udp_header' method (assuming that it is a UDPHeader object)
   module UDPHeaderMixin
     def udp_src=(v); self.udp_header.udp_src= v; end
     def udp_src; self.udp_header.udp_src; end

data/lib/packetfu/structfu.rb

@@ -1,293 +1,294 @@
+# -*- coding: binary -*-
 # StructFu, a nifty way to leverage Ruby's built in Struct class
 # to create meaningful binary data. 
 
 module StructFu
-	
-	# Normally, self.size and self.length will refer to the Struct
-	# size as an array. It's a hassle to redefine, so this introduces some
-	# shorthand to get at the size of the resultant string.
-	def sz
-		self.to_s.size
-	end
-
-	alias len sz
-
-	# Typecast is used mostly by packet header classes, such as IPHeader,
-	# TCPHeader, and the like. It takes an argument, and casts it to the
-	# expected type for that element. 
-	def typecast(i)
-		c = caller[0].match(/.*`([^']+)='/)[1]
-		self[c.intern].read i
-	end
-
-	# Used like typecast(), but specifically for casting Strings to StructFu::Strings.
-	def body=(i)
-		if i.kind_of? ::String
-			typecast(i)
-		elsif i.kind_of? StructFu
-			self[:body] = i
-		elsif i.nil?
-			self[:body] = StructFu::String.new.read("")
-		else
-			raise ArgumentError, "Can't cram a #{i.class} into a StructFu :body"
-		end
-	end
-
-	# Handle deep copies correctly. Marshal in 1.9, re-read myself on 1.8
-	def clone
-		begin
-			Marshal.load(Marshal.dump(self))
-		rescue
-			self.class.new.read(self.to_s)
-		end
-	end
-
-	# Ints all have a value, an endianness, and a default value.
-	# Note that the signedness of Int values are implicit as
-	# far as the subclasses are concerned; to_i and to_f will 
-	# return Integer/Float versions of the input value, instead
-	# of attempting to unpack the pack value. (This can be a useful
-	# hint to other functions).
-	#
-	# ==== Header Definition
-	#
-	#   Fixnum  :value
-	#   Symbol  :endian
-	#   Fixnum  :width
-	#   Fixnum  :default
-	class Int < Struct.new(:value, :endian, :width, :default)
-		alias :v= :value=
-		alias :v :value
-		alias :e= :endian=
-		alias :e :endian
-		alias :w= :width=
-		alias :w :width
-		alias :d= :default=
-		alias :d :default
-
-		# This is a parent class definition and should not be used directly.
-		def to_s
-			raise StandardError, "StructFu::Int#to_s accessed, must be redefined."
-		end
-
-		# Returns the Int as an Integer.
-		def to_i
-			(self.v || self.d).to_i
-		end
-
-		# Returns the Int as a Float.
-		def to_f
-			(self.v || self.d).to_f
-		end
-		
-		def initialize(value=nil, endian=nil, width=nil, default=nil)
-			super(value,endian,width,default=0)
-		end
-
-		# Reads either an Integer or a packed string, and populates the value accordingly.
-		def read(i)
-			self.v = i.kind_of?(Integer) ? i.to_i : i.to_s.unpack(@packstr).first
-			self
-		end
-
-	end
-
-	# Int8 is a one byte value.
-	class Int8 < Int
-
-		def initialize(v=nil)
-			super(v,nil,w=1)
-			@packstr = "C"
-		end
-
-		# Returns a one byte value as a packed string.
-		def to_s
-		 [(self.v || self.d)].pack("C")
-		end
-
-	end
-
-	# Int16 is a two byte value.
-	class Int16 < Int
-		def initialize(v=nil, e=:big)
-			super(v,e,w=2)
-			@packstr = (self.e == :big) ? "n" : "v"
-		end
-
-		# Returns a two byte value as a packed string.
-		def to_s
-			@packstr = (self.e == :big) ? "n" : "v"
-			[(self.v || self.d)].pack(@packstr)
-	 	end
-
-	end
   
-	# Int16be is a two byte value in big-endian format. The endianness cannot be altered.
-	class Int16be < Int16
-		undef :endian=
-	end
-
-	# Int16le is a two byte value in little-endian format. The endianness cannot be altered.
-	class Int16le < Int16
-		undef :endian=
-		def initialize(v=nil, e=:little)
-			super(v,e)
-			@packstr = (self.e == :big) ? "n" : "v"
-		end
-	end
-
-	# Int32 is a four byte value.
-	class Int32 < Int
-		def initialize(v=nil, e=:big)
-			super(v,e,w=4)
-			@packstr = (self.e == :big) ? "N" : "V"
-		end
-
-		# Returns a four byte value as a packed string.
-		def to_s
-			@packstr = (self.e == :big) ? "N" : "V"
-			[(self.v || self.d)].pack(@packstr)
-	 	end
-
-	end
-
-	# Int32be is a four byte value in big-endian format. The endianness cannot be altered.
-	class Int32be < Int32
-		undef :endian=
-	end
-
-	# Int32le is a four byte value in little-endian format. The endianness cannot be altered.
-	class Int32le < Int32
-		undef :endian=
-		def initialize(v=nil, e=:little)
-			super(v,e)
-		end
-	end
-
-	# Strings are just like regular strings, except it comes with a read() function
-	# so that it behaves like other StructFu elements.
-	class String < ::String
-		def read(str)
-			str = str.to_s
-			self.replace str
-			self
-		end
-	end
-
-	# Provides a primitive for creating strings, preceeded by
-	# an Int type of length. By default, a string of length zero with
-	# a one-byte length is presumed.  
-	#
-	# Note that IntStrings aren't used for much, but it seemed like a good idea at the time.
-	class IntString < Struct.new(:int, :string, :mode)
-
-		def initialize(string='',int=Int8,mode=nil)
-			if int < Int
-				super(int.new,string,mode)
-				calc
-			else
-				raise "IntStrings need a StructFu::Int for a length."
-			end
-		end
-
-		# Calculates the size of a string, and sets it as the value.
-		def calc
-			int.v = string.to_s.size
-			self.to_s
-		end
-
-		# Returns the object as a string, depending on the mode set upon object creation.
-		def to_s
-			if mode == :parse
-				"#{int}" + [string].pack("a#{len}")
-			elsif mode == :fix
-				self.int.v = string.size
-				"#{int}#{string}"
-			else
-				"#{int}#{string}"
-			end
-		end
-
-		# By redefining #string=, we can ensure the correct value
-		# is calculated upon assignment. If you'd prefer to have
-		# an incorrect value, use the syntax, obj[:string]="value"
-		# instead. Note, by using the alternate form, you must
-		# #calc before you can trust the int's value. Think of the = 
-		# assignment as "set to equal," while the []= assignment
-		# as "boxing in" the value. Maybe.
-		def string=(s)
-			self[:string] = s
-			calc
-		end
-
-		# Shorthand for querying a length. Note that the usual "length"
-		# and "size" refer to the number of elements of this struct.
-		def len
-			self[:int].value
-		end
-
-		# Override the size, if you must.
-		def len=(i)
-			self[:int].value=i
-		end
-
-		# Read takes a string, assumes an int width as previously
-		# defined upon initialization, but makes no guarantees
-		# the int value isn't lying. You're on your own to test
-		# for that (or use parse() with a :mode set).
-		def read(s)
-			unless s[0,int.width].size == int.width
-				raise StandardError, "String is too short for type #{int.class}"
-			else
-				int.read(s[0,int.width])
-				self[:string] = s[int.width,s.size]
-			end
-			self.to_s
-		end
-
-		# parse() is like read(), except that it interprets the string, either
-		# based on the declared length, or the actual length. Which strategy
-		# is used is dependant on which :mode is set (with self.mode).
-		#
-		# :parse : Read the length, and then read in that many bytes of the string. 
-		# The string may be truncated or padded out with nulls, as dictated by the value.
-		#
-		# :fix   : Skip the length, read the rest of the string, then set the length 
-		# to what it ought to be.
-		#
-		# else   : If neither of these modes are set, just perfom a normal read().
-		# This is the default.
-		def parse(s)
-			unless s[0,int.width].size == int.width
-				raise StandardError, "String is too short for type #{int.class}"
-			else
-				case mode 
-				when :parse
-					int.read(s[0,int.width])
-					self[:string] = s[int.width,int.value]
-					if string.size < int.value
-						self[:string] += ("\x00" * (int.value - self[:string].size))
-					end
-				when :fix
-					self.string = s[int.width,s.size]
-				else
-					return read(s)
-				end
-			end
-			self.to_s
-		end
-
-	end
+  # Normally, self.size and self.length will refer to the Struct
+  # size as an array. It's a hassle to redefine, so this introduces some
+  # shorthand to get at the size of the resultant string.
+  def sz
+    self.to_s.size
+  end
+
+  alias len sz
+
+  # Typecast is used mostly by packet header classes, such as IPHeader,
+  # TCPHeader, and the like. It takes an argument, and casts it to the
+  # expected type for that element. 
+  def typecast(i)
+    c = caller[0].match(/.*`([^']+)='/)[1]
+    self[c.intern].read i
+  end
+
+  # Used like typecast(), but specifically for casting Strings to StructFu::Strings.
+  def body=(i)
+    if i.kind_of? ::String
+      typecast(i)
+    elsif i.kind_of? StructFu
+      self[:body] = i
+    elsif i.nil?
+      self[:body] = StructFu::String.new.read("")
+    else
+      raise ArgumentError, "Can't cram a #{i.class} into a StructFu :body"
+    end
+  end
+
+  # Handle deep copies correctly. Marshal in 1.9, re-read myself on 1.8
+  def clone
+    begin
+      Marshal.load(Marshal.dump(self))
+    rescue
+      self.class.new.read(self.to_s)
+    end
+  end
+
+  # Ints all have a value, an endianness, and a default value.
+  # Note that the signedness of Int values are implicit as
+  # far as the subclasses are concerned; to_i and to_f will 
+  # return Integer/Float versions of the input value, instead
+  # of attempting to unpack the pack value. (This can be a useful
+  # hint to other functions).
+  #
+  # ==== Header Definition
+  #
+  #   Fixnum  :value
+  #   Symbol  :endian
+  #   Fixnum  :width
+  #   Fixnum  :default
+  class Int < Struct.new(:value, :endian, :width, :default)
+    alias :v= :value=
+    alias :v :value
+    alias :e= :endian=
+    alias :e :endian
+    alias :w= :width=
+    alias :w :width
+    alias :d= :default=
+    alias :d :default
+
+    # This is a parent class definition and should not be used directly.
+    def to_s
+      raise StandardError, "StructFu::Int#to_s accessed, must be redefined."
+    end
+
+    # Returns the Int as an Integer.
+    def to_i
+      (self.v || self.d).to_i
+    end
+
+    # Returns the Int as a Float.
+    def to_f
+      (self.v || self.d).to_f
+    end
+    
+    def initialize(value=nil, endian=nil, width=nil, default=nil)
+      super(value,endian,width,default=0)
+    end
+
+    # Reads either an Integer or a packed string, and populates the value accordingly.
+    def read(i)
+      self.v = i.kind_of?(Integer) ? i.to_i : i.to_s.unpack(@packstr).first
+      self
+    end
+
+  end
+
+  # Int8 is a one byte value.
+  class Int8 < Int
+
+    def initialize(v=nil)
+      super(v,nil,w=1)
+      @packstr = "C"
+    end
+
+    # Returns a one byte value as a packed string.
+    def to_s
+     [(self.v || self.d)].pack("C")
+    end
+
+  end
+
+  # Int16 is a two byte value.
+  class Int16 < Int
+    def initialize(v=nil, e=:big)
+      super(v,e,w=2)
+      @packstr = (self.e == :big) ? "n" : "v"
+    end
+
+    # Returns a two byte value as a packed string.
+    def to_s
+      @packstr = (self.e == :big) ? "n" : "v"
+      [(self.v || self.d)].pack(@packstr)
+     end
+
+  end
+  
+  # Int16be is a two byte value in big-endian format. The endianness cannot be altered.
+  class Int16be < Int16
+    undef :endian=
+  end
+
+  # Int16le is a two byte value in little-endian format. The endianness cannot be altered.
+  class Int16le < Int16
+    undef :endian=
+    def initialize(v=nil, e=:little)
+      super(v,e)
+      @packstr = (self.e == :big) ? "n" : "v"
+    end
+  end
+
+  # Int32 is a four byte value.
+  class Int32 < Int
+    def initialize(v=nil, e=:big)
+      super(v,e,w=4)
+      @packstr = (self.e == :big) ? "N" : "V"
+    end
+
+    # Returns a four byte value as a packed string.
+    def to_s
+      @packstr = (self.e == :big) ? "N" : "V"
+      [(self.v || self.d)].pack(@packstr)
+     end
+
+  end
+
+  # Int32be is a four byte value in big-endian format. The endianness cannot be altered.
+  class Int32be < Int32
+    undef :endian=
+  end
+
+  # Int32le is a four byte value in little-endian format. The endianness cannot be altered.
+  class Int32le < Int32
+    undef :endian=
+    def initialize(v=nil, e=:little)
+      super(v,e)
+    end
+  end
+
+  # Strings are just like regular strings, except it comes with a read() function
+  # so that it behaves like other StructFu elements.
+  class String < ::String
+    def read(str)
+      str = str.to_s
+      self.replace str
+      self
+    end
+  end
+
+  # Provides a primitive for creating strings, preceeded by
+  # an Int type of length. By default, a string of length zero with
+  # a one-byte length is presumed.  
+  #
+  # Note that IntStrings aren't used for much, but it seemed like a good idea at the time.
+  class IntString < Struct.new(:int, :string, :mode)
+
+    def initialize(string='',int=Int8,mode=nil)
+      if int < Int
+        super(int.new,string,mode)
+        calc
+      else
+        raise "IntStrings need a StructFu::Int for a length."
+      end
+    end
+
+    # Calculates the size of a string, and sets it as the value.
+    def calc
+      int.v = string.to_s.size
+      self.to_s
+    end
+
+    # Returns the object as a string, depending on the mode set upon object creation.
+    def to_s
+      if mode == :parse
+        "#{int}" + [string].pack("a#{len}")
+      elsif mode == :fix
+        self.int.v = string.size
+        "#{int}#{string}"
+      else
+        "#{int}#{string}"
+      end
+    end
+
+    # By redefining #string=, we can ensure the correct value
+    # is calculated upon assignment. If you'd prefer to have
+    # an incorrect value, use the syntax, obj[:string]="value"
+    # instead. Note, by using the alternate form, you must
+    # #calc before you can trust the int's value. Think of the = 
+    # assignment as "set to equal," while the []= assignment
+    # as "boxing in" the value. Maybe.
+    def string=(s)
+      self[:string] = s
+      calc
+    end
+
+    # Shorthand for querying a length. Note that the usual "length"
+    # and "size" refer to the number of elements of this struct.
+    def len
+      self[:int].value
+    end
+
+    # Override the size, if you must.
+    def len=(i)
+      self[:int].value=i
+    end
+
+    # Read takes a string, assumes an int width as previously
+    # defined upon initialization, but makes no guarantees
+    # the int value isn't lying. You're on your own to test
+    # for that (or use parse() with a :mode set).
+    def read(s)
+      unless s[0,int.width].size == int.width
+        raise StandardError, "String is too short for type #{int.class}"
+      else
+        int.read(s[0,int.width])
+        self[:string] = s[int.width,s.size]
+      end
+      self.to_s
+    end
+
+    # parse() is like read(), except that it interprets the string, either
+    # based on the declared length, or the actual length. Which strategy
+    # is used is dependant on which :mode is set (with self.mode).
+    #
+    # :parse : Read the length, and then read in that many bytes of the string. 
+    # The string may be truncated or padded out with nulls, as dictated by the value.
+    #
+    # :fix   : Skip the length, read the rest of the string, then set the length 
+    # to what it ought to be.
+    #
+    # else   : If neither of these modes are set, just perfom a normal read().
+    # This is the default.
+    def parse(s)
+      unless s[0,int.width].size == int.width
+        raise StandardError, "String is too short for type #{int.class}"
+      else
+        case mode 
+        when :parse
+          int.read(s[0,int.width])
+          self[:string] = s[int.width,int.value]
+          if string.size < int.value
+            self[:string] += ("\x00" * (int.value - self[:string].size))
+          end
+        when :fix
+          self.string = s[int.width,s.size]
+        else
+          return read(s)
+        end
+      end
+      self.to_s
+    end
+
+  end
 
 end
 
 class Struct
 
-	# Monkeypatch for Struct to include some string safety -- anything that uses
-	# Struct is going to presume binary strings anyway.
-	def force_binary(str)
-		PacketFu.force_binary(str)
-	end
+  # Monkeypatch for Struct to include some string safety -- anything that uses
+  # Struct is going to presume binary strings anyway.
+  def force_binary(str)
+    PacketFu.force_binary(str)
+  end
 
 end