caper 0.2.0

data/spec/packet_injection_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Caper::Live do
+  describe "packet injection" do
+    before(:all) do
+      @pcap = Caper.open_live :device => PCAP_DEV, 
+                             :promisc => false,
+                             :timeout => 100,
+                             :snaplen => 8192
+    end
+
+    after(:all) do
+      @pcap.close
+    end
+
+    it "should detect when an invalid argument is supplied" do
+      lambda { @pcap.inject(Object.new)}.should raise_error(ArgumentError)
+      lambda { @pcap.inject(nil)}.should raise_error(ArgumentError)
+      lambda { @pcap.inject(1)}.should raise_error(ArgumentError)
+      lambda { @pcap.inject([])}.should raise_error(ArgumentError)
+      lambda { @pcap.inject(:foo => :bar)}.should raise_error(ArgumentError)
+      lambda { 
+        @pcap.inject(FFI::MemoryPointer.new(10))
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should allow injection of a String using inject()" do
+      test_data = "A" * 1024
+      @pcap.inject(test_data).should == test_data.size
+    end
+
+    it "should allow injection of a Packet using inject()" do
+      test_data = "B" * 512
+      @pcap.inject(Packet.from_string(test_data)).should == test_data.size
+    end
+
+  end
+end

data/spec/packet_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'packet_behaviors'
+
+describe Packet do
+  describe 'created using new() with a body string and nil header' do
+    before(:all) do
+      @test_body = "\xde\xad\xbe\xef"
+      @pkt = Packet.new(nil, @test_body)
+    end
+
+    it_should_behave_like "Caper::Packet composed"
+
+  end
+
+  describe 'created using new() with a Header and pointer to body' do
+    before(:all) do
+      @test_body = "\xde\xad\xbe\xef\xba\xbe"
+      l = @test_body.size
+      body = FFI::MemoryPointer.from_string(@test_body)
+      @pkt = Packet.new(PacketHeader.new(:caplen => l, :len => l), body)
+    end
+
+    it_should_behave_like "Caper::Packet composed"
+
+  end
+
+  describe 'created with from_string()' do
+    before(:all) do
+      @test_body = "\xde\xad\xbe\xef"
+      @pkt = Packet.from_string("\xde\xad\xbe\xef")
+    end
+  
+    it_should_behave_like "Caper::Packet composed"
+
+  end
+
+
+  describe 'provided by a libpcap savefile using next()' do
+    before(:all) do
+      @pcap = Caper.open_offline(PCAP_TESTFILE)
+      @pkt = @pcap.next()
+    end
+
+    after(:all) do
+      @pcap.close()
+    end
+
+    it_should_behave_like "Caper::Packet populated"
+  end
+
+  describe 'provided by a libpcap savefile using loop()' do
+    before(:all) do
+      @pcap = Caper.open_offline(PCAP_TESTFILE)
+      @pkt = nil
+      # we use copy inside the loop because libpcap's loop() frees or reuses 
+      # memory for packets after each call to the handler.
+      @pcap.loop(:count => 1) {|this,pkt| @pkt = pkt.copy }
+    end
+
+    after(:all) do
+      @pcap.close()
+    end
+
+    it_should_behave_like "Caper::Packet populated"
+  end
+
+
+  describe "error detection for new()" do
+    it "should raise an error when two nil values are supplied" do
+      lambda { Packet.new(nil,nil)}.should raise_error(Exception)
+    end
+
+    it "should raise an error for an invalid header" do
+      lambda { 
+        Packet.new(Object.new, FFI::MemoryPointer.new(256))
+      }.should raise_error(Exception)
+    end
+
+    it "should raise an error for a nil header without a string body" do
+      lambda { 
+        Packet.new(nil, FFI::MemoryPointer.new(256))
+      }.should raise_error(Exception)
+    end
+
+    it "should raise an error for a valid header but an invalid body pointer" do
+      lambda { 
+        Packet.new(PacketHeader.new, "hellotest")
+      }.should raise_error(Exception)
+    end
+
+    it "should not raise an error for a PacketHeader and a pointer" do
+      lambda { 
+        Packet.new(PacketHeader.new, FFI::MemoryPointer.new(256))
+      }.should_not raise_error(Exception)
+    end
+
+    it "should not raise an error for a pointer and a pointer" do
+      lambda { 
+        Packet.new(FFI::MemoryPointer.new(20), FFI::MemoryPointer.new(256))
+      }.should_not raise_error(Exception)
+    end
+
+    it "should not raise an error for a nil and a string" do
+      lambda { 
+        Packet.new(nil, "hellothere")
+      }.should_not raise_error(Exception)
+
+    end
+
+  end
+end

data/spec/pcap_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Caper do
+  it "should define a VERSION constant" do
+    Caper.const_defined?('VERSION').should == true
+  end
+
+  it ".lib_version() should expose the libpcap version banner" do
+    Caper.lib_version.should_not be_nil
+    Caper.lib_version.should_not be_empty
+  end
+
+  it ".lib_version_number() should expose the libpcap version number only" do
+    Caper.lib_version_number.should_not be_nil
+    Caper.lib_version_number.should_not be_empty
+    Caper.lib_version_number.should =~ /^\d+\.\d+\.\d+$/
+  end
+
+  it ".lookupdev() should return a device deafult device" do
+    dev = Caper.lookupdev
+    dev.should_not be_nil
+    dev.should_not be_empty
+  end
+
+  it ".each_device() should enumerate over all usable interfaces" do
+    i = 0
+    Caper.each_device do |dev|
+      dev.should_not be_nil
+      Interface.should === dev
+      [true,false].include?(dev.loopback?).should == true
+      i+=1
+    end
+    i.should_not == 0
+  end
+
+  it ".device_names() should return names for all network interfaces" do
+    devs = Caper.device_names
+    Array.should === devs
+    i = 0
+    devs.each do |dev|
+      String.should === dev
+      dev.should_not be_nil
+      dev.should_not be_empty
+      i+=1
+    end
+    i.should_not == 0
+    devs.include?(PCAP_DEV).should == true
+  end
+
+  it ".dump_devices() should return name/network pairs for all interfaces" do
+    i = 0
+    devs = Caper.dump_devices
+    Array.should === devs
+    devs.each do |y|
+      y.size.should == 2
+      dev, net = y
+      String.should === dev
+      dev.should_not be_nil
+      dev.should_not be_empty
+      i+=1
+    end
+    i.should_not == 0
+    devs.select{|dev,net| not net.nil? }.should_not be_empty
+    devs.map{|dev,net| dev}.include?(PCAP_DEV).should == true
+  end
+
+  it ".open_live() should open a live pcap handler given a chosen device" do
+    lambda {
+      pcap = Caper.open_live(:device => PCAP_DEV)
+      pcap.device.should == PCAP_DEV
+      pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+  it ".open_live() should open a live pcap handler using a default device" do
+    lambda {
+      # XXX Using Vista and wpcap.dll this breaks on me.
+      #     The lookupdev for a default adapter result is '\', which is just
+      #     wrong.
+      pcap = Caper.open_live()
+      pcap.should be_ready
+      pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+  it ".open_dead() should open a dead pcap handler" do
+    lambda {
+      pcap = Caper.open_dead()
+      pcap.should be_ready
+      pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+  it ".open_offline() should open a pcap dump file" do
+    lambda {
+      pcap = Caper.open_offline(PCAP_TESTFILE)
+      pcap.should be_ready
+      pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+  it ".open_file() should work the same as .open_offline()" do
+    lambda {
+      pcap = Caper.open_offline(PCAP_TESTFILE)
+      pcap.should be_ready
+      pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+  it ".open_live() should take a block and close the device after calling it" do
+    pcap = nil
+    ret = Caper.open_live(:device => PCAP_DEV) {|this|
+      Live.should === this
+      this.should be_ready
+      this.should_not be_closed
+      pcap = this
+    }
+    ret.should be_nil
+    pcap.should_not be_ready
+    pcap.should be_closed
+  end
+
+  it ".open_dead() should take a block and close the device after calling it" do
+    pcap = nil
+    ret = Caper.open_dead() {|this|
+      Dead.should === this
+      this.should be_ready
+      this.should_not be_closed
+      pcap = this
+    }
+    ret.should be_nil
+    pcap.should_not be_ready
+    ret.should be_nil
+  end
+
+  it ".open_file() should take a block and close the device after calling it" do
+    pcap = nil
+    ret = Caper.open_file(PCAP_TESTFILE) {|this|
+      Offline.should === this
+      this.should be_ready
+      this.should_not be_closed
+      pcap = this
+    }
+    ret.should be_nil
+    pcap.should_not be_ready
+    ret.should be_nil
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+gem 'rspec', '>=1.2.9'
+require 'spec'
+
+require 'caper'
+
+include FFI
+include Caper
+
+PCAP_DEV      = ENV['PCAP_DEV'] || 'lo0'
+PCAP_TESTFILE = ENV['PCAP_TESTFILE'] || File.expand_path(File.join(File.dirname(__FILE__), 'dumps', 'simple_tcp.pcap'))
+PCAP_TESTADDR = ENV['PCAP_TESTADDR'] || '127.0.0.1'
+
+$test_ping_pid = nil
+
+def start_traffic_generator
+  begin
+    if $test_ping_pid.nil?
+      $test_ping_pid = Process.fork{ `ping #{PCAP_TESTADDR}` }
+    end
+  rescue NotImplementedError
+    $test_ping_pid = nil
+  end
+end
+
+def stop_traffic_generator
+  if $test_ping_pid
+    Process.kill('TERM', $test_ping_pid)
+    $test_ping_pid = nil
+  end
+end

data/spec/wrapper_behaviors.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'tempfile'
+
+shared_examples_for "Caper::CommonWrapper" do
+  it "should indicate readiness" do
+    @pcap.ready?.should == true
+  end
+
+  it "should have a datalink" do
+    datalink = @pcap.datalink
+    datalink.value.should_not be_nil
+    Numeric.should === datalink.value
+    datalink.name.should_not be_empty
+  end
+
+  it "should be able to open a dump file" do
+    lambda {
+      dumper = @pcap.open_dump(Tempfile.new(rand(0xffff).to_s).path)
+      Dumper.should === dumper
+      dumper.close
+    }.should_not raise_error(Exception)
+  end
+
+  it "should raise an exception when opening a bad dump file" do
+    lambda {
+      @pcap.open_dump(File.join('','obviously','not','there'))
+    }.should raise_error(Exception)
+  end
+
+  it "should return an empty String when an error has not occurred" do
+    @pcap.error.should be_empty
+  end
+
+  it "should be able to compile a filter" do
+    filter = @pcap.compile("ip")
+    filter.should_not be_nil
+    BPFProgram.should === filter
+    filter.bf_len.should > 0
+  end
+
+  it "should detect invalid filter syntax when compiling" do
+    lambda {
+      @pcap.compile("ip and totally bogus")
+    }.should raise_error(LibError)
+  end
+
+  it "should prevent double closes" do
+    @pcap.close
+    @pcap.should be_closed
+    @pcap.should_not be_ready
+
+    lambda {
+      @pcap.close
+    }.should_not raise_error(Exception)
+  end
+
+end
+
+shared_examples_for "Caper::CaptureWrapper" do
+
+  it "should pass packets to a block using loop()" do
+    i = 0
+    @pkt = nil
+    @pcap.loop(:count => 2) do |this, pkt|
+      this.should == @pcap
+      pkt.should_not be_nil
+      Packet.should === pkt
+      i+=1
+    end
+    i.should == 2
+  end
+
+  it "should be able to get the next packet" do
+    pkt = @pcap.next
+    pkt.should_not be_nil
+  end
+
+  it "should be able to break out of a pcap loop()" do
+    stopped = false
+    i = 0
+
+    @pcap.loop(:count => 3) do |this, pkt|
+      stopped = true
+      i+=1
+      this.stop
+    end
+
+    i.should == 1
+    stopped.should == true
+  end
+
+  it "should consume packets without a block passed to loop()" do
+    lambda { @pcap.loop(:count => 3) }.should_not raise_error(Exception)
+  end
+
+  it "should be able to set a filter" do
+    lambda {
+      @pcap.set_filter("ip")
+    }.should_not raise_error(Exception)
+  end
+
+  it "should detect invalid filter syntax in set_filter" do
+    lambda {
+      @pcap.set_filter("ip and totally bogus")
+    }.should raise_error(LibError)
+  end
+
+  it_should_behave_like "Caper::CommonWrapper"
+end
+

data/tasks/rcov.rb

@@ -0,0 +1,6 @@
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end