packetfu 1.1.10 → 1.1.11

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