dakrone-pcap-ffi 0.0.0 → 0.0.1

data/Manifest.txt

@@ -2,10 +2,7 @@ History.txt
 Manifest.txt
 Rakefile
 README.txt
-examples/print_bytes.rb
 lib/pcap.rb
-lib/pcap/exceptions.rb
-lib/pcap/exceptions/read_error.rb
 lib/pcap/typedefs.rb
 lib/pcap/time_val.rb
 lib/pcap/in_addr.rb
@@ -15,7 +12,6 @@ lib/pcap/if.rb
 lib/pcap/addr.rb
 lib/pcap/file_header.rb
 lib/pcap/packet_header.rb
-lib/pcap/packet.rb
 lib/pcap/packets.rb
 lib/pcap/packets/typedefs.rb
 lib/pcap/packets/ethernet.rb
@@ -23,18 +19,8 @@ lib/pcap/packets/ip.rb
 lib/pcap/packets/tcp.rb
 lib/pcap/stat.rb
 lib/pcap/data_link.rb
-lib/pcap/error_buffer.rb
 lib/pcap/handler.rb
 lib/pcap/dumper.rb
 lib/pcap/version.rb
 lib/pcap/ffi.rb
 lib/pcap/pcap.rb
-tasks/spec.rb
-spec/spec_helper.rb
-spec/helpers/dumps.rb
-spec/dumps/simple_tcp.pcap
-spec/error_buffer.rb
-spec/data_link_spec.rb
-spec/handler_examples.rb
-spec/handler_spec.rb
-spec/pcap_spec.rb

data/Rakefile

@@ -2,17 +2,22 @@
 
 require 'rubygems'
 require './lib/pcap/version.rb'
-require './tasks/spec.rb'
+
+#Hoe.new('pcap-ffi', FFI::PCap::VERSION) do |p|
+  #p.rubyforge_name = 'pcap-ffi'
+  #p.developer('Postmodern','postmodern.mod3@gmail.com')
+  #p.remote_rdoc_dir = ''
+  #p.extra_deps = [['ffi', '>=0.4.0']]
+#end
 
 # Generate a gem using jeweler
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.rubyforge_project = 'pcap-ffi'
     gemspec.name = "pcap-ffi"
     gemspec.summary = "FFI bindings for libpcap"
-    gemspec.email = "postmodern.mod3@gmail.com"
-    gemspec.homepage = "http://github.com/postmodern/pcap-ffi"
+    gemspec.email = "lee@writequit.org"
+    gemspec.homepage = "http://github.com/dakrone/pcap-ffi"
     gemspec.description = "Bindings to sniff packets using the FFI interface in Ruby."
     gemspec.authors = ["Postmodern, Dakrone"]
   end

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/lib/pcap/dumper.rb

@@ -6,32 +6,19 @@ module FFI
   module PCap
     class Dumper < FFI::MemoryPointer
 
-      def initialize(dumper)
-        @dumper = dumper
-      end
-
-      def write(header,bytes)
-        PCap.pcap_dump(@dumper,header,bytes)
+      def self.open(path)
       end
 
       def tell
-        PCap.pcap_dump_ftell(@dumper)
+        PCap.pcap_dump_ftell(self)
       end
 
       def flush
-        PCap.pcap_dump_flush(@dumper)
+        PCap.pcap_dump_flush(self)
       end
 
       def close
-        PCap.pcap_dump_close(@dumper)
-      end
-
-      def to_ptr
-        @dumper
-      end
-
-      def inspect
-        "#<#{self.class}: 0x#{@dumper.address.to_s(16)}>"
+        PCap.pcap_dump_close(self)
       end
 
     end

data/lib/pcap/ffi.rb

@@ -1,5 +1,3 @@
-require 'pcap/typedefs'
-
 require 'ffi'
 
 module FFI
@@ -8,6 +6,8 @@ module FFI
 
     ffi_lib 'libpcap'
 
+    ERRBUF_SIZE = 256
+
     enum :pcap_direction, [
       :pcap_d_inout,
       :pcap_d_in,
@@ -16,11 +16,11 @@ module FFI
 
     callback :pcap_handler, [:pointer, :pointer, :pointer], :void
 
-    attach_function :pcap_lookupdev, [:pointer], :string
-    attach_function :pcap_lookupnet, [:string, :pointer, :pointer, :pointer], :int
-    attach_function :pcap_open_live, [:string, :int, :int, :int, :pointer], :pointer
+    attach_function :pcap_lookupdev, [:string], :string
+    attach_function :pcap_lookupnet, [:string, :pointer, :pointer, :string], :int
+    attach_function :pcap_open_live, [:string, :int, :int, :int, :string], :pointer
     attach_function :pcap_open_dead, [:int, :int], :pointer
-    attach_function :pcap_open_offline, [:string, :pointer], :pointer
+    attach_function :pcap_open_offline, [:string, :string], :pointer
     attach_function :pcap_fopen_offline, [:pointer, :string], :pointer
     attach_function :pcap_close, [:pointer], :void
     attach_function :pcap_loop, [:pointer, :int, :pcap_handler, :pointer], :int
@@ -30,9 +30,9 @@ module FFI
     attach_function :pcap_breakloop, [:pointer], :void
     attach_function :pcap_stats, [:pointer, :pointer], :int
     attach_function :pcap_setfilter, [:pointer, :pointer], :int
-    attach_function :pcap_setdirection, [:pointer, :pcap_direction], :int
-    attach_function :pcap_getnonblock, [:pointer, :pointer], :int
-    attach_function :pcap_setnonblock, [:pointer, :int, :pointer], :int
+    attach_function :pcap_setdirection, [:pointer, :pcap_direction_t], :int
+    attach_function :pcap_getnonblock, [:pointer, :string], :int
+    attach_function :pcap_setnonblock, [:pointer, :int, :string], :int
     attach_function :pcap_perror, [:pointer, :string], :void
     attach_function :pcap_inject, [:pointer, :pointer, :int], :int
     attach_function :pcap_sendpacket, [:pointer, :pointer, :int], :int
@@ -63,7 +63,7 @@ module FFI
     attach_function :pcap_dump_close, [:pointer], :void
     attach_function :pcap_dump, [:pointer, :pointer, :pointer], :void
 
-    attach_function :pcap_findalldevs, [:pointer, :pointer], :int
+    attach_function :pcap_findalldevs, [:pointer, :string], :int
     attach_function :pcap_freealldevs, [:pointer], :void
 
     attach_function :pcap_lib_version, [], :string

data/lib/pcap/handler.rb

@@ -1,9 +1,5 @@
-require 'pcap/exceptions/read_error'
 require 'pcap/ffi'
-require 'pcap/error_buffer'
 require 'pcap/data_link'
-require 'pcap/packet_header'
-require 'pcap/stat'
 
 require 'ffi'
 
@@ -22,26 +18,8 @@ module FFI
       # Number of packets to sniff
       attr_accessor :count
 
-      def initialize(pcap,options={},&block)
+      def initialize(pcap)
         @pcap = pcap
-        @closed = false
-
-        # Default is to infinitely loop over packets.
-        @count = (options[:count] || -1)
-
-        if options[:direction]
-          self.direction = options[:direction]
-        end
-
-        @callback_wrapper = Proc.new do |user,header,bytes|
-          if @callback
-            @callback.call(user,PacketHeader.new(header),bytes)
-          end
-        end
-
-        callback(&block)
-
-        trap('SIGINT') { self.close }
       end
 
       def datalink
@@ -49,120 +27,48 @@ module FFI
       end
 
       def callback(&block)
-        @callback = block
-        return @callback
-      end
-
-      def direction=(dir)
-        directions = PCap.enum_type(:pcap_direction)
-
-        return PCap.pcap_setdirection(@pcap,directions[:"pcap_d_#{dir}"])
-      end
-
-      def non_blocking=(mode)
-        errbuf = ErrorBuffer.new
-        mode = if mode
-          1
-        else
-          0
-        end
-
-        if PCap.pcap_setnonblock(@pcap,mode,errbuf) == -1
-          raise(RuntimeError,errbuf.to_s,caller)
+        if block
+          @callback = block
         end
 
-        return mode == 1
+        return @callback
       end
 
-      def non_blocking?
-        errbuf = ErrorBuffer.new
-        mode = PCap.pcap_getnonblock(@pcap,errbuf)
-
-        if mode == -1
-          raise(RuntimeError,errbuf.to_s,caller)
-        end
-
-        return mode == 1
+      def direction=(dir)
+        PCap.pcap_setdirection(@pcap,dir)
       end
 
-      def loop(data=nil,&block)
+      def loop(data,&block)
         callback(&block) if block
 
-        PCap.pcap_loop(@pcap,@count,@callback_wrapper,data)
+        PCap.pcap_loop(@pcap,@count,@callback,data)
       end
 
-      alias each loop
+      alias :each :loop
 
-      def dispatch(data=nil,&block)
+      def dispatch(data,&block)
         callback(&block) if block
 
-        return PCap.pcap_dispatch(@pcap,@count,@callback_wrapper,data)
+        PCap.pcap_dispatch(@pcap,@count,@callback,data)
       end
 
       def next
         header = PacketHeader.new
         data = PCap.pcap_next(@pcap,header)
 
-        return [nil, nil] if data.null?
         return [header, data]
       end
 
-      def next_extra
-        header_ptr = MemoryPointer.new(:pointer)
-        data_ptr = MemoryPointer.new(:pointer)
-
-        case PCap.pcap_next_ex(@pcap,header_ptr,data_ptr)
-        when -1
-          raise(ReadError,"an error occurred while reading the packet",caller)
-        when -2
-          raise(ReadError,"the 'savefile' contains no more packets",caller)
-        end
-
-        return [header_ptr.get_pointer(0), data_ptr.get_pointer(0)]
-      end
-
-      def open_dump(path)
-        dump_ptr = PCap.pcap_dump_open(@pcap,File.expand_path(path))
-
-        if dump_ptr.null?
-          raise(RuntimeError,error,caller)
-        end
-
-        return Dumper.new(dump_ptr)
-      end
-
-      def stats
-        stats = Stat.new
-
-        PCap.pcap_stats(@pcap,stats)
-        return stats
-      end
-
-      def error
-        PCap.pcap_geterr(@pcap)
-      end
-
       def stop
         PCap.pcap_breakloop(@pcap)
       end
 
-      def closed?
-        @closed == true
-      end
-
       def close
-        unless @closed
-          @closed = true
-          PCap.pcap_close(@pcap)
-        end
-      end
-
-      def to_ptr
-        @pcap
+        PCap.pcap_close(@pcap)
       end
 
       def inspect
-        "#<#{self.class}: 0x#{@pcap.address.to_s(16)}>"
+        "#<#{self.class}: 0x#{@pcap.to_s(16)}>"
       end
 
     end

data/lib/pcap/if.rb

@@ -19,18 +19,10 @@ module FFI
         IF.new(self[:next])
       end
 
-      def name
-        self[:name]
-      end
-
       def addresses
         Addr.new(self[:addresses])
       end
 
-      def to_s
-        self[:name]
-      end
-
     end
   end
 end

data/lib/pcap/packet_header.rb

@@ -9,18 +9,6 @@ module FFI
       layout :ts, TimeVal,
              :caplen, :bpf_uint32,
              :len, :bpf_uint32
-
-      def timestamp
-        self[:ts]
-      end
-
-      def captured
-        self[:caplen]
-      end
-
-      def length
-        self[:len]
-      end
     end
   end
 end

data/lib/pcap/packets/ethernet.rb

@@ -1,5 +1,4 @@
 require 'pcap/packets/typedefs'
-require 'pcap/packet'
 
 require 'ffi'
 
@@ -8,8 +7,6 @@ module FFI
     module Packets
       class Ethernet < FFI::Struct
 
-        include Packet
-
         # Number of bytes for an ethernet address
         ADDR_LEN = 6
 

data/lib/pcap/packets/ip.rb

@@ -1,4 +1,3 @@
-require 'pcap/packet'
 require 'pcap/in_addr'
 
 require 'ffi'
@@ -8,8 +7,6 @@ module FFI
     module Packets
       class IPv4 < FFI::Struct
 
-        include Packet
-
         # IPv4 flags
         FLAGS = [
           # Reserved fragment flag

data/lib/pcap/packets/tcp.rb

@@ -1,5 +1,4 @@
 require 'pcap/packets/typedefs'
-require 'pcap/packet'
 
 require 'ffi'
 
@@ -8,8 +7,6 @@ module FFI
     module Packets
       class TCP < FFI::Struct
 
-        include Packet
-
         # TCP flags
         FLAGS = [
           # Null flags

data/lib/pcap/pcap.rb

@@ -1,85 +1,33 @@
 require 'pcap/ffi'
 require 'pcap/data_link'
-require 'pcap/if'
 require 'pcap/handler'
-require 'pcap/error_buffer'
 
 module FFI
   module PCap
-    def PCap.lib_version
-      PCap.pcap_lib_version
-    end
-
-    def PCap.device
-      errbuf = ErrorBuffer.new
-
-      unless (name = PCap.pcap_lookupdev(errbuf))
-        raise(StandardError,errbuf.to_s,caller)
-      end
-
-      return name
-    end
-
-    def PCap.each_device(&block)
-      devices = MemoryPointer.new(:pointer)
-      errbuf = ErrorBuffer.new
-
-      PCap.pcap_findalldevs(devices,errbuf)
-      node = devices.get_pointer(0)
-
-      if node.null?
-        raise(StandardError,errbuf.to_s,caller)
-      end
-
-      device = IF.new(node)
-
-      until device
-        block.call(device) if block
-        device = device.next
-      end
-
-      PCap.pcap_freealldevs(node)
-      return nil
-    end
-
-    def PCap.open_live(options={},&block)
+    def PCap.open_live(options={})
       device = options[:device]
       promisc = if options[:promisc]
                   1
                 else
                   0
                 end
-      snaplen = (options[:snaplen] || Handler::SNAPLEN)
+      snaplen = (options[:snaplen] || SNAPLEN)
       to_ms = (options[:timeout] || 0)
-      errbuf = ErrorBuffer.new
 
       ptr = PCap.pcap_open_live(device,snaplen,promisc,to_ms,nil)
 
-      if ptr.null?
-        raise(StandardError,errbuf.to_s,caller)
+      unless ptr
+        raise(StandardError,errbuf,caller)
       end
 
-      return Handler.new(ptr,options,&block)
+      return Handler.new(ptr)
     end
 
-    def PCap.open_dead(datalink,options={})
+    def self.open_dead(datalink,snaplen=SNAPLEN)
       datalink = DataLink[datalink]
-      snaplen = (options[:snaplen] || Handler::SNAPLEN)
 
-      return Handler.new(PCap.pcap_open_dead(datalink,snaplen),options)
+      return Handler.new(PCap.pcap_open_dead(datalink,snaplen))
     end
 
-    def PCap.open_offline(path,options={})
-      path = File.expand_path(path)
-      errbuf = ErrorBuffer.new
-
-      ptr = PCap.pcap_open_offline(path,errbuf)
-
-      if ptr.null?
-        raise(StandardError,errbuf.to_s,caller)
-      end
-
-      return Handler.new(ptr,options)
-    end
   end
 end

data/lib/pcap/stat.rb

@@ -6,18 +6,6 @@ module FFI
       layout :ps_recv, :uint,
              :ps_drop, :uint,
              :ps_ifdrop, :uint
-
-      def received
-        self[:ps_recv]
-      end
-
-      def dropped
-        self[:ps_drop]
-      end
-
-      def interface_dropped
-        self[:ps_ifdrop]
-      end
     end
   end
 end

data/lib/pcap/time_val.rb

@@ -16,14 +16,6 @@ module FFI
         self[:tv_usec]
       end
 
-      def to_time
-        Time.at(self[:tv_sec],self[:tv_usec])
-      end
-
-      def to_s
-        to_time.to_s
-      end
-
     end
   end
 end

data/lib/pcap/typedefs.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'ffi'
 
 module FFI
@@ -13,4 +12,5 @@ module FFI
   alias_type :uint32, :in_addr_t
   alias_type :int, :bpf_int32
   alias_type :uint, :bpf_uint32
+  alias_type :int, :pcap_direction_t
 end

data/pcap-ffi.gemspec

@@ -2,13 +2,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pcap-ffi}
-  s.version = "0.0.0"
+  s.version = "0.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Postmodern, Dakrone"]
-  s.date = %q{2009-05-27}
+  s.date = %q{2009-05-24}
   s.description = %q{Bindings to sniff packets using the FFI interface in Ruby.}
-  s.email = %q{postmodern.mod3@gmail.com}
+  s.email = %q{lee@writequit.org}
   s.extra_rdoc_files = [
     "README.txt"
   ]
@@ -19,14 +19,10 @@ Gem::Specification.new do |s|
      "README.txt",
      "Rakefile",
      "VERSION",
-     "examples/print_bytes.rb",
      "lib/pcap.rb",
      "lib/pcap/addr.rb",
      "lib/pcap/data_link.rb",
      "lib/pcap/dumper.rb",
-     "lib/pcap/error_buffer.rb",
-     "lib/pcap/exceptions.rb",
-     "lib/pcap/exceptions/read_error.rb",
      "lib/pcap/ffi.rb",
      "lib/pcap/file_header.rb",
      "lib/pcap/handler.rb",
@@ -45,38 +41,17 @@ Gem::Specification.new do |s|
      "lib/pcap/time_val.rb",
      "lib/pcap/typedefs.rb",
      "lib/pcap/version.rb",
-     "pcap-ffi.gemspec",
-     "spec/data_link_spec.rb",
-     "spec/dumps/simple_tcp.pcap",
-     "spec/error_buffer.rb",
-     "spec/handler_examples.rb",
-     "spec/handler_spec.rb",
-     "spec/helpers/dumps.rb",
-     "spec/pcap_spec.rb",
-     "spec/spec_helper.rb",
-     "tasks/spec.rb"
+     "pcap-ffi.gemspec"
   ]
-  s.has_rdoc = true
-  s.homepage = %q{http://github.com/postmodern/pcap-ffi}
+  s.homepage = %q{http://github.com/dakrone/pcap-ffi}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{pcap-ffi}
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.3}
   s.summary = %q{FFI bindings for libpcap}
-  s.test_files = [
-    "spec/pcap_spec.rb",
-     "spec/data_link_spec.rb",
-     "spec/error_buffer.rb",
-     "spec/spec_helper.rb",
-     "spec/handler_spec.rb",
-     "spec/handler_examples.rb",
-     "spec/helpers/dumps.rb",
-     "examples/print_bytes.rb"
-  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
     else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dakrone-pcap-ffi
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Postmodern, Dakrone
@@ -9,12 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-27 00:00:00 -07:00
+date: 2009-05-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
 description: Bindings to sniff packets using the FFI interface in Ruby.
-email: postmodern.mod3@gmail.com
+email: lee@writequit.org
 executables: []
 
 extensions: []
@@ -28,14 +28,10 @@ files:
 - README.txt
 - Rakefile
 - VERSION
-- examples/print_bytes.rb
 - lib/pcap.rb
 - lib/pcap/addr.rb
 - lib/pcap/data_link.rb
 - lib/pcap/dumper.rb
-- lib/pcap/error_buffer.rb
-- lib/pcap/exceptions.rb
-- lib/pcap/exceptions/read_error.rb
 - lib/pcap/ffi.rb
 - lib/pcap/file_header.rb
 - lib/pcap/handler.rb
@@ -55,17 +51,8 @@ files:
 - lib/pcap/typedefs.rb
 - lib/pcap/version.rb
 - pcap-ffi.gemspec
-- spec/data_link_spec.rb
-- spec/dumps/simple_tcp.pcap
-- spec/error_buffer.rb
-- spec/handler_examples.rb
-- spec/handler_spec.rb
-- spec/helpers/dumps.rb
-- spec/pcap_spec.rb
-- spec/spec_helper.rb
-- tasks/spec.rb
-has_rdoc: true
-homepage: http://github.com/postmodern/pcap-ffi
+has_rdoc: false
+homepage: http://github.com/dakrone/pcap-ffi
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -85,17 +72,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: pcap-ffi
+rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: FFI bindings for libpcap
-test_files: 
-- spec/pcap_spec.rb
-- spec/data_link_spec.rb
-- spec/error_buffer.rb
-- spec/spec_helper.rb
-- spec/handler_spec.rb
-- spec/handler_examples.rb
-- spec/helpers/dumps.rb
-- examples/print_bytes.rb
+test_files: []
+

data/examples/print_bytes.rb

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'pcap'
-
-include FFI
-
-pcap = PCap.open_live(:device => ARGV[0]) do |user,header,bytes|
-  puts "#{header.timestamp}:"
-
-  header.captured.times { |i|
-    print ' %.2x' % bytes.get_uchar(i)
-  }
-  putc "\n"
-end
-
-pcap.loop

data/lib/pcap/error_buffer.rb

@@ -1,26 +0,0 @@
-require 'ffi'
-
-module FFI
-  module PCap
-    class ErrorBuffer < FFI::Buffer
-
-      # Size of the error buffers
-      SIZE = 256
-
-      #
-      # Creates a new ErrorBuffer object.
-      #
-      def initialize
-        super(SIZE)
-      end
-
-      #
-      # Returns the error message within the error buffer.
-      #
-      def to_s
-        get_string(SIZE)
-      end
-
-    end
-  end
-end

data/lib/pcap/exceptions.rb

@@ -1 +0,0 @@
-require 'pcap/exceptions/read_error'

data/lib/pcap/exceptions/read_error.rb

@@ -1,6 +0,0 @@
-module FFI
-  module PCap
-    class ReadError < RuntimeError
-    end
-  end
-end

data/spec/data_link_spec.rb

@@ -1,29 +0,0 @@
-require 'pcap/data_link'
-
-require 'spec_helper'
-
-describe DataLink do
-  before(:all) do
-    @datalink = DataLink.new(0)
-  end
-
-  it "should be initialized from a pcap datalink value" do
-    @datalink.name.should == 'NULL'
-  end
-
-  it "should map datalink names to pcap datalink values" do
-    DataLink[:en10mb].should == 1
-  end
-
-  it "should have a description" do
-    @datalink.description.should_not be_empty
-  end
-
-  it "should be able to convert to an Integer" do
-    @datalink.to_i.should == 0
-  end
-
-  it "should be able to convert to a String" do
-    @datalink.to_s.should == 'NULL'
-  end
-end

data/spec/error_buffer.rb

@@ -1,18 +0,0 @@
-require 'pcap/error_buffer'
-
-require 'spec_helper'
-
-describe PCap::ErrorBuffer do
-  before(:all) do
-    @errbuf = PCap::ErrorBuffer.new
-  end
-
-  it "should have a size of 256" do
-    @errbuf.size.should == 256
-  end
-
-  it "should return the error message for to_s" do
-    @errbuf.write_string('test')
-    @errbuf.to_s.should == 'test'
-  end
-end

data/spec/handler_examples.rb

@@ -1,71 +0,0 @@
-require 'pcap/handler'
-
-require 'spec_helper'
-
-shared_examples_for "Handler" do
-  it "must have a datalink" do
-    datalink = @pcap.datalink
-
-    datalink.value.should_not be_nil
-    datalink.name.should_not be_empty
-  end
-
-  it "should pass packets to a callback" do
-    @pcap.callback do |user,header,bytes|
-      header.captured.should_not == 0
-      header.length.should_not == 0
-
-      bytes.should_not be_null
-    end
-
-    @pcap.loop
-  end
-
-  it "should be able to get the next packet" do
-    header, data = @pcap.next
-
-    header.should_not be_nil
-    header.captured.should_not == 0
-    header.length.should_not == 0
-
-    data.should_not be_nil
-    data.should_not be_null
-  end
-
-  it "should be able to open a dump file" do
-    lambda {
-      dumper = @pcap.open_dump(Tempfile.new.path)
-      dumper.close
-    }.should_not raise_error(RuntimeError)
-  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(RuntimeError)
-  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 break out of the Handler#loop" do
-    stopped = false
-
-    @pcap.loop do |user,pkthdr,bytes|
-      stopped = true
-      @pcap.stop
-    end
-
-    stopped.should == true
-  end
-
-  it "should prevent double closes" do
-    @pcap.close
-    @pcap.should be_closed
-
-    lambda {
-      @pcap.close
-    }.should_not raise_error(StandardError)
-  end
-end

data/spec/handler_spec.rb

@@ -1,80 +0,0 @@
-require 'pcap/handler'
-
-require 'spec_helper'
-require 'helpers/dumps'
-require 'handler_examples'
-
-describe PCap::Handler do
-  describe "offline" do
-    before(:each) do
-      @pcap = PCap.open_offline(dump_path('simple_tcp'))
-    end
-
-    after(:each) do
-      @pcap.close
-    end
-
-    it_should_behave_like "Handler"
-
-    it "should not support non-blocking mode" do
-      @pcap.non_blocking = true
-      @pcap.should_not be_non_blocking
-    end
-
-    it "should return a nil if there are no packets left in the dump file" do
-      @pcap.loop
-
-      header, data = @pcap.next
-
-      header.should be_nil
-      data.should be_nil
-    end
-
-    it "should raise a ReadError when reading past the end of a dump file" do
-      @pcap.loop
-
-      lambda {
-        @pcap.next_extra
-      }.should raise_error(ReadError)
-    end
-  end
-
-  describe "live" do
-    before(:each) do
-      @pcap = PCap.open_live(:count => 2)
-    end
-
-    after(:each) do
-      @pcap.close
-    end
-
-    it_should_behave_like "Handler"
-
-    it "should support non-blocking mode" do
-      @pcap.non_blocking = true
-      @pcap.should be_non_blocking
-    end
-
-    it "should provide statistics about packets received/dropped" do
-      @pcap.loop
-
-      stats = @pcap.stats
-      stats.received.should > 0
-    end
-  end
-
-  describe "dead" do
-    before(:each) do
-      @pcap = PCap.open_dead
-    end
-
-    after(:each) do
-      @pcap.close
-    end
-
-    it "should support non-blocking mode" do
-      @pcap.non_blocking = true
-      @pcap.should be_non_blocking
-    end
-  end
-end

data/spec/helpers/dumps.rb

@@ -1,3 +0,0 @@
-def dump_path(name)
-  File.expand_path(File.join(File.dirname(__FILE__),'..','dumps',"#{name}.pcap"))
-end

data/spec/pcap_spec.rb

@@ -1,51 +0,0 @@
-require 'pcap/pcap'
-require 'pcap/version'
-
-require 'spec_helper'
-require 'helpers/dumps'
-
-describe PCap do
-  it "should define a VERSION constant" do
-    PCap.const_defined?('VERSION').should == true
-  end
-
-  it "should have a library version" do
-    PCap.lib_version.should_not be_empty
-  end
-
-  it "should return the name of a device suitable for open_live" do
-    dev = PCap.device
-
-    dev.should_not be_nil
-    dev.should_not be_empty
-  end
-
-  it "should enumerate over all usable devices" do
-    PCap.each_device do |dev|
-      dev.should_not be_nil
-      dev.should_not be_null
-      dev.class.should == PCap::IF
-    end
-  end
-
-  it "should be able to open a live pcap handler" do
-    lambda {
-      pcap = PCap.open_live
-      pcap.close
-    }.should_not raise_error(StandardError)
-  end
-
-  it "should be able to open a dead pcap handler" do
-    lambda {
-      pcap = PCap.open_dead('null')
-      pcap.close
-    }.should_not raise_error(StandardError)
-  end
-
-  it "should be able to open a pcap dump file" do
-    lambda {
-      pcap = PCap.open_offline(dump_path('simple_tcp'))
-      pcap.close
-    }.should_not raise_error(StandardError)
-  end
-end

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-require 'rubygems'
-gem 'rspec', '>=1.1.12'
-require 'spec'
-
-require 'pcap/version'
-
-include FFI
-include FFI::PCap

data/tasks/spec.rb

@@ -1,9 +0,0 @@
-require 'spec/rake/spectask'
-
-desc "Run all specifications"
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.libs += ['lib', 'spec']
-  t.spec_opts = ['--colour', '--format', 'specdoc']
-end
-
-task :default => :spec