DIY-pcap 0.0.4 → 0.2.0

data/lib/diy/packet.rb

@@ -0,0 +1,17 @@
+module DIY
+  class Packet
+    def initialize( content, detail_msg = nil )
+      @content = content
+      @detail_msg = detail_msg
+    end
+    attr_reader :content, :detail_msg
+    
+    def to_s
+      @content
+    end
+    
+    def inspect
+      "#{Utils.pp(@content)} : from #{@detail_msg}"
+    end
+  end
+end

data/lib/diy/pcap.rb

@@ -17,15 +17,20 @@ module DIY
     attr_accessor :timeout, :dir, :device_name
     
     def send(pkt_dir)
-      @pkt_stack << Packet.new( pkt_dir2pkt(pkt_dir), Packet::SEND)
+      @pkt_stack << PacketEx.new( pkt_dir2pkt(pkt_dir), PacketEx::SEND, pkt_dir)
     end
     
     def recv(pkt_dir)
-      @pkt_stack << Packet.new( pkt_dir2pkt(pkt_dir), Packet::RECV)
+      @pkt_stack << PacketEx.new( pkt_dir2pkt(pkt_dir), PacketEx::RECV, pkt_dir)
     end
     
     def pkt_dir2pkt(dir)
-      File.read( File.join( @dir, dir ) )
+      #~ File.read( File.join( @dir, dir ) )
+      ret = ""
+      File.open( File.join( @dir, dir), "rb") do |f|
+        ret += f.read(65535) until f.eof?
+      end
+      ret
     end
     
     def run
@@ -44,9 +49,9 @@ module DIY
     def run_client
       @pkt_stack.each do |pkt|
         if pkt.to_outer?
-          send_pkt(pkt.pkt)
+          send_pkt(pkt)
         else
-          recv_pkt(pkt.pkt)
+          recv_pkt(pkt)
         end
       end
     end
@@ -54,33 +59,46 @@ module DIY
     def run_server
       @pkt_stack.each do |pkt|
         if pkt.to_inner?
-          send_pkt(pkt.pkt)
+          send_pkt(pkt)
         else
-          recv_pkt(pkt.pkt)
+          recv_pkt(pkt)
         end
       end
     end
     
     def send_pkt(pkt)
       sleep 1
-      logger.info("send pkt: [ #{Time.now} ]#{pkt[0..10].dump}...")
-      @driver.inject(pkt)
+      logger.info("send pkt: [ #{Time.now} ]#{pkt.pkt[0..10].dump}(file: #{pkt.filename}, size: #{pkt.size})...")
+      pkt = pkt.pkt
+      pkt = fill60(pkt)
+      @driver.send_packet(pkt)
     end
     
     def recv_pkt(pkt)
-      logger.info("I hope pkt: #{pkt[0..10].dump}")
+      logger.info("I hope pkt: #{pkt.pkt[0..10].dump}(file: #{pkt.filename}, size: #{pkt.size})...")
+      pkt = pkt.pkt
+      pkt = fill60(pkt)
       @driver.loop do |this, new_pkt|
         #~ logger.info("recv pkt: [ #{new_pkt.time} ]: #{new_pkt.body[0..10].dump}..." )
-        if new_pkt.body == pkt
-          logger.info("recv pkt: [ #{new_pkt.time} ]: #{new_pkt.body[0..10].dump}..." )
-          logger.info "got the same pkt,stop"
+        new_pkt_body = fill60(new_pkt.body)
+        if new_pkt_body == pkt
+          logger.info("recv pkt: [ #{new_pkt.time} ]: #{new_pkt_body[0..10].dump}..." )
+          logger.info "got the same pkt,next"
           return true
         end
       end
     end
     
+    def fill60(pkt)
+      if pkt.size < 60
+        logger.debug "pkt size #{pkt.size} less than 60, fill with zero"
+        pkt += "0" * (60 - pkt.size)
+      end
+      pkt
+    end
+    
     def logger
-      @@logger ||= Logger.new(STDOUT)
+      @@logger ||= DIY::Logger
     end
     
     def logger=(logger)
@@ -89,12 +107,13 @@ module DIY
     
   end
   
-  class Packet
+  class PacketEx
     SEND = 1
     RECV = 0
-    def initialize( pkt, pos )
+    def initialize( pkt, pos, filename = nil )
       @pkt = pkt
       @pos = pos
+      @filename = filename
     end
     
     def to_outer?
@@ -105,6 +124,10 @@ module DIY
       @pos == RECV
     end
     
-    attr_reader :pkt, :pos
+    def size
+      @pkt.size
+    end
+    
+    attr_reader :pkt, :pos, :filename
   end
 end

data/lib/diy/strategy_builder.rb

@@ -2,10 +2,9 @@
 require 'logger'
 module DIY
   class StrategyBuilder
-    def initialize(queue)
+    def initialize
       @ins = []
       @logger = DIY::Logger
-      @queue = queue
     end
     attr_reader :queue
     
@@ -22,27 +21,21 @@ module DIY
       @logger
     end
     
-    def recv_pkt(pkt)
-      recv_pkt_queue(queue,pkt)
-    end
-    
-    def recv_pkt_queue(queue, recv_pkt)
-      hope_pkt = queue.peek
-      logger.debug("recv_pkt, I hope: #{ hope_pkt[0..10].dump rescue nil }...")
+    def call(hope_pkt, recv_pkt, queue)
+      logger.debug("recv_pkt, I hope: #{ Utils.pp(hope_pkt) rescue nil }...")
       
       return if hope_pkt.nil?
       
       @ins.each do |strategy|
         begin
-        ret = strategy.call(hope_pkt, recv_pkt, queue)
+          ret = strategy.call(hope_pkt.content, recv_pkt.content, queue)
         rescue Exception => e
           logger.error("user strategy exception: #{e.class} -> #{e.message}")
           raise
-          #TODO 也许仅仅忽略?
         else
           if ret == Strategy::OK
             logger.info("pkt same:")
-            queue.pop
+            queue.shift
             return
           elsif ret == Strategy::OK_NO_POP
             logger.info("pkt skip:")

data/lib/diy/utils.rb

@@ -3,17 +3,29 @@ module DIY
     class << self
       # 漂亮输出包的前十个内容
       def pp(pkt)
+        pkt = pkt.content if pkt.kind_of?(DIY::Packet)
         return nil if pkt.nil?
         ( pkt[0..10] + "..." ).dump
       end
       
       def src_mac(pkt)
+        pkt = pkt.content if pkt.kind_of?(DIY::Packet)
         pkt[6..11]
       end
       
       def dst_mac(pkt)
+        pkt = pkt.content if pkt.kind_of?(DIY::Packet)
         pkt[0..5]
       end
+      
+      def wait_until( timeout = 20, &block )
+        timeout(timeout) do
+          loop do
+            break if block.call
+            sleep 0.01
+          end
+        end
+      end
     end
   end
 end

data/lib/diy/version.rb

@@ -1,5 +1,5 @@
-module DIY
-  class PCAP
-    VERSION = "0.0.4"
-  end
-end
+module DIY
+  class PCAP
+    VERSION = "0.2.0"
+  end
+end

data/lib/diy/worker.rb

@@ -0,0 +1,49 @@
+# encoding : utf-8
+require 'diy/packet'
+require 'drb'
+module DIY
+  include DRbUndumped
+  class Worker
+    def initialize(live)
+      @live = live
+      @recv_t = nil
+      @start = false
+      loop_recv
+    end
+  
+    # 发包
+    def inject(pkts)
+      pkts.each do |pkt|
+        DIY::Logger.info "send pkt: #{pkt.inspect}"
+        @live.send_packet(pkt.content)
+      end
+    end
+    
+    def loop_recv
+      @recv_t = Thread.new do
+        DIY::Logger.info "start thread recving pkt..."
+        @live.loop do |this, pkt|
+          next unless @start
+          @block.call(pkt.body) if @block
+        end
+      end
+    end
+    
+    #收包
+    def ready(&block)
+      DIY::Logger.info("start recv pkt")
+      @block = block
+      @start = true
+    end
+    
+    def terminal
+      DIY::Logger.info("stop recv pkt")
+      @start = false
+    end
+    
+    def inspect
+      "<Worker: #{@live.net}>"
+    end
+  
+  end
+end

data/lib/diy/worker_keeper.rb

@@ -0,0 +1,25 @@
+# encoding : utf-8
+require 'drb'
+require 'diy/worker'
+
+module DIY
+  # 创建DRb服务
+  class WorkerKeeper
+    def initialize(worker, uri)
+      @worker = worker
+      @uri = uri
+    end
+    
+    def run
+      DIY::Logger.info "serving at #{@uri}"
+      DRb.start_service(@uri, @worker)
+      running = true
+      trap("INT") { running = false }
+      while running
+        sleep 0.5
+      end
+      DIY::Logger.info "bye..."
+      DRb.stop_service
+    end
+  end
+end

data/simple/4000port.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift File.join( File.dirname(__FILE__), '..', 'lib' )
+require 'rubygems'
+require 'diy/pcap'
+
+# client and server
+DIY::PCAP.new do |s|
+  s.dir = File.join( File.dirname(__FILE__), '4000port')
+  s.send("s1.dat")
+  s.recv("r1.dat")
+  s.send("s2.dat")
+  s.send("s3.dat")
+  s.recv("r3.dat")
+  s.send("s4.dat")
+  s.recv("r4.dat")
+  s.send("s5.dat")
+  s.send("s6.dat")
+  s.recv("r6.dat")
+  s.recv("r7.dat")
+  s.send("s8.dat")
+end

data/spec/controller_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe DIY::Builder do
+  
+  before(:each) do
+    @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)
+    @live2 = FFI::PCap::Live.new(:dev=>@device_name, :handler => FFI::PCap::Handler, :promisc => true)
+    
+    @curi = "druby://localhost:7878"
+    @suri = "druby://localhost:7879"
+    
+  end
+    
+  it "#run" do
+    # client create
+    Thread.abort_on_exception = true
+    client_t = Thread.new do
+      client = DIY::Worker.new(@live)
+      DIY::WorkerKeeper.new(client, @curi).run
+    end
+    
+    server_t = Thread.new do
+      server = DIY::Worker.new(@live2)
+      DIY::WorkerKeeper.new(server, @suri).run
+    end
+    
+    sleep 1
+    builder = DIY::Builder.new do
+      pcapfiles "helper/http.pcap"
+      use DIY::SimpleStrategy.new
+    end
+    builder.run
+  end
+end

data/spec/device_finder_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'diy/device_finder'
+
+describe DIY::DeviceFinder do
+  it "#devices" do
+    DIY::DeviceFinder.devices
+  end
+  
+  it "#pp_devices" do
+    DIY::DeviceFinder.pp_devices
+  end
+  
+  it "#smart_select" do
+    DIY::DeviceFinder.smart_select.should be_kind_of(String)
+  end
+end

data/spec/offline_spec.rb

@@ -1,47 +1,44 @@
 require 'spec_helper'
 
 describe DIY::Offline do
-  it "should get single pkt" do
-    file = "helper/gre.pcap"
-    offline = DIY::Offline.new(file)
-    offline.next.body.should == File.read( File.join( File.dirname(__FILE__), 'helper/pkt1' ) )
-  end
   
-  it "should get single pkt nil " do
-    file = "helper/gre.pcap"
-    offline = DIY::Offline.new(file)
-    lambda { while( offline.next ) do ; end }.should_not raise_error
+  it "should get next pcap" do
+    files = [ "helper/gre.pcap", "helper/app.pcap" ]
+    offline = DIY::Offline.new(files)
+    offline.next_pcap
+    lambda { offline.next_pcap }.should raise_error(DIY::EOFError)
   end
   
-  it "should get correct pkt in two files" do
-    files = [ "helper/gre.pcap", "helper/app.pcap" ]
+  it "should get next special first_pkt" do
+    files = [ "helper/app.pcap", "helper/gre.pcap" ]
     offline = DIY::Offline.new(files)
-    lambda { while( offline.next ) do ; end }.should_not raise_error
+    22.times { offline.nexts }
+    offline.nexts.size.should == 1
   end
   
-  it "should get next pcap" do
+  it "should get nexts two" do
     files = [ "helper/gre.pcap", "helper/app.pcap" ]
     offline = DIY::Offline.new(files)
+    offline.nexts.size.should == 1
+    offline.nexts.size.should == 2
+    offline.nexts.size.should == 2
     offline.next_pcap
-    lambda { offline.next_pcap }.should raise_error(DIY::EOFError)
+    offline.nexts.size.should == 1
+    offline.nexts.size.should == 7
+    lambda { loop do offline.nexts end }.should raise_error(DIY::EOFError)
   end
   
-  it "should get correct first_pkt flag" do
-    files = [ "helper/gre.pcap", "helper/app.pcap" ]
+  it "should get another two" do
+    files = [ "helper/http.pcap", "helper/gre.pcap" ]
     offline = DIY::Offline.new(files)
-    offline.next
-    offline.should be_first_pkt
-    offline.fullname.should == "pkt: `helper/gre.pcap: 1th' "
-    offline.next
-    offline.should_not be_first_pkt
-    offline.fullname.should == "pkt: `helper/gre.pcap: 2th' "
-    offline.next_pcap
-    offline.next
-    offline.fullname.should == "pkt: `helper/app.pcap: 1th' "
-    offline.should be_first_pkt
-    offline.next
-    offline.should_not be_first_pkt
-    offline.fullname.should == "pkt: `helper/app.pcap: 2th' "
+    offline.nexts.size.should == 1
+    offline.nexts.size.should == 1
+    offline.nexts.size.should == 1
+    #change to next
+    offline.nexts.size.should == 1
+    offline.nexts.size.should == 2
+    offline.nexts.size.should == 2
+    lambda { loop do offline.nexts end }.should raise_error(DIY::EOFError)
   end
   
 end