packetfu 1.1.9 → 1.1.10

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

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

data/lib/packetfu/protos/hsrp.rb

@@ -12,85 +12,85 @@ require 'packetfu/protos/hsrp/header'
 require 'packetfu/protos/hsrp/mixin'
 
 module PacketFu
-  # HSRPPacket is used to construct HSRP Packets. They contain an EthHeader, an IPHeader, and a UDPHeader.
-  #
-  # == Example
-  #
-  #  hsrp_pkt.new
-  #  hsrp_pkt.hsrp_opcode = 0
-  #  hsrp_pkt.hsrp_state = 16
-  #  hsrp_pkt.hsrp_priority = 254
-  #  hsrp_pkt.hsrp_group = 1
-  #  hsrp_pkt.hsrp_vip = 10.100.100.254
-  #  hsrp_pkt.recalc
-  #  hsrp_pkt.to_f('/tmp/hsrp.pcap')
-  #
-  # == Parameters
-  #
-  #  :eth
-  #   A pre-generated EthHeader object.
-  #  :ip
-  #   A pre-generated IPHeader object.
-  #  :udp
-  #   A pre-generated UDPHeader object.
-  #  :flavor
-  #   TODO: HSRP packets don't tend have any flavor.
-  #  :config
-  #   A hash of return address details, often the output of Utils.whoami?
-  class HSRPPacket < Packet
+	# HSRPPacket is used to construct HSRP Packets. They contain an EthHeader, an IPHeader, and a UDPHeader.
+	#
+	# == Example
+	#
+	#  hsrp_pkt.new
+	#  hsrp_pkt.hsrp_opcode = 0
+	#  hsrp_pkt.hsrp_state = 16
+	#  hsrp_pkt.hsrp_priority = 254
+	#  hsrp_pkt.hsrp_group = 1
+	#  hsrp_pkt.hsrp_vip = 10.100.100.254
+	#  hsrp_pkt.recalc
+	#  hsrp_pkt.to_f('/tmp/hsrp.pcap')
+	#
+	# == Parameters
+	#
+	#  :eth
+	#   A pre-generated EthHeader object.
+	#  :ip
+	#   A pre-generated IPHeader object.
+	#  :udp
+	#   A pre-generated UDPHeader object.
+	#  :flavor
+	#   TODO: HSRP packets don't tend have any flavor.
+	#  :config
+	#   A hash of return address details, often the output of Utils.whoami?
+	class HSRPPacket < Packet
     include ::PacketFu::EthHeaderMixin
     include ::PacketFu::IPHeaderMixin
     include ::PacketFu::UDPHeaderMixin
     include ::PacketFu::HSRPHeaderMixin
 
-    attr_accessor :eth_header, :ip_header, :udp_header, :hsrp_header
+		attr_accessor :eth_header, :ip_header, :udp_header, :hsrp_header
 
-    def self.can_parse?(str)
-      return false unless str.size >= 54
-      return false unless EthPacket.can_parse? str
-      return false unless IPPacket.can_parse? str
-      return false unless UDPPacket.can_parse? str
-      temp_packet = UDPPacket.new
-      temp_packet.read(str)
-      if temp_packet.ip_ttl == 1 and [temp_packet.udp_sport,temp_packet.udp_dport] == [1985,1985] 
-        return true
-      else 
-        return false
-      end
-    end
+		def self.can_parse?(str)
+			return false unless str.size >= 54
+			return false unless EthPacket.can_parse? str
+			return false unless IPPacket.can_parse? str
+			return false unless UDPPacket.can_parse? str
+			temp_packet = UDPPacket.new
+			temp_packet.read(str)
+			if temp_packet.ip_ttl == 1 and [temp_packet.udp_sport,temp_packet.udp_dport] == [1985,1985] 
+				return true
+			else 
+				return false
+			end
+		end
 
-    def read(str=nil, args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-      super(args)
-      self
-    end
+		def read(str=nil, args={})
+			raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
+			@eth_header.read(str)
+			super(args)
+			self
+		end
 
-    def initialize(args={})
-      @eth_header = EthHeader.new(args).read(args[:eth])
-      @ip_header = IPHeader.new(args).read(args[:ip])
-      @ip_header.ip_proto = 0x11
-      @udp_header = UDPHeader.new(args).read(args[:udp])
-      @hsrp_header = HSRPHeader.new(args).read(args[:hsrp])
-      @udp_header.body = @hsrp_header
-      @ip_header.body = @udp_header
-      @eth_header.body = @ip_header
-      @headers = [@eth_header, @ip_header, @udp_header, @hsrp_header]
-      super
-    end
+		def initialize(args={})
+			@eth_header = EthHeader.new(args).read(args[:eth])
+			@ip_header = IPHeader.new(args).read(args[:ip])
+			@ip_header.ip_proto = 0x11
+			@udp_header = UDPHeader.new(args).read(args[:udp])
+			@hsrp_header = HSRPHeader.new(args).read(args[:hsrp])
+			@udp_header.body = @hsrp_header
+			@ip_header.body = @udp_header
+			@eth_header.body = @ip_header
+			@headers = [@eth_header, @ip_header, @udp_header, @hsrp_header]
+			super
+		end
 
-    # Peek provides summary data on packet contents.
-    def peek_format
-      peek_data = ["UH "]
-      peek_data << "%-5d" % self.to_s.size
-      peek_data << "%-16s" % self.hsrp_addr
-      peek_data << "%-4d" % self.hsrp_group
-      peek_data << "%-35s" % self.hsrp_password_readable
-      peek_data << "%-15s" % self.ip_saddr
-      peek_data.join
-    end
+		# Peek provides summary data on packet contents.
+		def peek_format
+			peek_data = ["UH "]
+			peek_data << "%-5d" % self.to_s.size
+			peek_data << "%-16s" % self.hsrp_addr
+			peek_data << "%-4d" % self.hsrp_group
+			peek_data << "%-35s" % self.hsrp_password_readable
+			peek_data << "%-15s" % self.ip_saddr
+			peek_data.join
+		end
 
-  end
+	end
 
 end
 

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

@@ -1,121 +1,121 @@
 # -*- coding: binary -*-
 module PacketFu
-  # HSRPHeader is a complete HSRP struct, used in HSRPPacket. HSRP is typically used for
-  # fault-tolerant default gateway in IP routing environment.
-  #
-  # For more on HSRP packets, see http://www.networksorcery.com/enp/protocol/hsrp.htm
-  #
-  # Submitted by fropert@packetfault.org. Thanks, Francois!
-  #
-  # ==== Header Definition
-  #
-  #   Int8    :hsrp_version      Default: 0     # Version
-  #   Int8    :hsrp_opcode                      # Opcode
-  #   Int8    :hsrp_state                       # State
-  #   Int8    :hsrp_hellotime    Default: 3     # Hello Time
-  #   Int8    :hsrp_holdtime     Default: 10    # Hold Time
-  #   Int8    :hsrp_priority                    # Priority
-  #   Int8    :hsrp_group                       # Group
-  #   Int8    :hsrp_reserved     Default: 0     # Reserved
-  #   String  :hsrp_password                    # Authentication Data
-  #   Octets  :hsrp_vip                         # Virtual IP Address
-  #   String  :body
-  class HSRPHeader < Struct.new(:hsrp_version, :hsrp_opcode, :hsrp_state,
-                  :hsrp_hellotime, :hsrp_holdtime,
-                  :hsrp_priority, :hsrp_group,
-                  :hsrp_reserved, :hsrp_password,
-                  :hsrp_vip, :body)
+	# HSRPHeader is a complete HSRP struct, used in HSRPPacket. HSRP is typically used for
+	# fault-tolerant default gateway in IP routing environment.
+	#
+	# For more on HSRP packets, see http://www.networksorcery.com/enp/protocol/hsrp.htm
+	#
+	# Submitted by fropert@packetfault.org. Thanks, Francois!
+	#
+	# ==== Header Definition
+	#
+	#   Int8    :hsrp_version      Default: 0     # Version
+	#   Int8    :hsrp_opcode                      # Opcode
+	#   Int8    :hsrp_state                       # State
+	#   Int8    :hsrp_hellotime    Default: 3     # Hello Time
+	#   Int8    :hsrp_holdtime     Default: 10    # Hold Time
+	#   Int8    :hsrp_priority                    # Priority
+	#   Int8    :hsrp_group                       # Group
+	#   Int8    :hsrp_reserved     Default: 0     # Reserved
+	#   String  :hsrp_password                    # Authentication Data
+	#   Octets  :hsrp_vip                         # Virtual IP Address
+	#   String  :body
+	class HSRPHeader < Struct.new(:hsrp_version, :hsrp_opcode, :hsrp_state,
+								  :hsrp_hellotime, :hsrp_holdtime,
+								  :hsrp_priority, :hsrp_group,
+								  :hsrp_reserved, :hsrp_password,
+								  :hsrp_vip, :body)
 
-    include StructFu
+		include StructFu
 
-    def initialize(args={})
-      super(
-        Int8.new(args[:hsrp_version] || 0),
-        Int8.new(args[:hsrp_opcode]),
-        Int8.new(args[:hsrp_state]),
-        Int8.new(args[:hsrp_hellotime] || 3),
-        Int8.new(args[:hsrp_holdtime] || 10),
-        Int8.new(args[:hsrp_priority]),
-        Int8.new(args[:hsrp_group]),
-        Int8.new(args[:hsrp_reserved] || 0),
-        StructFu::String.new.read(args[:hsrp_password] || "cisco\x00\x00\x00"),
-        Octets.new.read(args[:hsrp_vip] || ("\x00" * 4)),
-        StructFu::String.new.read(args[:body])
-      )
-    end
+		def initialize(args={})
+			super(
+				Int8.new(args[:hsrp_version] || 0),
+				Int8.new(args[:hsrp_opcode]),
+				Int8.new(args[:hsrp_state]),
+				Int8.new(args[:hsrp_hellotime] || 3),
+				Int8.new(args[:hsrp_holdtime] || 10),
+				Int8.new(args[:hsrp_priority]),
+				Int8.new(args[:hsrp_group]),
+				Int8.new(args[:hsrp_reserved] || 0),
+				StructFu::String.new.read(args[:hsrp_password] || "cisco\x00\x00\x00"),
+				Octets.new.read(args[:hsrp_vip] || ("\x00" * 4)),
+				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[:hsrp_version].read(str[0,1])
-      self[:hsrp_opcode].read(str[1,1])
-      self[:hsrp_state].read(str[2,1])
-      self[:hsrp_hellotime].read(str[3,1])
-      self[:hsrp_holdtime].read(str[4,1])
-      self[:hsrp_priority].read(str[5,1])
-      self[:hsrp_group].read(str[6,1])
-      self[:hsrp_reserved].read(str[7,1])
-      self[:hsrp_password].read(str[8,8])
-      self[:hsrp_vip].read(str[16,4])
-      self[:body].read(str[20,str.size]) if str.size > 20
-      self
-    end
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			self[:hsrp_version].read(str[0,1])
+			self[:hsrp_opcode].read(str[1,1])
+			self[:hsrp_state].read(str[2,1])
+			self[:hsrp_hellotime].read(str[3,1])
+			self[:hsrp_holdtime].read(str[4,1])
+			self[:hsrp_priority].read(str[5,1])
+			self[:hsrp_group].read(str[6,1])
+			self[:hsrp_reserved].read(str[7,1])
+			self[:hsrp_password].read(str[8,8])
+			self[:hsrp_vip].read(str[16,4])
+			self[:body].read(str[20,str.size]) if str.size > 20
+			self
+		end
 
-    # Setter for the type.
-    def hsrp_version=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_version; self[:hsrp_version].to_i; end
-    # Setter for the type.
-    def hsrp_opcode=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_opcode; self[:hsrp_opcode].to_i; end
-    # Setter for the type.
-    def hsrp_state=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_state; self[:hsrp_state].to_i; end
-    # Setter for the type.
-    def hsrp_hellotime=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_hellotime; self[:hsrp_hellotime].to_i; end
-    # Setter for the type.
-    def hsrp_holdtime=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_holdtime; self[:hsrp_holdtime].to_i; end
-    # Setter for the type.
-    def hsrp_priority=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_priority; self[:hsrp_priority].to_i; end
-    # Setter for the type.
-    def hsrp_group=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_group; self[:hsrp_group].to_i; end
-    # Setter for the type.
-    def hsrp_reserved=(i); typecast i; end
-    # Getter for the type.
-    def hsrp_reserved; self[:hsrp_reserved].to_i; end
+		# Setter for the type.
+		def hsrp_version=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_version; self[:hsrp_version].to_i; end
+		# Setter for the type.
+		def hsrp_opcode=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_opcode; self[:hsrp_opcode].to_i; end
+		# Setter for the type.
+		def hsrp_state=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_state; self[:hsrp_state].to_i; end
+		# Setter for the type.
+		def hsrp_hellotime=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_hellotime; self[:hsrp_hellotime].to_i; end
+		# Setter for the type.
+		def hsrp_holdtime=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_holdtime; self[:hsrp_holdtime].to_i; end
+		# Setter for the type.
+		def hsrp_priority=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_priority; self[:hsrp_priority].to_i; end
+		# Setter for the type.
+		def hsrp_group=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_group; self[:hsrp_group].to_i; end
+		# Setter for the type.
+		def hsrp_reserved=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_reserved; self[:hsrp_reserved].to_i; end
 
-    def hsrp_addr=(addr)
-      self[:hsrp_vip].read_quad(addr)
-    end
+		def hsrp_addr=(addr)
+			self[:hsrp_vip].read_quad(addr)
+		end
 
-    # Returns a more readable IP source address.
-    def hsrp_addr
-      self[:hsrp_vip].to_x
-    end
+		# Returns a more readable IP source address.
+		def hsrp_addr
+			self[:hsrp_vip].to_x
+		end
 
-    # Readability aliases
+		# Readability aliases
 
-    alias :hsrp_vip_readable :hsrp_addr
+		alias :hsrp_vip_readable :hsrp_addr
 
-    def hsrp_password_readable
-      hsrp_password.to_s.inspect
-    end
+		def hsrp_password_readable
+			hsrp_password.to_s.inspect
+		end
 
-  end
+	end
 end

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

@@ -1,32 +1,32 @@
 # -*- coding: binary -*-
 module PacketFu
-  # This Mixin simplifies access to the HSRPHeaders. Mix this in with your 
-  # packet interface, and it will add methods that essentially delegate to
-  # the 'hsrp_header' method (assuming that it is a HSRPHeader object)
-  module HSRPHeaderMixin
-    def hsrp_version=(v); self.hsrp_header.hsrp_version= v; end
-    def hsrp_version; self.hsrp_header.hsrp_version; end
-    def hsrp_opcode=(v); self.hsrp_header.hsrp_opcode= v; end
-    def hsrp_opcode; self.hsrp_header.hsrp_opcode; end
-    def hsrp_state=(v); self.hsrp_header.hsrp_state= v; end
-    def hsrp_state; self.hsrp_header.hsrp_state; end
-    def hsrp_hellotime=(v); self.hsrp_header.hsrp_hellotime= v; end
-    def hsrp_hellotime; self.hsrp_header.hsrp_hellotime; end
-    def hsrp_holdtime=(v); self.hsrp_header.hsrp_holdtime= v; end
-    def hsrp_holdtime; self.hsrp_header.hsrp_holdtime; end
-    def hsrp_priority=(v); self.hsrp_header.hsrp_priority= v; end
-    def hsrp_priority; self.hsrp_header.hsrp_priority; end
-    def hsrp_group=(v); self.hsrp_header.hsrp_group= v; end
-    def hsrp_group; self.hsrp_header.hsrp_group; end
-    def hsrp_reserved=(v); self.hsrp_header.hsrp_reserved= v; end
-    def hsrp_reserved; self.hsrp_header.hsrp_reserved; end
-    def hsrp_addr=(v); self.hsrp_header.hsrp_addr= v; end
-    def hsrp_addr; self.hsrp_header.hsrp_addr; end
-    def hsrp_vip_readable; self.hsrp_header.hsrp_vip_readable; end
-    def hsrp_password_readable; self.hsrp_header.hsrp_password_readable; end
-    def hsrp_password; self.hsrp_header.hsrp_password; end
-    def hsrp_password=(v); self.hsrp_header.hsrp_password= v; end
-    def hsrp_vip; self.hsrp_header.hsrp_vip; end
-    def hsrp_vip=(v); self.hsrp_header.hsrp_vip= v; end
-  end
+	# This Mixin simplifies access to the HSRPHeaders. Mix this in with your 
+	# packet interface, and it will add methods that essentially delegate to
+	# the 'hsrp_header' method (assuming that it is a HSRPHeader object)
+	module HSRPHeaderMixin
+		def hsrp_version=(v); self.hsrp_header.hsrp_version= v; end
+		def hsrp_version; self.hsrp_header.hsrp_version; end
+		def hsrp_opcode=(v); self.hsrp_header.hsrp_opcode= v; end
+		def hsrp_opcode; self.hsrp_header.hsrp_opcode; end
+		def hsrp_state=(v); self.hsrp_header.hsrp_state= v; end
+		def hsrp_state; self.hsrp_header.hsrp_state; end
+		def hsrp_hellotime=(v); self.hsrp_header.hsrp_hellotime= v; end
+		def hsrp_hellotime; self.hsrp_header.hsrp_hellotime; end
+		def hsrp_holdtime=(v); self.hsrp_header.hsrp_holdtime= v; end
+		def hsrp_holdtime; self.hsrp_header.hsrp_holdtime; end
+		def hsrp_priority=(v); self.hsrp_header.hsrp_priority= v; end
+		def hsrp_priority; self.hsrp_header.hsrp_priority; end
+		def hsrp_group=(v); self.hsrp_header.hsrp_group= v; end
+		def hsrp_group; self.hsrp_header.hsrp_group; end
+		def hsrp_reserved=(v); self.hsrp_header.hsrp_reserved= v; end
+		def hsrp_reserved; self.hsrp_header.hsrp_reserved; end
+		def hsrp_addr=(v); self.hsrp_header.hsrp_addr= v; end
+		def hsrp_addr; self.hsrp_header.hsrp_addr; end
+		def hsrp_vip_readable; self.hsrp_header.hsrp_vip_readable; end
+		def hsrp_password_readable; self.hsrp_header.hsrp_password_readable; end
+		def hsrp_password; self.hsrp_header.hsrp_password; end
+		def hsrp_password=(v); self.hsrp_header.hsrp_password= v; end
+		def hsrp_vip; self.hsrp_header.hsrp_vip; end
+		def hsrp_vip=(v); self.hsrp_header.hsrp_vip= v; end
+	end
 end