packetfu 1.1.10 → 1.1.11

data/test/test_pcap.rb

@@ -1,208 +1,210 @@
 #!/usr/bin/env ruby
+# -*- coding: binary -*-
+
 require 'test/unit'
 $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class PcapHeaderTest < Test::Unit::TestCase
-	include PacketFu
-	def setup
-		@file = File.open('sample.pcap') {|f| f.read}
-		@file.force_encoding "binary" if @file.respond_to? :force_encoding
-		@file_magic = @file[0,4]
-		@file_header = @file[0,24]
-	end
-
-	def test_header_size
-		assert_equal(24, PcapHeader.new.sz)
-		assert_equal(24, PcapHeader.new.sz)
-	end
-
-	# If this fails, the rest is pretty much for naught.
-	def test_read_file
-		assert_equal("\xd4\xc3\xb2\xa1", @file_magic) # yep, it's libpcap.
-	end
-
-	def test_endian_magic
-		p = PcapHeader.new # usual case
-		assert_equal(@file_magic, p.to_s[0,4]) 
-		p = PcapHeader.new(:endian => :big)
-		assert_equal("\xa1\xb2\xc3\xd4", p.to_s[0,4])
-	end
-
-	def test_header
-		p = PcapHeader.new
-		assert_equal(@file_header, p.to_s[0,24])
-		p = PcapHeader.new(:endian => :big)
-		assert_not_equal(@file_header, p.to_s[0,24])
-		# We want to ensure our endianness is little or big.
-		assert_raise(ArgumentError) {PcapHeader.new(:endian => :just_right)}
-	end
-
-	def test_header_read
-		p = PcapHeader.new
-		p.read @file
-		assert_equal(@file_header,p.to_s)
-	end
+  include PacketFu
+  def setup
+    @file = File.open('sample.pcap') {|f| f.read}
+    @file.force_encoding "binary" if @file.respond_to? :force_encoding
+    @file_magic = @file[0,4]
+    @file_header = @file[0,24]
+  end
+
+  def test_header_size
+    assert_equal(24, PcapHeader.new.sz)
+    assert_equal(24, PcapHeader.new.sz)
+  end
+
+  # If this fails, the rest is pretty much for naught.
+  def test_read_file
+    assert_equal("\xd4\xc3\xb2\xa1", @file_magic) # yep, it's libpcap.
+  end
+
+  def test_endian_magic
+    p = PcapHeader.new # usual case
+    assert_equal(@file_magic, p.to_s[0,4]) 
+    p = PcapHeader.new(:endian => :big)
+    assert_equal("\xa1\xb2\xc3\xd4", p.to_s[0,4])
+  end
+
+  def test_header
+    p = PcapHeader.new
+    assert_equal(@file_header, p.to_s[0,24])
+    p = PcapHeader.new(:endian => :big)
+    assert_not_equal(@file_header, p.to_s[0,24])
+    # We want to ensure our endianness is little or big.
+    assert_raise(ArgumentError) {PcapHeader.new(:endian => :just_right)}
+  end
+
+  def test_header_read
+    p = PcapHeader.new
+    p.read @file
+    assert_equal(@file_header,p.to_s)
+  end
 
 end
 
 class TimestampTest < Test::Unit::TestCase
-	include PacketFu
-	def setup
-		@file = File.open('sample.pcap') {|f| f.read}
-		@ts = @file[24,8]
-	end
-
-	def test_timestamp_size
-		assert_equal(3, Timestamp.new.size) # Number of elements
-		assert_equal(8, Timestamp.new.sz) # Length of the string (in PacketFu)
-	end
-
-	def test_timestamp_read
-		t = Timestamp.new
-		t.read(@ts)
-		assert_equal(@ts, t.to_s)
-	end
+  include PacketFu
+  def setup
+    @file = File.open('sample.pcap') {|f| f.read}
+    @ts = @file[24,8]
+  end
+
+  def test_timestamp_size
+    assert_equal(3, Timestamp.new.size) # Number of elements
+    assert_equal(8, Timestamp.new.sz) # Length of the string (in PacketFu)
+  end
+
+  def test_timestamp_read
+    t = Timestamp.new
+    t.read(@ts)
+    assert_equal(@ts, t.to_s)
+  end
 end
 
 class PcapPacketTest < Test::Unit::TestCase
-	include PacketFu
-	def setup
-		@file = File.open('sample.pcap') {|f| f.read}
-		@file.force_encoding "binary" if @file.respond_to? :force_encoding
-		@header = @file[0,24]
-		@packet = @file[24,100] # pkt is 78 bytes + 16 bytes pcap hdr == 94
-	end
-
-	def test_pcappacket_read
-		p = PcapPacket.new :endian => :little
-		p.read(@packet)
-		assert_equal(78,@packet[8,4].unpack("V").first)
-		assert_equal(@packet[8,4].unpack("V").first,p[:incl_len].to_i)
-		assert_equal(@packet[0,94],p.to_s)
-	end
+  include PacketFu
+  def setup
+    @file = File.open('sample.pcap') {|f| f.read}
+    @file.force_encoding "binary" if @file.respond_to? :force_encoding
+    @header = @file[0,24]
+    @packet = @file[24,100] # pkt is 78 bytes + 16 bytes pcap hdr == 94
+  end
+
+  def test_pcappacket_read
+    p = PcapPacket.new :endian => :little
+    p.read(@packet)
+    assert_equal(78,@packet[8,4].unpack("V").first)
+    assert_equal(@packet[8,4].unpack("V").first,p[:incl_len].to_i)
+    assert_equal(@packet[0,94],p.to_s)
+  end
 
 end
 
 class PcapPacketsTest < Test::Unit::TestCase
 
-	include PacketFu
-	def setup
-		@file = File.open('sample.pcap') {|f| f.read}
-	end
+  include PacketFu
+  def setup
+    @file = File.open('sample.pcap') {|f| f.read}
+  end
 
-	def test_pcappackets_read
-		p = PcapPackets.new
-		p.read @file
-		assert_equal(11,p.size)
-		assert_equal(@file[24,@file.size],p.to_s)
-	end
+  def test_pcappackets_read
+    p = PcapPackets.new
+    p.read @file
+    assert_equal(11,p.size)
+    assert_equal(@file[24,@file.size],p.to_s)
+  end
 
 end
 
 class PcapFileTest < Test::Unit::TestCase
-	require 'digest/md5'
-
-	include PacketFu
-	def setup
-		@file = File.open('sample.pcap') {|f| f.read}
-		@md5 = '1be3b5082bb135c6f22de8801feb3495'
-	end
-
-	def test_pcapfile_read
-		p = PcapFile.new
-		p.read @file
-		assert_equal(3,p.size)
-		assert_equal(@file.size, p.sz)
-		assert_equal(@file, p.to_s)
-	end
-
-	def test_pcapfile_file_to_array
-		p = PcapFile.new.file_to_array(:filename => 'sample.pcap')
-		assert_equal(@md5.downcase, Digest::MD5.hexdigest(@file).downcase)
-		assert_instance_of(Array, p)
-		assert_instance_of(String, p[0])
-		assert_equal(11,p.size)
-		assert_equal(78,p[0].size)
-		assert_equal(94,p[1].size)
-		assert_equal(74,p[10].size)
-	end
-
-	def test_pcapfile_read_and_write
-		File.unlink('out.pcap') if File.exists? 'out.pcap'
-		p = PcapFile.new
-		p.read @file
-		p.to_file(:filename => 'out.pcap')
-		@newfile = File.open('out.pcap') {|f| f.read(f.stat.size)}
-		@newfile.force_encoding "binary" if @newfile.respond_to? :force_encoding
-		assert_equal(@file, @newfile)
-		p.to_file(:filename => 'out.pcap', :append => true)
-		packet_array = PcapFile.new.f2a(:filename => 'out.pcap')
-		assert_equal(22, packet_array.size)
-	end
-
-	def test_pcapfile_write_after_recalc
-		File.unlink('out.pcap') if File.exists? 'out.pcap'
-		pcaps = PcapFile.new.file_to_array(:filename => 'sample.pcap')
-		pcaps.each {|pkt|
-			p = Packet.parse pkt
-			p.recalc
-			p.to_f('out.pcap','a')
-		}
-		packet_array = PcapFile.new.f2a(:filename => 'out.pcap')
-		assert_equal(11, packet_array.size)
-		File.unlink('out.pcap')
-	end
-
-	def test_pcapfile_read_and_write_timestamps
-		File.unlink('out.pcap') if File.exists? 'out.pcap'
-		pf = PcapFile.new
-		arr = pf.file_to_array(:filename => 'sample.pcap')
-		assert_equal(11, arr.size)
-		pf = PcapFile.new
-		pf.a2f(:array => arr, :f => 'out.pcap', :ts_inc => 4, 
-					 :timestamp => Time.now.to_i - 1_000_000)
-		diff_time = pf.body[0].timestamp.sec.to_i - pf.body[1].timestamp.sec.to_i
-		assert_equal(-4, diff_time)
-		File.unlink('out.pcap')
-	end
+  require 'digest/md5'
+
+  include PacketFu
+  def setup
+    @file = File.open('sample.pcap') {|f| f.read}
+    @md5 = '1be3b5082bb135c6f22de8801feb3495'
+  end
+
+  def test_pcapfile_read
+    p = PcapFile.new
+    p.read @file
+    assert_equal(3,p.size)
+    assert_equal(@file.size, p.sz)
+    assert_equal(@file, p.to_s)
+  end
+
+  def test_pcapfile_file_to_array
+    p = PcapFile.new.file_to_array(:filename => 'sample.pcap')
+    assert_equal(@md5.downcase, Digest::MD5.hexdigest(@file).downcase)
+    assert_instance_of(Array, p)
+    assert_instance_of(String, p[0])
+    assert_equal(11,p.size)
+    assert_equal(78,p[0].size)
+    assert_equal(94,p[1].size)
+    assert_equal(74,p[10].size)
+  end
+
+  def test_pcapfile_read_and_write
+    File.unlink('out.pcap') if File.exists? 'out.pcap'
+    p = PcapFile.new
+    p.read @file
+    p.to_file(:filename => 'out.pcap')
+    @newfile = File.open('out.pcap') {|f| f.read(f.stat.size)}
+    @newfile.force_encoding "binary" if @newfile.respond_to? :force_encoding
+    assert_equal(@file, @newfile)
+    p.to_file(:filename => 'out.pcap', :append => true)
+    packet_array = PcapFile.new.f2a(:filename => 'out.pcap')
+    assert_equal(22, packet_array.size)
+  end
+
+  def test_pcapfile_write_after_recalc
+    File.unlink('out.pcap') if File.exists? 'out.pcap'
+    pcaps = PcapFile.new.file_to_array(:filename => 'sample.pcap')
+    pcaps.each {|pkt|
+      p = Packet.parse pkt
+      p.recalc
+      p.to_f('out.pcap','a')
+    }
+    packet_array = PcapFile.new.f2a(:filename => 'out.pcap')
+    assert_equal(11, packet_array.size)
+    File.unlink('out.pcap')
+  end
+
+  def test_pcapfile_read_and_write_timestamps
+    File.unlink('out.pcap') if File.exists? 'out.pcap'
+    pf = PcapFile.new
+    arr = pf.file_to_array(:filename => 'sample.pcap')
+    assert_equal(11, arr.size)
+    pf = PcapFile.new
+    pf.a2f(:array => arr, :f => 'out.pcap', :ts_inc => 4, 
+           :timestamp => Time.now.to_i - 1_000_000)
+    diff_time = pf.body[0].timestamp.sec.to_i - pf.body[1].timestamp.sec.to_i
+    assert_equal(-4, diff_time)
+    File.unlink('out.pcap')
+  end
 
 end
-	
+  
 # Test the legacy Read objects.
 class ReadTest < Test::Unit::TestCase
 
-	include PacketFu
-
-	def test_read_string
-		pkts = Read.file_to_array(:file => 'sample.pcap')
-		assert_kind_of Array, pkts
-		assert_equal 11, pkts.size
-		this_packet = Packet.parse pkts[0]
-		assert_kind_of UDPPacket, this_packet
-		that_packet = Packet.parse pkts[3]
-		assert_kind_of ICMPPacket, that_packet
-	end
-
-	def test_read_hash
-		pkts = Read.file_to_array(:file => 'sample.pcap', :ts => true)
-		assert_kind_of Array, pkts
-		assert_equal 11, pkts.size
-		this_packet = Packet.parse pkts[0].values.first
-		assert_kind_of UDPPacket, this_packet
-		that_packet = Packet.parse pkts[3].values.first
-		assert_kind_of ICMPPacket, that_packet
-	end
+  include PacketFu
+
+  def test_read_string
+    pkts = Read.file_to_array(:file => 'sample.pcap')
+    assert_kind_of Array, pkts
+    assert_equal 11, pkts.size
+    this_packet = Packet.parse pkts[0]
+    assert_kind_of UDPPacket, this_packet
+    that_packet = Packet.parse pkts[3]
+    assert_kind_of ICMPPacket, that_packet
+  end
+
+  def test_read_hash
+    pkts = Read.file_to_array(:file => 'sample.pcap', :ts => true)
+    assert_kind_of Array, pkts
+    assert_equal 11, pkts.size
+    this_packet = Packet.parse pkts[0].values.first
+    assert_kind_of UDPPacket, this_packet
+    that_packet = Packet.parse pkts[3].values.first
+    assert_kind_of ICMPPacket, that_packet
+  end
 
 end
 
 class WriteTest < Test::Unit::TestCase
 
-	include PacketFu
+  include PacketFu
 
-	def test_write
+  def test_write
 
-	end
+  end
 
 end
 

data/test/test_structfu.rb

@@ -1,111 +1,113 @@
 #!/usr/bin/env ruby
+# -*- coding: binary -*-
+
 require 'test/unit'
 $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 # Whee unit testing.
 class IntStringTest < Test::Unit::TestCase
-	include StructFu
-
-	def test_intstring_len
-		s = IntString.new("hello!", Int32)
-		assert_equal(s.len, s.int.v)
-		assert_not_equal(s.len, s.length)
-		s.len=10
-		assert_equal(s.len, s[:int][:value])
-	end
-
-	def test_intstring_to_s
-		s = IntString.new("hello!", Int16)
-		assert_equal("\x00\x06hello!",s.to_s)
-		s.len=10
-		assert_equal("\x00\x0ahello!",s.to_s)
-		s = IntString.new("hello!", Int16, :parse)
-		s.len=10
-		assert_equal("\x00\x0ahello!\x00\x00\x00\x00",s.to_s)
-		s = IntString.new("hello!", Int16, :fix)
-		s.len=10
-		assert_equal("\x00\x06hello!",s.to_s)
-	end
-
-	def test_intstring_new
-		assert_equal("\x06Hello!",IntString.new("Hello!").to_s)
-		assert_equal("\x00\x06Hello!",IntString.new("Hello!",Int16).to_s)
-		assert_equal("\x06\x00\x00\x00Hello!",IntString.new("Hello!",Int32le).to_s)
-	end
-
-	def test_intstring_read
-		s = IntString.new
-		s.read("\x06Hello!")
-		assert_equal("Hello!", s.string)
-		assert_equal("Hello!", s[:string])
-		assert_equal(6, s.int.value)
-		assert_equal(6, s.len)
-	end
-
-	def test_intstring_parse
-		s = IntString.new
-		s[:mode] = :parse
-		s.parse("\x02Hello!")
-		assert_equal("He", s.string)
-		assert_equal(2, s.int.v)
-		s.parse("\x0aHello!")
-		assert_equal("Hello!\x00\x00\x00\x00", s.string)
-		s[:mode] = :fix
-		s.parse("\x0aHello!")
-		assert_equal("Hello!", s.string)
-	end
-
-	def test_intstring_nocalc
-		s = IntString.new
-		s[:string] = "Hello"
-		assert_equal(0,s.int.value)
-	end
+  include StructFu
+
+  def test_intstring_len
+    s = IntString.new("hello!", Int32)
+    assert_equal(s.len, s.int.v)
+    assert_not_equal(s.len, s.length)
+    s.len=10
+    assert_equal(s.len, s[:int][:value])
+  end
+
+  def test_intstring_to_s
+    s = IntString.new("hello!", Int16)
+    assert_equal("\x00\x06hello!",s.to_s)
+    s.len=10
+    assert_equal("\x00\x0ahello!",s.to_s)
+    s = IntString.new("hello!", Int16, :parse)
+    s.len=10
+    assert_equal("\x00\x0ahello!\x00\x00\x00\x00",s.to_s)
+    s = IntString.new("hello!", Int16, :fix)
+    s.len=10
+    assert_equal("\x00\x06hello!",s.to_s)
+  end
+
+  def test_intstring_new
+    assert_equal("\x06Hello!",IntString.new("Hello!").to_s)
+    assert_equal("\x00\x06Hello!",IntString.new("Hello!",Int16).to_s)
+    assert_equal("\x06\x00\x00\x00Hello!",IntString.new("Hello!",Int32le).to_s)
+  end
+
+  def test_intstring_read
+    s = IntString.new
+    s.read("\x06Hello!")
+    assert_equal("Hello!", s.string)
+    assert_equal("Hello!", s[:string])
+    assert_equal(6, s.int.value)
+    assert_equal(6, s.len)
+  end
+
+  def test_intstring_parse
+    s = IntString.new
+    s[:mode] = :parse
+    s.parse("\x02Hello!")
+    assert_equal("He", s.string)
+    assert_equal(2, s.int.v)
+    s.parse("\x0aHello!")
+    assert_equal("Hello!\x00\x00\x00\x00", s.string)
+    s[:mode] = :fix
+    s.parse("\x0aHello!")
+    assert_equal("Hello!", s.string)
+  end
+
+  def test_intstring_nocalc
+    s = IntString.new
+    s[:string] = "Hello"
+    assert_equal(0,s.int.value)
+  end
 
 end
 
 class IntTest < Test::Unit::TestCase
-	include StructFu
-
-	def test_int_to_s
-		assert_equal("\x02",Int8.new(2).to_s) 
-		assert_equal("\x00\x07",Int16.new(7).to_s) 
-		assert_equal("\x00\x00\x00\x0a",Int32.new(10).to_s) 
-	end
-
-	def test_int_big
-		assert_equal("\x00\x07",Int16be.new(7).to_s) 
-		assert_equal("\x00\x00\x00\x0a",Int32be.new(10).to_s) 
-	end
-
-	def test_int_little
-		assert_equal("\x07\x00",Int16le.new(7).to_s) 
-		assert_equal("\x01\x04\x00\x00",Int32le.new(1025).to_s) 
-	end
-
-	def test_read
-		assert_equal(7,Int16.new.read("\x00\x07").to_i) 
-		assert_equal(Int32.new.read("\x00\x00\x00\x0a").to_i,10) 
-		i = Int32.new
-		i.read("\x00\x00\x00\xff")
-		assert_equal(i.v, 255)
-		assert_equal(7, Int16le.new.read("\x07\x00").to_i) 
-		assert_equal(1025,Int32le.new.read("\x01\x04\x00\x00").to_i) 
-		i = Int32le.new
-		i.read("\xff\x00\x00\x00")
-		assert_equal(i.v, 255)
-	end
-
-	def test_int_compare
-		little = Int32le.new
-		big = Int32be.new
-		little.v = 128
-		big.v = 0x80
-		assert_not_equal(little.to_s, big.to_s)
-		assert_equal(little.v, big.v)
-		assert_equal(little[:value], big[:value])
-		assert_equal(little.value, big.value)
-	end
+  include StructFu
+
+  def test_int_to_s
+    assert_equal("\x02",Int8.new(2).to_s) 
+    assert_equal("\x00\x07",Int16.new(7).to_s) 
+    assert_equal("\x00\x00\x00\x0a",Int32.new(10).to_s) 
+  end
+
+  def test_int_big
+    assert_equal("\x00\x07",Int16be.new(7).to_s) 
+    assert_equal("\x00\x00\x00\x0a",Int32be.new(10).to_s) 
+  end
+
+  def test_int_little
+    assert_equal("\x07\x00",Int16le.new(7).to_s) 
+    assert_equal("\x01\x04\x00\x00",Int32le.new(1025).to_s) 
+  end
+
+  def test_read
+    assert_equal(7,Int16.new.read("\x00\x07").to_i) 
+    assert_equal(Int32.new.read("\x00\x00\x00\x0a").to_i,10) 
+    i = Int32.new
+    i.read("\x00\x00\x00\xff")
+    assert_equal(i.v, 255)
+    assert_equal(7, Int16le.new.read("\x07\x00").to_i) 
+    assert_equal(1025,Int32le.new.read("\x01\x04\x00\x00").to_i) 
+    i = Int32le.new
+    i.read("\xff\x00\x00\x00")
+    assert_equal(i.v, 255)
+  end
+
+  def test_int_compare
+    little = Int32le.new
+    big = Int32be.new
+    little.v = 128
+    big.v = 0x80
+    assert_not_equal(little.to_s, big.to_s)
+    assert_equal(little.v, big.v)
+    assert_equal(little[:value], big[:value])
+    assert_equal(little.value, big.value)
+  end
 
 end