ffi-pcap 0.2.0 → 0.2.1

data/lib/ffi/pcap/dead.rb

@@ -1,37 +1,50 @@
 require 'ffi/pcap/common_wrapper'
+require 'ffi/pcap/data_link'
 
 module FFI
-module PCap
-  # A wrapper class for pcap devices opened with open_dead()
-  class Dead < CommonWrapper
-    attr_reader :datalink
-
-    # Creates a fake pcap interface for compiling filters or opening a
-    # capture for output.
-    #
-    # @param [Hash] opts
-    #   Options are ignored and passed to the super-class except those below.
-    #
-    # @option opts [optional, String, Symbol, Integer] :datalink
-    #   The link-layer type for pcap. nil is equivalent to 0 (aka DLT_NULL).
-    #
-    # @option opts [optional, Integer] :snaplen
-    #   The snapshot length for the pcap object. Defaults to FFI::PCap::DEFAULT_SNAPLEN
+  module PCap
     #
-    # @return [Dead]
-    #   A FFI::PCap::Dead wrapper.
+    # A wrapper class for pcap devices opened with {PCap.open_dead}
     #
-    def initialize(opts={}, &block)
-      dl = opts[:datalink] || DataLink.new(0)
-      @datalink = dl.kind_of?(DataLink) ? dl : DataLink.new(dl)
-      @snaplen  = opts[:snaplen] || DEFAULT_SNAPLEN
-      @pcap = FFI::PCap.pcap_open_dead(@datalink.value, @snaplen)
-      raise(LibError, "pcap_open_dead(): returned a null pointer") if @pcap.null?
-      super(@pcap, opts, &block)
-    end
-  end
+    class Dead < CommonWrapper
 
-  attach_function :pcap_open_dead, [:int, :int], :pcap_t
+      attr_reader :datalink
 
-end
+      #
+      # Creates a fake pcap interface for compiling filters or opening a
+      # capture for output.
+      #
+      # @param [Hash] opts
+      #   Options are ignored and passed to the super-class except those
+      #   below.
+      #
+      # @option opts [optional, String, Symbol, Integer] :datalink
+      #   The link-layer type for pcap. nil is equivalent to 0
+      #   (aka DLT_NULL).
+      #
+      # @option opts [optional, Integer] :snaplen
+      #   The snapshot length for the pcap object.
+      #   Defaults to FFI::PCap::DEFAULT_SNAPLEN
+      #
+      # @return [Dead]
+      #   A FFI::PCap::Dead wrapper.
+      #
+      def initialize(opts={}, &block)
+        dl = opts[:datalink] || DataLink.new(0)
+
+        @datalink = dl.kind_of?(DataLink) ? dl : DataLink.new(dl)
+        @snaplen  = opts[:snaplen] || DEFAULT_SNAPLEN
+        @pcap = PCap.pcap_open_dead(@datalink.value, @snaplen)
+
+        if @pcap.null?
+          raise(LibError,"pcap_open_dead(): returned a null pointer",caller)
+        end
+
+        super(@pcap, opts, &block)
+      end
+
+    end
+
+    attach_function :pcap_open_dead, [:int, :int], :pcap_t
+  end
 end

data/lib/ffi/pcap/dumper.rb

@@ -1,55 +1,53 @@
-
 module FFI
-module PCap
+  module PCap
+    #
+    # See `pcap_dumper_t` in `pcap.h`.
+    #
+    # A `pcap_dumper`, {Dumper} is handled opaquely so that it can
+    # be implemented differently on different platforms. In {PCap}, we
+    # simply wrap the `pcap_dumper_t` pointer with a ruby interface.
+    #
+    class Dumper
+
+      def initialize(dumper)
+        @dumper = dumper
+      end
 
-  # See pcap_dumper_t in pcap.h
-  #
-  # A pcap_dumper, or FFI::PCap::Dumper is handled opaquely so that it can
-  # be implemented differently on different platforms. In FFI::PCap, we
-  # simply wrap the pcap_dumper_t pointer with a ruby interface.
-  class Dumper
+      def _write(header, bytes)
+        PCap.pcap_dump(@dumper, header, bytes)
+      end
 
-    def initialize(dumper)
-      @dumper = dumper
-    end
+      def write(*args)
+        case args.first
+        when Packet then write_pkt(*args)
+        else             _write(*args)
+        end
+      end
 
-    def _write(header, bytes)
-      FFI::PCap.pcap_dump(@dumper, header, bytes)
-    end
+      def write_pkt(pkt)
+        _write(pkt.header, pkt.body_ptr)
+      end
 
-    def write(*args)
-      if args.first.is_a? Packet
-        write_pkt(*args)
-      else
-        _write(*args)
+      def tell
+        PCap.pcap_dump_ftell(@dumper)
       end
-    end
 
-    def write_pkt(pkt)
-      _write(pkt.header, pkt.body_ptr)
-    end
+      def flush
+        PCap.pcap_dump_flush(@dumper)
+      end
 
-    def tell
-      FFI::PCap.pcap_dump_ftell(@dumper)
-    end
+      def close
+        PCap.pcap_dump_close(@dumper)
+      end
 
-    def flush
-      FFI::PCap.pcap_dump_flush(@dumper)
     end
 
-    def close
-      FFI::PCap.pcap_dump_close(@dumper)
-    end
+    # XXX not sure if we even want file FILE IO stuff yet
+    #attach_function :pcap_dump_file, [:pcap_dumper_t], :FILE
 
+    attach_function :pcap_dump_ftell, [:pcap_dumper_t], :long
+    attach_function :pcap_dump_flush, [:pcap_dumper_t], :int
+    attach_function :pcap_dump_close, [:pcap_dumper_t], :void
+    attach_function :pcap_dump, [:pointer, PacketHeader, :pointer], :void
   end
-
-  # XXX not sure if we even want file FILE IO stuff yet
-  #attach_function :pcap_dump_file, [:pcap_dumper_t], :FILE
-
-  attach_function :pcap_dump_ftell, [:pcap_dumper_t], :long
-  attach_function :pcap_dump_flush, [:pcap_dumper_t], :int
-  attach_function :pcap_dump_close, [:pcap_dumper_t], :void
-  attach_function :pcap_dump, [:pointer, PacketHeader, :pointer], :void
-
 end
-end

data/lib/ffi/pcap/error_buffer.rb

@@ -1,44 +1,29 @@
 module FFI
-module PCap
-  class ErrorBuffer < FFI::MemoryPointer
+  module PCap
+    class ErrorBuffer < FFI::Buffer
 
-    # Size of the error buffers
-    SIZE = 256
+      # Size of the error buffers
+      SIZE = 256
 
-    #  Creates a new ErrorBuffer object. Because of wierdness in JRuby
-    #  when trying to subclass FFI::Buffer, always use this instead of 
-    #  'new()'
-    #
-    #  See http://github.com/ffi/ffi/issues#issue/27
-    def self.create()
-      new(SIZE)
-    end
-
-    #
-    # Creates a new ErrorBuffer object.
-    # The argument is nil and is only present for compatability with JRuby.
-    #
-    # See http://github.com/ffi/ffi/issues#issue/27
-    def initialize(arg=nil)
-      super(SIZE)
-    end
-
-    #
-    # Returns the error message within the error buffer.
-    #
-    def to_s
-      get_string(0)
-    end
+      #
+      # Creates a new {ErrorBuffer} object.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to an existing {ErrorBuffer}.
+      #
+      def initialize(ptr=nil)
+        if ptr then super(ptr)
+        else        super(SIZE)
+        end
+      end
 
-    # Older JRuby/ffi versions of MemoryPointer and Buffer don't have a size 
-    # method. We override it here to ensure we can use it.
-    def size
-      begin
-        super()
-      rescue NoMethodError
-        SIZE
+      #
+      # Returns the error message within the error buffer.
+      #
+      def to_s
+        get_string(0)
       end
+
     end
   end
 end
-end

data/lib/ffi/pcap/exceptions.rb

@@ -1,21 +1,27 @@
 module FFI
-module PCap
-  # A FFI::PCap::UnsupportedDataLinkError indicates an invalid or unsupported
-  # DataLink Layer Type (DLT) value or name.
-  class UnsupportedDataLinkError < StandardError
-  end
+  module PCap
+    #
+    # A {UnsupportedDataLinkError} indicates an invalid or
+    # unsupported DataLink Layer Type (DLT) value or name.
+    #
+    class UnsupportedDataLinkError < StandardError
+    end
 
-  # A FFI::PCap::LibError is used to convey errors detected by the libpcap
-  # native library.
-  class LibError < StandardError
-  end
+    #
+    # A {LibError} is used to convey errors detected by the libpcap
+    # native library.
+    #
+    class LibError < StandardError
+    end
 
-  # A FFI::PCap::ReadError is a sub-class of FFI::PCap::LibError that indicates a 
-  # problem reading from a pcap device.
-  class ReadError < LibError
-  end
+    #
+    # A {ReadError} is a sub-class of {LibError} that
+    # indicates a problem reading from a pcap device.
+    #
+    class ReadError < LibError
+    end
 
-  class TimeoutError < LibError
+    class TimeoutError < LibError
+    end
   end
 end
-end

data/lib/ffi/pcap/file_header.rb

@@ -1,26 +1,32 @@
+require 'ffi/pcap/typedefs'
+require 'ffi/pcap/data_link'
+
+require 'ffi_dry'
 
 module FFI
-module PCap
-  class FileHeader < FFI::Struct
-    include FFI::DRY::StructHelper
+  module PCap
+    class FileHeader < FFI::Struct
 
-    dsl_layout do
-      field :magic,         :bpf_uint32
-      field :version_major, :ushort
-      field :version_minor, :ushort
-      field :thiszone,      :bpf_int32
-      field :sigfigs,       :bpf_uint32
-      field :snaplen,       :bpf_uint32
-      field :linktype,      :bpf_uint32
-    end
+      include FFI::DRY::StructHelper
 
-    def datalink
-      DataLink.new(self.linktype)
-    end
+      dsl_layout do
+        field :magic,         :bpf_uint32
+        field :version_major, :ushort
+        field :version_minor, :ushort
+        field :thiszone,      :bpf_int32
+        field :sigfigs,       :bpf_uint32
+        field :snaplen,       :bpf_uint32
+        field :linktype,      :bpf_uint32
+      end
+
+      def datalink
+        @data_link ||= DataLink.new(self.linktype)
+      end
+
+      def version
+        "#{self.version_major}.#{self.version_minor}"
+      end
 
-    def version
-      "#{self.version_major}.#{self.version_minor}"
     end
   end
 end
-end

data/lib/ffi/pcap/in_addr.rb

@@ -1,9 +1,9 @@
 module FFI
-module PCap
-  class InAddr < FFI::Struct
+  module PCap
+    class InAddr < FFI::Struct
 
-    layout :s_addr, [NativeType::UINT8, 4]
+      layout :s_addr, [:uint8, 4]
 
+    end
   end
 end
-end

data/lib/ffi/pcap/interface.rb

@@ -1,29 +1,31 @@
+require 'ffi/pcap/typedefs'
 
 module FFI
-module PCap
+  module PCap
+    #
+    # Item in a list of interfaces.
+    #
+    # See `pcap_if` struct in `pcap.h`.
+    #
+    class Interface < FFI::Struct
 
-  # Item in a list of interfaces.
-  #
-  # See pcap_if struct in pcap.h
-  class Interface < FFI::Struct
-    include FFI::DRY::StructHelper
+      include FFI::DRY::StructHelper
 
-    # interface is loopback
-    LOOPBACK = 0x00000001
+      # interface is loopback
+      LOOPBACK = 0x00000001
 
-    dsl_layout do
-      p_struct  :next, ::FFI::PCap::Interface
-      field     :name,        :string, :desc => 'name used by pcap_open_live()'
-      field     :description, :string, :desc => 'text description, or NULL'
-      p_struct  :addresses, ::FFI::PCap::Addr,    :desc => 'address linked list'
-      field     :flags,   :bpf_uint32, :desc => 'PCAP_IF_ interface flags'
-    end
+      dsl_layout do
+        p_struct  :next, ::FFI::PCap::Interface
+        field     :name,        :string, :desc => 'name used by pcap_open_live()'
+        field     :description, :string, :desc => 'text description, or NULL'
+        p_struct  :addresses, ::FFI::PCap::Addr,    :desc => 'address linked list'
+        field     :flags,   :bpf_uint32, :desc => 'PCAP_IF_ interface flags'
+      end
 
-    def loopback?
-      self.flags & LOOPBACK == LOOPBACK
-    end
+      def loopback?
+        self.flags & LOOPBACK == LOOPBACK
+      end
 
+    end
   end
-
-end
 end

data/lib/ffi/pcap/live.rb

@@ -1,303 +1,347 @@
 require 'ffi/pcap/capture_wrapper'
 
 module FFI
-module PCap
-  begin
-    attach_function :pcap_setdirection, [:pcap_t, :pcap_direction_t], :int
-  rescue FFI::NotFoundError
-  end
+  module PCap
+    begin
+      attach_function :pcap_setdirection, [:pcap_t, :pcap_direction_t], :int
+    rescue FFI::NotFoundError
+    end
 
-  begin
-    attach_function :pcap_sendpacket, [:pcap_t, :pointer, :int], :int
-  rescue FFI::NotFoundError
-  end
+    begin
+      attach_function :pcap_sendpacket, [:pcap_t, :pointer, :int], :int
+    rescue FFI::NotFoundError
+    end
 
-  begin
-    attach_function :pcap_inject, [:pcap_t, :pointer, :int], :int
-  rescue FFI::NotFoundError
-  end
+    begin
+      attach_function :pcap_inject, [:pcap_t, :pointer, :int], :int
+    rescue FFI::NotFoundError
+    end
 
+    class Live < CaptureWrapper
+
+      DEFAULT_TO_MS = 1000     # Default timeout for pcap_open_live()
+
+      attr_reader :device, :promisc, :timeout, :direction
+
+      #
+      # Creates a pcap interface for capturing from the network.
+      #
+      # @param [Hash] opts
+      #   Options are ignored and passed to the super-class except those
+      #   below.
+      #
+      # @option opts [String, nil] :device, :dev
+      #   The device to open. On some platforms, this can be "any".
+      #   If nil or unspecified {PCap.lookupdev} is called to obtain a
+      #   default device. 
+      #
+      # @option opts [Integer] :snaplen
+      #   The snapshot length for the pcap object.
+      #   Defaults to DEFAULT_SNAPLEN
+      #
+      # @option opts [Boolean] :promisc
+      #   Specifies if the interface is to be put into promiscuous mode.
+      #   Defaults to false.
+      #
+      # @option opts [Integer] :timeout
+      #   Specifies the read timeout in milliseconds.
+      #   Defaults to DEFAULT_TO_MS
+      #
+      # @return [Live]
+      #   A live wrapper.
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant error 
+      #   message from libpcap.
+      #
+      # @raise [ArgumentError]
+      #   May raise an exception if a :device cannot be autodetected using 
+      #   {PCap.lookupdev} for any reason. This should never happen on
+      #   most platforms.
+      #
+      def initialize(opts=nil)
+        opts ||= {}
+
+        @device = (opts[:device] || opts[:dev] || PCap.lookupdev)
+
+        unless @device
+          raise(ArgumentError,"Couldn't detect a device. One must be specified",caller)
+        end
 
-  # Creates a pcap interface for capturing from the network.
-  #
-  # @param [Hash] opts
-  #   Options are ignored and passed to the super-class except those below.
-  #
-  # @option opts [String, nil] :device, :dev
-  #   The device to open. On some platforms, this can be "any". If nil or 
-  #   unspecified FFI::PCap.lookupdev() is called to obtain a default device. 
-  #
-  # @option opts [Integer] :snaplen
-  #   The snapshot length for the pcap object. Defaults to DEFAULT_SNAPLEN
-  #
-  # @option opts [Boolean] :promisc
-  #   Specifies if the interface is to be put into promiscuous mode. Defaults
-  #   to false.
-  #
-  # @option opts [Integer] :timeout
-  #   Specifies the read timeout in milliseconds. Defaults to DEFAULT_TO_MS
-  #
-  # @return [Live]
-  #   A FFI::PCap::Live wrapper.
-  #
-  # @raise [LibError]
-  #   On failure, an exception is raised with the relevant error 
-  #   message from libpcap.
-  #
-  # @raise [ArgumentError]
-  #   May raise an exception if a :device cannot be autodetected using 
-  #   FFI::PCap.lookupdev() for any reason. This should never happen on most platforms.
-  #
-  class Live < CaptureWrapper
-    DEFAULT_TO_MS = 1000     # Default timeout for pcap_open_live()
-
-    attr_reader :device, :promisc, :timeout, :direction
-
-    def initialize(opts=nil)
-      opts ||= {}
-      @device = opts[:device] || opts[:dev] || FFI::PCap.lookupdev()
-      unless @device
-        raise(ArgumentError, "Couldn't detect a device. One must be specified.")
-      end
+        @snaplen   = opts[:snaplen] || DEFAULT_SNAPLEN
+        @promisc   = opts[:promisc] ? 1 : 0
+        @timeout   = opts[:timeout] || DEFAULT_TO_MS
+        @direction = (opts[:direction] || opts[:dir])
 
-      @snaplen   = opts[:snaplen] || DEFAULT_SNAPLEN
-      @promisc   = opts[:promisc] ? 1 : 0
-      @timeout   = opts[:timeout] || DEFAULT_TO_MS
-      @direction = (opts[:direction] || opts[:dir])
+        @errbuf = ErrorBuffer.new
+        @pcap   = PCap.pcap_open_live(@device, @snaplen, @promisc, @timeout, @errbuf)
 
-      @errbuf = ErrorBuffer.create()
-      @pcap = FFI::PCap.pcap_open_live(@device, @snaplen, @promisc, @timeout, @errbuf)
-      raise(LibError, "pcap_open_live(): #{@errbuf.to_s}") if @pcap.null?
+        if @pcap.null?
+          raise(LibError, "pcap_open_live(): #{@errbuf}",caller)
+        end
 
-      # call super to get all our ducks in a row
-      super(@pcap, opts)
+        # call super to get all our ducks in a row
+        super(@pcap, opts)
+
+        set_direction(@direction) if @direction
+
+        # Cache network and netmask from pcap_lookupdev.
+        # These pointers may be used internally (and should get autoreleased)
+        @netp, @maskp = nil
+        begin
+          PCap.lookupnet(@device) do |netp, maskp|
+            @netp = netp
+            @maskp = maskp
+          end
+        rescue LibError
+          warn "Warning: #{$!}"
+        end
 
-      set_direction(@direction) if @direction
+        yield self if block_given?
+      end
 
-      # Cache network and netmask from pcap_lookupdev.
-      # These pointers may be used internally (and should get autoreleased)
-      @netp, @maskp = nil
-      begin
-        FFI::PCap.lookupnet(@device) do |netp, maskp|
-          @netp = netp
-          @maskp = maskp
+      #
+      # Returns the dotted notation string for the IPv4 network address for 
+      # the device used by this pcap interface.
+      #
+      def network
+        if @netp
+          @network ||= @netp.get_array_of_uchar(0,4).join('.')
         end
-      rescue LibError
-        warn "Warning: #{$!}"
       end
 
-      yield self if block_given?
-    end
+      #
+      # Returns the dotted notation string for the IPv4 netmask for the
+      # device used by this pcap interface.
+      #
+      def netmask
+        if @maskp
+          @netmask ||= @maskp.get_array_of_uchar(0,4).join('.')
+        end
+      end
 
-    # Returns the dotted notation string for the IPv4 network address for 
-    # the device used by this pcap interface.
-    def network
-      return nil unless @netp
-      @network ||= @netp.get_array_of_uchar(0,4).join('.')
-    end
+      #
+      # Returns the 32-bit numeric representation of the IPv4 network
+      # address for this device.
+      #
+      def network_n32
+        if @netp
+          ::FFI::DRY::NetEndian.ntohl(@netp.get_uint32(0))
+        end
+      end
 
-    # Returns the dotted notation string for the IPv4 netmask for the device
-    # used by this pcap interface.
-    def netmask
-      return nil unless @maskp
-      @netmask ||= @maskp.get_array_of_uchar(0,4).join('.')
-    end
+      #
+      # Returns the 32-bit numeric representation of the IPv4 network
+      # address for this device.
+      #
+      def netmask_n32
+        if @maskp
+          ::FFI::DRY::NetEndian.ntohl(@maskp.get_uint32(0))
+        end
+      end
 
-    # Returns the 32-bit numeric representation of the IPv4 network address
-    # for this device.
-    def network_n32
-      return nil unless @netp
-      ::FFI::DRY::NetEndian.ntohl(@netp.get_uint32(0))
-    end
+      @@have_setdirection = PCap.respond_to?(:pcap_setdirection)
 
-    # Returns the 32-bit numeric representation of the IPv4 network address
-    # for this device.
-    def netmask_n32
-      return nil unless @maskp
-      ::FFI::DRY::NetEndian.ntohl(@maskp.get_uint32(0))
-    end
+      #
+      # Sets the direction for which packets will be captured.
+      # 
+      # (Not supported on all platforms)
+      #
+      def set_direction(dir)
+        unless @@have_setdirection
+          raise(NotImplementedError,"pcap_setdirection() is not avaiable from your pcap library",caller) 
+        end
 
-    @@have_setdirection = FFI::PCap.respond_to?(:pcap_setdirection)
+        dirs = PCap.enum_type(:pcap_direction_t)
 
-    # Sets the direction for which packets will be captured.
-    # 
-    # (Not supported on all platforms)
-    def set_direction(dir)
-      unless @@have_setdirection
-        raise(NotImplementedError, 
-              "pcap_setdirection() is not avaiable from your pcap library") 
+        if PCap.pcap_setdirection(_pcap, dirs[:"pcap_d_#{dir}"]) == 0
+          return true
+        else
+          raise(LibError,"pcap_setdirection(): #{geterr}",caller)
+        end
       end
 
-      dirs = FFI::PCap.enum_type(:pcap_direction_t)
-      if FFI::PCap.pcap_setdirection(_pcap, dirs[:"pcap_d_#{dir}"]) == 0
-        return true
-      else
-        raise(LibError, "pcap_setdirection(): #{geterr()}", caller)
+      alias direction= set_direction
+
+      #
+      # set the state of non-blocking mode on a capture device
+      #
+      # @param [Boolean] mode
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant error
+      #   message from libpcap.
+      #
+      def set_non_blocking(mode)
+        mode =  mode ? 1 : 0
+
+        if PCap.pcap_setnonblock(_pcap, mode, @errbuf) == 0
+          return (mode == 1)
+        else
+          raise(LibError,"pcap_setnonblock(): #{@errbuf}",caller)
+        end
       end
-    end
 
-    alias direction= set_direction
-
-    # set the state of non-blocking mode on a capture device
-    #
-    # @param [Boolean] mode
-    #
-    # @raise [LibError]
-    #   On failure, an exception is raised with the relevant error message 
-    #   from libpcap.
-    #
-    def set_non_blocking(mode)
-      mode =  mode ? 1 : 0
-      if FFI::PCap.pcap_setnonblock(_pcap, mode, @errbuf) == 0
-        return mode == 1
-      else
-        raise(LibError, "pcap_setnonblock(): #{@errbuf.to_s}", caller)
+      alias non_blocking= set_non_blocking
+      alias nonblocking= set_non_blocking
+
+      #
+      # get the state of non-blocking mode on a capture device
+      #
+      # @return [Boolean]
+      #   non-blocking mode
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant error
+      #   message from libpcap.
+      #
+      def non_blocking
+        mode = PCap.pcap_getnonblock(_pcap, @errbuf)
+
+        if mode == -1
+          raise(LibError,"pcap_getnonblock(): #{@errbuf}",caller)
+        else
+          return mode == 1
+        end
       end
-    end
 
-    alias non_blocking= set_non_blocking
-
-    # get the state of non-blocking mode on a capture device
-    #
-    # @return [Boolean]
-    #   non-blocking mode
-    #
-    # @raise [LibError]
-    #   On failure, an exception is raised with the relevant error message 
-    #   from libpcap.
-    #
-    def non_blocking
-      if (mode=FFI::PCap.pcap_getnonblock(_pcap, @errbuf)) == -1
-        raise(LibError, "pcap_getnonblock(): #{@errbuf.to_s}", caller)
-      else
-        return mode == 1
+      alias non_blocking? non_blocking
+
+      #
+      # Get capture statistics
+      #
+      # @return [Stats]
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant error
+      #   message from libpcap.
+      #
+      def stats
+        stats = Stat.new
+
+        unless PCap.pcap_stats(_pcap, stats) == 0
+          raise(LibError,"pcap_stats(): #{geterr}",caller)
+        end
+
+        return stats
       end
-    end
 
-    alias non_blocking? non_blocking
-
-    # Get capture statistics
-    #
-    # @return [Stats]
-    #
-    # @raise [LibError]
-    #   On failure, an exception is raised with the relevant error message 
-    #   from libpcap.
-    #
-    def stats
-      stats = Stat.new
-      unless FFI::PCap.pcap_stats(_pcap, stats) == 0
-        raise(LibError, "pcap_stats(): #{geterr()}")
+      @@have_inject = PCap.respond_to?(:pcap_inject)
+
+      #
+      # Transmit a packet using pcap_inject()
+      #
+      # (not available on all platforms)
+      #
+      # @param [Packet, String] obj
+      #   The packet to send. This can be a Packet or String object.
+      #
+      # @return [Integer]
+      #   The number of bytes sent.
+      #
+      # @raise [ArgumentError]
+      #   An exception is raised if the pkt object type is incorrect or
+      #   if it is a Packet and the body pointer is null. 
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant libpcap
+      #   error message.
+      #
+      # @raise [NotImplementedError]
+      #   If the pcap_inject() function is not available from your libpcap
+      #   library pcap_sendpacket will be tried, if both are missing, this 
+      #   exception will be raised.
+      #
+      def inject(pkt)
+        if @@have_inject
+          if pkt.kind_of?(Packet)
+            len = pkt.caplen
+            bufp = pkt.body_ptr
+
+            if bufp.null?
+              raise(ArgumentError,"packet data null pointer",caller)
+            end
+          elsif pkt.kind_of?(String)
+            len = pkt.size
+            bufp = FFI::MemoryPointer.from_string(pkt)
+          else
+            raise(ArgumentError,"Don't know how to inject #{pkt.class}",caller)
+          end
+
+          sent = PCap.pcap_inject(_pcap, bufp, len)
+
+          if sent < 0
+            raise(LibError,"pcap_inject(): #{geterr}",caller)
+          end
+
+          return sent
+        else 
+          # fake it with sendpacket on windows
+          if sendpacket(pkt)
+            return (Packet === pkt) ? pkt.caplen : pkt.size
+          end
+        end
       end
-      return stats
-    end
 
+      @@have_sendpacket = PCap.respond_to?(:pcap_sendpacket)
+
+      #
+      # Transmit a packet using pcap_sendpacket()
+      #
+      # (not available on all platforms)
+      #
+      # @param [Packet, String] obj
+      #   The packet to send. This can be a Packet or String object.
+      #
+      # @return [True]
+      #   True is returned on success. Otherwise an exception is raised.
+      #
+      # @raise [ArgumentError]
+      #   An exception is raised if the pkt object type is incorrect or
+      #   if it is a Packet and the body pointer is null. 
+      #
+      # @raise [LibError]
+      #   On failure, an exception is raised with the relevant libpcap
+      #   error message.
+      #
+      # @raise [NotImplementedError]
+      #   If the pcap_sendpacket() function is not available from your
+      #   libpcap library this exception will be raised.
+      #
+      def sendpacket(pkt)
+        unless @@have_sendpacket
+          raise(NotImplementedError,"packet injectors are not avaiable from your pcap library",caller)
+        end
 
-    @@have_inject = FFI::PCap.respond_to?(:pcap_inject)
-
-    # Transmit a packet using pcap_inject()
-    #
-    # (not available on all platforms)
-    #
-    # @param [Packet, String] obj
-    #   The packet to send. This can be a Packet or String object.
-    #
-    # @return [Integer]
-    #   The number of bytes sent.
-    #
-    # @raise [ArgumentError]
-    #   An exception is raised if the pkt object type is incorrect or
-    #   if it is a Packet and the body pointer is null. 
-    #
-    # @raise [LibError]
-    #   On failure, an exception is raised with the relevant libpcap
-    #   error message.
-    #
-    # @raise [NotImplementedError]
-    #   If the pcap_inject() function is not available from your libpcap
-    #   library pcap_sendpacket will be tried, if both are missing, this 
-    #   exception will be raised.
-    #
-    def inject(pkt)
-      if @@have_inject
         if pkt.kind_of? Packet
           len = pkt.caplen
           bufp = pkt.body_ptr
-          raise(ArgumentError, "packet data null pointer") if bufp.null?
+
+          if bufp.null?
+            raise(ArgumentError,"packet data null pointer",caller)
+          end
         elsif pkt.kind_of? String
           len = pkt.size
           bufp = FFI::MemoryPointer.from_string(pkt)
         else
-          raise(ArgumentError, "Don't know how to inject #{pkt.class}")
+          raise(ArgumentError,"Don't know how to send #{pkt.class}",caller)
         end
 
-        if (sent=FFI::PCap.pcap_inject(_pcap, bufp, len)) < 0
-          raise(LibError, "pcap_inject(): #{geterr()}")
+        if PCap.pcap_sendpacket(_pcap, bufp, len) != 0
+          raise(LibError,"pcap_sendpacket(): #{geterr}",caller)
         end
-        return sent
-      else 
-        # fake it with sendpacket on windows
-        if sendpacket(pkt)
-          return (Packet === pkt)? pkt.caplen : pkt.size
-        end
-      end
-    end
 
-    @@have_sendpacket = FFI::PCap.respond_to?(:pcap_sendpacket)
-
-    # Transmit a packet using pcap_sendpacket()
-    #
-    # (not available on all platforms)
-    #
-    # @param [Packet, String] obj
-    #   The packet to send. This can be a Packet or String object.
-    #
-    # @return [True]
-    #   True is returned on success. Otherwise an exception is raised.
-    #
-    # @raise [ArgumentError]
-    #   An exception is raised if the pkt object type is incorrect or
-    #   if it is a Packet and the body pointer is null. 
-    #
-    # @raise [LibError]
-    #   On failure, an exception is raised with the relevant libpcap
-    #   error message.
-    #
-    # @raise [NotImplementedError]
-    #   If the pcap_sendpacket() function is not available from your libpcap
-    #   library this exception will be raised.
-    #
-    def sendpacket(pkt)
-      unless @@have_sendpacket
-        raise(NotImplementedError, 
-              "packet injectors are not avaiable from your pcap library") 
+        return true
       end
 
-      if pkt.kind_of? Packet
-        len = pkt.caplen
-        bufp = pkt.body_ptr
-        raise(ArgumentError, "packet data null pointer") if bufp.null?
-      elsif pkt.kind_of? String
-        len = pkt.size
-        bufp = FFI::MemoryPointer.from_string(pkt)
-      else
-        raise(ArgumentError, "Don't know how to send #{pkt.class}")
-      end
+      alias send_packet sendpacket
 
-      if FFI::PCap.pcap_sendpacket(_pcap, bufp, len) != 0
-        raise(LibError, "pcap_sendpacket(): #{geterr()}")
-      end
-      return true
     end
 
-    alias send_packet sendpacket
+    attach_function :pcap_open_live, [:string, :int, :int, :int, :pointer], :pcap_t
+    attach_function :pcap_getnonblock, [:pcap_t, :pointer], :int
+    attach_function :pcap_setnonblock, [:pcap_t, :int, :pointer], :int
+    attach_function :pcap_stats, [:pcap_t, Stat], :int
 
   end
-
-  attach_function :pcap_open_live, [:string, :int, :int, :int, :pointer], :pcap_t
-  attach_function :pcap_getnonblock, [:pcap_t, :pointer], :int
-  attach_function :pcap_setnonblock, [:pcap_t, :int, :pointer], :int
-  attach_function :pcap_stats, [:pcap_t, Stat], :int
-
-end
 end