DIY-pcap 0.0.4 → 0.2.0

data/bin/pcap

@@ -1,10 +1,67 @@
 $LOAD_PATH.unshift File.join( File.dirname(__FILE__), '..', 'lib' )
+require 'rubygems'
 require 'diy-pcap'
 require 'diy/task'
 
-if ARGV[0].nil?
-  puts "Usage: #{File.basename(__FILE__)} file"
-  exit 0
-end
+require 'optparse'
 
-require File.join( Dir.pwd, ARGV[0] )
+options = {
+  :ip => "0.0.0.0:7878",
+}
+
+OptionParser.new do |opts|
+  
+  opts.on("-f file", "File will be parsed") do |v|
+    options[:file] = v
+  end
+  
+  opts.on("-i ip", "--ip ip", "client or server : 0.0.0.0 or 0.0.0.0:7878", "default is 0.0.0.0:7878") do |v|
+    options[:ip] = v
+  end
+  
+  opts.on("-n device_name", "--name device_name", "Send or Recv device name") do |v|
+    options[:device_name] = v
+  end
+  
+  opts.on_tail("--show", "Show all devices name and exit") do 
+    require 'diy/device_finder'
+    DIY::DeviceFinder.pp_devices
+    exit 0
+  end
+  
+  opts.on_tail('-v','--version', 'Show version') do
+    puts DIY::PCAP::VERSION
+    exit 0
+  end
+  
+  opts.on_tail('-V', 'detail mode') do
+    DIY::Logger.level = ::Logger::DEBUG
+  end
+  
+  opts.on_tail('-h','--help', 'Show this help') do
+    puts opts
+    exit 0
+  end
+end.parse!
+
+if options[:file]
+  require File.join( Dir.pwd, options[:file] )
+else
+  ip = options[:ip]
+  if ip.include?(':')
+    uri = "druby://#{ip}"
+  else
+    uri = "druby://#{ip}:7878"
+  end
+  
+  if options[:device_name]
+    device_name = options[:device_name]
+  else
+    require 'diy/device_finder'
+    device_name = DIY::DeviceFinder.smart_select
+  end
+  DIY::Logger.info( "Initialize Live: #{device_name}" )
+  device = FFI::PCap::Live.new(:dev=>device_name, :handler => FFI::PCap::Handler, :promisc => true)
+  worker = DIY::Worker.new(device)
+  DIY::WorkerKeeper.new(worker, uri).run
+end

data/bin/rpcap

@@ -1,12 +1,68 @@
 $LOAD_PATH.unshift File.join( File.dirname(__FILE__), '..', 'lib' )
+require 'rubygems'
 require 'diy-pcap'
 require 'diy/task'
 
-$SERVER = true
+require 'optparse'
 
-if ARGV[0].nil?
-  puts "Usage: #{File.basename(__FILE__)} file"
-  exit 0
-end
+options = {
+  :ip => "0.0.0.0:7879",
+}
 
-require File.join( Dir.pwd, ARGV[0] )
+OptionParser.new do |opts|
+  
+  opts.on("-f file", "File will be parsed") do |v|
+    options[:file] = v
+  end
+  
+  opts.on("-i ip", "--ip ip", "client or server : 0.0.0.0 or 0.0.0.0:7879", "default is 0.0.0.0:7879") do |v|
+    options[:ip] = v
+  end
+  
+  opts.on("-n device_name", "--name device_name", "Send or Recv device name") do |v|
+    options[:device_name] = v
+  end
+  
+  opts.on_tail("--show", "Show all devices name and exit") do 
+    require 'diy/device_finder'
+    DIY::DeviceFinder.pp_devices
+    exit 0
+  end
+  
+  opts.on_tail('-v','--version', 'Show version') do
+    puts DIY::PCAP::VERSION
+    exit 0
+  end
+  
+  opts.on_tail('-V', 'detail mode') do
+    DIY::Logger.level = ::Logger::DEBUG
+  end
+  
+  opts.on_tail('-h','--help', 'Show this help') do
+    puts opts
+    exit 0
+  end
+end.parse!
+
+if options[:file]
+  $SERVER = true
+  require File.join( Dir.pwd, options[:file])
+else
+  ip = options[:ip]
+  if ip.include?(':')
+    uri = "druby://#{ip}"
+  else
+    uri = "druby://#{ip}:7879"
+  end
+  
+  if options[:device_name]
+    device_name = options[:device_name]
+  else
+    require 'diy/device_finder'
+    device_name = DIY::DeviceFinder.smart_select
+  end
+  DIY::Logger.info( "Initialize Live: #{device_name}" )
+  device = FFI::PCap::Live.new(:dev=>device_name, :handler => FFI::PCap::Handler, :promisc => true)
+  worker = DIY::Worker.new(device)
+  DIY::WorkerKeeper.new(worker, uri).run
+end

data/lib/diy/builder.rb

@@ -1,3 +1,4 @@
+require 'drb'
 module DIY
   class Builder
     def initialize(server = false, &block)
@@ -6,16 +7,6 @@ module DIY
       @server = server
     end
     
-    def find_device
-      @device_name ||= FFI::PCap.dump_devices[0][0]
-      DIY::Logger.info( "Initialize Live: #{@device_name}" )
-      @live = FFI::PCap::Live.new(:dev=>@device_name, :handler => FFI::PCap::Handler, :promisc => true)
-    end
-    
-    def device(name)
-      @device_name = name
-    end
-    
     def use(what)
       @strategies.unshift(what)
     end
@@ -24,6 +15,14 @@ module DIY
       @before_send_hook = block
     end
     
+    def find_worker_keepers
+      @curi ||= "druby://localhost:7878"
+      @suri ||= "druby://localhost:7879"
+      DRb.start_service
+      @client = DRbObject.new_with_uri(@curi)
+      @server = DRbObject.new_with_uri(@suri)
+    end
+    
     def pcapfile(pcaps)
       DIY::Logger.info( "Initialize Offline: #{pcaps.to_a.join(', ')}" )
       @offline = DIY::Offline.new(pcaps)
@@ -31,13 +30,12 @@ module DIY
     alias pcapfiles pcapfile
     
     def run
-      @offline ||= FFI::PCap::Offline.new('pcaps/example.pcap')
-      @queue = Queue.new(@offline, @server)
-      @strategy_builder = DIY::StrategyBuilder.new(@queue)
+      @offline ||= DIY::Offline.new('pcaps/example.pcap')
+      @strategy_builder = DIY::StrategyBuilder.new
       @strategies.each { |builder| @strategy_builder.add(builder) }
-      find_device
-      controller = Controller.new( @live, @strategy_builder )
-      controller.before_send(&@before_send_hook)
+      find_worker_keepers
+      controller = Controller.new( @client, @server, @offline, @strategy_builder )
+      #~ controller.before_send(&@before_send_hook)
       controller.run
     end
     

data/lib/diy/controller.rb

@@ -1,46 +1,63 @@
 # encoding : utf-8
+
+require 'timeout'
 module DIY
   class Controller
-    def initialize(live, strategy)
-      @live = live
-      @recver = Recver.new(@live)
-      @recver.add_watcher(strategy)
-      @recver_t = nil
-      @sender = Sender.new(@live)
-      @queue = strategy.queue
-      @logger = DIY::Logger
-    end
-    attr_accessor :logger
-    
-    def before_send(&block)
-      @sender.before_send(&block)
+    def initialize( client, server, offline, strategy)
+      @client = client
+      @server = server
+      @offline = offline
+      @strategy = strategy
     end
     
     def run
-      # 接收线程
-      @recver_t = Thread.new do
-        @recver.run
-      end
+      client = @client
+      server = @server
       
-      begin
-        @queue.do_loop do |pkt|
-          logger.info "send pkt: #{Utils.pp(pkt)}"
-          @sender.inject(pkt)
-        end
-        @recver_t.join
-      rescue HopePacketTimeoutError =>e
-        # next offline
-        DIY::Logger.warn("Timeout: #{e}")
-        old = e
+      #clear
+      client.terminal
+      server.terminal
+      
+      loop do
         begin
-          @queue.clear_and_next_pcap
-          retry
+        pkts = @offline.nexts
+        one_round( client, server, pkts )
+        client, server = server, client
+        rescue HopePacketTimeoutError
+          DIY::Logger.warn( "Timeout: Hope packet is #{pkts[0].inspect} ")
+          @offline.next_pcap
+          client,server = @client, @server
         rescue EOFError
-          @recver.stop
-          raise old
+          client.terminal
+          server.terminal
+          break
+        end
+      end
+    end
+    
+    def one_round( client, server, pkts )
+      @round_count = 0 unless @round_count
+      @round_count += 1
+      DIY::Logger.info "round #{@round_count}: #{client} #{server} #{pkts[0].inspect}:(size= #{pkts.size})"
+      server.ready do |recv_pkt|
+        recv_pkt = Packet.new(recv_pkt)
+        @strategy.call(pkts.first, recv_pkt, pkts)
+      end
+      client.inject(pkts)
+      wait_recv_ok(pkts)
+      server.terminal
+    end
+    
+    def wait_recv_ok(pkts)
+      wait_until { pkts.empty? }
+    end
+    
+    def wait_until( timeout = 20, &block )
+      timeout(timeout, DIY::HopePacketTimeoutError.new("hope packet wait timeout after #{timeout} senconds") ) do
+        loop do
+          break if block.call
+          sleep 0.01
         end
-      rescue EOFError
-        @recver.stop
       end
     end
     

data/lib/diy/device_finder.rb

@@ -0,0 +1,26 @@
+module DIY
+  class DeviceFinder
+    class <<self
+      def smart_select
+        ret = devices.find do |device, net|
+          !device.match(/dialup/) && net != nil
+        end
+        if ret
+          ret[0]
+        else
+          devices[0]
+        end
+      end
+      
+      def pp_devices
+        devices.each do |device, net|
+          printf "%20s\t:\t%s\n", device, net
+        end
+      end
+      
+      def devices
+        FFI::PCap.dump_devices
+      end
+    end
+  end
+end

data/lib/diy/dig.rb

@@ -1,11 +1,12 @@
 require 'diy/exceptions'
 require 'diy/logger'
 require 'diy/utils'
+require 'diy/packet'
 require 'diy/offline'
-require 'diy/recver'
-require 'diy/sender'
-require 'diy/queue'
-require 'diy/strategy'
-require 'diy/strategy_builder'
+require 'diy/builder'
 require 'diy/controller'
-require 'diy/builder'
+require 'diy/strategy_builder'
+require 'diy/strategy'
+
+require 'diy/worker'
+require 'diy/worker_keeper'

data/lib/diy/logger.rb

@@ -34,6 +34,13 @@ module DIY
       
       def set(logger)
         @@logger = logger
+        clear_and_add(logger)
+      end
+      
+      def level=(level)
+        @@logger_container.each do |logger|
+          logger.level = level
+        end
       end
       
       def add(logger)

data/lib/diy/offline.rb

@@ -2,56 +2,126 @@
 
 module DIY
   class Offline
-    def initialize( file_or_files)
-      @file_or_files = file_or_files
-      if file_or_files.kind_of?(String)
-        @off = FFI::PCap::Offline.new(file_or_files)
-      elsif file_or_files.kind_of?(Array)
-        raise ZeroOfflineError," no pcap files found " if file_or_files.empty?
-        @off = FFI::PCap::Offline.new(file_or_files[0])
-        @position = 0
-      end
-      @new_pcap = true
+    def initialize( pcap_files )
+      @pcap_files = [ pcap_files ] if pcap_files.kind_of?(String)
+      @pcap_files ||= pcap_files
+      @off = FFI::PCap::Offline.new(@pcap_files[0])
+      # 记录文件在目录中的位置
+      @position = 0
+      # 记录包在当前文件的位置
       @num = 0
+      
+      @tmp_pcap = nil
     end
     
-    def next
-      pkt = @off.next
+    def nexts
+      ret = []
+      # 取一个
+      pkt = fetch_one
       if pkt.nil?
-        begin
-          next_pcap
-          pkt = @off.next
-        rescue EOFError
-          pkt = nil
+        next_pcap
+        pkt = fetch_one
+      end
+      
+      ret << pkt
+      op = "=="
+      if ! fetch_cached_mac
+        cached_mac(pkt)
+      else
+        if Utils.src_mac(pkt) != fetch_cached_mac
+          op = "!="
         end
       end
       
-      #record num of pkt
-      @num += 1 if pkt
+      loop do
+        pkt = self.next
+        if pkt.nil?
+          return ret
+        end
+        
+        if compare_mac( op, Utils.src_mac(pkt), fetch_cached_mac)
+          ret << pkt
+        else
+          cached(pkt)
+          return ret
+        end
+        
+      end
       
+    end
+    
+    def compare_mac( op, mac1, mac2)
+      if op == "=="
+        mac1 == mac2
+      elsif op == "!="
+        mac1 != mac2
+      else
+        raise "error op"
+      end
+    end
+    
+    def fetch_one
+      pkt = fetch_cache
+      if pkt.nil?
+        pkt = self.next
+      end
       pkt
     end
+    protected
+    # 只处理当前文件
+    def next
+      pkt = @off.next
+      @num += 1
+      return nil if pkt.nil?
+
+      return Packet.new(pkt.copy.body, fullname)
+    end
+    
+    def cached(pkt)
+      raise "Can't cached one pkt twice" if @tmp_pcap
+      @tmp_pcap = pkt
+    end
+    
+    def cached_mac(pkt)
+      @src = Utils.src_mac(pkt)
+    end
+    
+    def fetch_cached_mac
+      @src
+    end
+    
+    def clear_cached_mac
+      @src = nil
+    end
+    
+    def fetch_cache
+      if @tmp_pcap
+        tmp = @tmp_pcap
+        @tmp_pcap = nil
+        return tmp
+      end
+      return nil
+    end
     
     def first_pkt?
+      puts @num
       @num == 1
     end
-    
+    public
     def next_pcap
-      if @file_or_files.kind_of?(String) or @position >= @file_or_files.size - 1
+      if @position >= @pcap_files.size - 1
         raise EOFError, " end of pcaps "
       end
       @position += 1
-      DIY::Logger.info("pcap file changed: #{@file_or_files[@position]}")
-      @off = FFI::PCap::Offline.new(@file_or_files[@position])
+      DIY::Logger.info("pcap file changed: #{@pcap_files[@position]}")
+      @off = FFI::PCap::Offline.new(@pcap_files[@position])
       @num = 0
+      clear_cached_mac
+      fetch_cache
     end
     
     def filename
-      if @file_or_files.kind_of?(String)
-        @file_or_files
-      else
-        @file_or_files[@position]
-      end
+      @pcap_files[@position]
     end
     
     def fullname