emonti-rbkb 0.6.2.1 → 0.6.6

data/lib/rbkb/cli/d64.rb

@@ -8,12 +8,15 @@ class Rbkb::Cli::D64 < Rbkb::Cli::Executable
   def make_parser
     super()
     @oparse.banner += " <data | blank for stdin>"
+    add_std_file_opt(:indat)
   end
 
   def parse(*args)
     super(*args)
     parse_string_argument(:indat)
+    parse_file_argument(:indat)
     parse_catchall()
+    @opts[:indat] ||= @stdin.read
   end
 
   def go(*args)

data/lib/rbkb/cli/dedump.rb

@@ -7,8 +7,10 @@ require 'rbkb/cli'
 # by Unix utilities like 'xxd' as well as 'hexdump -C'.
 class Rbkb::Cli::Dedump < Rbkb::Cli::Executable
   def initialize(*args)
-    super(*args)
-    @opts[:len] ||= 16
+    super(*args) {|this|
+      this.opts[:len] ||= 16
+      yield this if block_given?
+    }
   end
 
   def make_parser()
@@ -16,7 +18,7 @@ class Rbkb::Cli::Dedump < Rbkb::Cli::Executable
     arg.banner += " <input-file | blank for stdin>"
 
     arg.on("-l", "--length LEN", Numeric, 
-      "Bytes per line in hexdump (default: #{@opts[:len]})") do |l|
+      "Bytes per line in hexdump (Default: #{@opts[:len]})") do |l|
         bail("Length must be greater than zero") unless (@opts[:len] = l) > 0
     end
     return arg

data/lib/rbkb/cli/feed.rb

@@ -0,0 +1,223 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+require 'rbkb/plug/feed_import'
+require 'eventmachine'
+
+# Copyright 2009 emonti at moatasano dot com
+# See README.rdoc for license information
+#
+# This is a plug-board message feeder from static data sources.
+# The "feed" handles messages opaquely and just plays them in the given 
+# sequence.
+#
+# Feed can do the following things with minimum fuss: 
+#   - Import messages from files, yaml, or pcap
+#   - Inject custom/modified messages with "blit"
+#   - Run as a server or client using UDP or TCP
+#   - Bootstrap protocols without a lot of work up front
+#   - Skip uninteresting messages and focus attention on the fun ones.
+#   - Replay conversations for relatively unfamiliar protocols.
+#   - Observe client/server behaviors using different messages at
+#     various phases of a conversation.
+#
+# To-dos / Ideas:
+#  - Unix Domain Socket support?
+#  - more import options?
+#  - dynamic feed elements?
+#  - add/control feed elements while 'stepping'?
+#
+
+class Rbkb::Cli::Feed < Rbkb::Cli::Executable
+  def initialize(*args)
+    @local_addr = "0.0.0.0"
+    @local_port = nil
+    @listen = false
+    @persist = false
+    @transport = :TCP
+    @svr_method = :start_server
+    @cli_method = :connect
+    @blit_addr = Plug::Blit::DEFAULT_IPADDR
+    @blit_port = Plug::Blit::DEFAULT_PORT
+
+
+    ## Default options sent to the Feed handler
+    @feed_opts = { 
+      :close_at_end => false,
+      :step => false,
+      :go_first => false
+    }
+
+    super(*args)
+
+    # TODO Plug::UI obviously need fixing. 
+    # TODO It shouldn't be driven by constants for configuration
+    Plug::UI::LOGCFG[:verbose] = true
+    Plug::UI::LOGCFG[:dump] = :hex
+    Plug::UI::LOGCFG[:out] = @stderr
+  end
+
+  def make_parser()
+    arg = super()
+    arg.banner += " host:port"
+
+    arg.on("-o", "--output=FILE", "Output to file") do |o|
+      Plug::UI::LOGCFG[:out] = File.open(o, "w")
+    end
+
+    arg.on("-l", "--listen=(ADDR:?)PORT", "Server - on port (and addr?)") do |p|
+      if m=/^(?:([\w\._-]+):)?(\d+)$/.match(p)
+        @local_addr = $1 if $1
+        @local_port = $2.to_i
+        @listen = true
+      else
+        raise "Invalid listen argument: #{p.inspect}"
+      end
+    end
+
+    arg.on("-b", "--blit=(ADDR:)?PORT", "Where to listen for blit") do |b|
+      puts b
+      unless(m=/^(?:([\w\._-]+):)?(\d+)$/.match(b))
+        raise "Invalid blit argument: #{b.inspect}"
+      end
+      @blit_port = m[2].to_i
+      @blit_addr = m[1] if m[1]
+    end
+
+    arg.on("-i", "--[no-]initiate", "Send the first message on connect") do |i|
+      @feed_opts[:go_first] = i
+    end
+
+    arg.on("-e", "--[no-]end", "End connection when feed is exhausted") do |c|
+      @feed_opts[:close_at_end] = c
+    end
+     
+    arg.on("-s", "--[no-]step", "'Continue' prompt between messages") do |s|
+      @feed_opts[:step] = s
+    end
+
+    arg.on("-u", "--udp", "Use UDP instead of TCP" ) do
+      @transport = :UDP
+    end
+
+    arg.on("-r", "--reconnect", "Attempt to reconnect endlessly.") do
+      @persist=true
+    end
+
+    arg.on("-q", "--quiet", "Suppress verbose messages/dumps") do
+      Plug::UI::LOGCFG[:verbose] = false
+    end
+
+    arg.on("-Q", "--squelch-exhausted", "Squelch 'FEED EXHAUSTED' messages") do |s|
+      @feed_opts[:squelch_exhausted] = true
+    end
+
+    arg.separator  "  Sources: (can be combined)"
+
+    arg.on("-f", "--from-files=GLOB", "Import messages from raw files") do |f|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_rawfiles(f)
+    end
+
+    arg.on("-x", "--from-hex=FILE", "Import messages from hexdumps") do |x|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_dump(x)
+    end
+
+    arg.on("-y", "--from-yaml=FILE", "Import messages from yaml") do |y|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_yaml(y)
+    end
+
+    arg.on("-p", "--from-pcap=FILE[:FILTER]", "Import messages from pcap") do |p|
+      if /^([^:]+):(.+)$/.match(p)
+        file = $1
+        filter = $2
+      else
+        file = p
+        filter = nil
+      end
+
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_pcap(file, filter)
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+
+    if @transport == :UDP
+      @svr_method = @cli_method = :open_datagram_socket
+    end
+
+    # Prepare EventMachine arguments based on whether we are a client or server
+    if @listen
+      @evma_addr = @local_addr
+      @evma_port = @local_port
+      @meth = @svr_method
+      @feed_opts[:kind] = :server
+      @feed_opts[:no_stop_on_unbind] = true
+    else
+
+      ## Get target/listen argument for client mode
+      unless (m = /^([\w\.]+):(\d+)$/.match(tgt=@argv.shift))
+        bail_args tgt
+      end
+
+      @target_addr = m[1]
+      @target_port = m[2].to_i
+
+      if @transport == :UDP
+        @evma_addr = @local_addr
+        @evma_port = @local_port || 0
+      else
+        @evma_addr = @target_addr
+        @evma_port = @target_port
+      end
+
+      @meth = @cli_method
+      @feed_opts[:kind] = :client
+    end
+
+    @feed_opts[:feed] ||= []
+
+    @em_args=[ 
+      @meth, 
+      @evma_addr, 
+      @evma_port, 
+      Plug::ArrayFeeder, 
+      @transport, 
+      @feed_opts
+    ].flatten
+
+    parse_catchall()
+  end
+
+
+  def go(*args)
+    super(*args)
+
+    Plug::UI.verbose "** FEED CONTAINS #{@feed_opts[:feed].size} MESSAGES"
+
+    ## Start the eventmachine
+    loop do
+      EventMachine::run do
+        EventMachine.send(*@em_args) do |c|
+          EventMachine.start_server(@blit_addr, @blit_port, Plug::Blit, :TCP, c)
+          Plug::UI::verbose("** BLITSRV-#{@blit_addr}:#{@blit_port}(TCP) Started")
+
+          # if this is a UDP client, we will always send the first message
+          if [:UDP, :client] == [@transport, c.kind]
+            peer = c.peers.add_peer_manually(@target_addr, @target_port)
+            c.feed_data(peer)
+            c.go_first = false
+          end
+        end
+      end
+
+      break unless @persist
+      Plug::UI::verbose("** RECONNECTING")
+    end
+
+  end
+end
+

data/lib/rbkb/cli/hexify.rb

@@ -15,7 +15,7 @@ class Rbkb::Cli::Hexify < Rbkb::Cli::Executable
     arg.banner += " <data | blank for stdin>"
 
     arg.on("-l", "--length LEN", Numeric, "Output lines of LEN bytes") do |l|
-      bail("Length must be greater than zero") unless (@opts[:len] = l) > 0
+      @opts[:len] = l
     end
 
     arg.on("-d", "--delim=DELIMITER", "DELIMITER between each byte") do |d|
@@ -51,9 +51,9 @@ class Rbkb::Cli::Hexify < Rbkb::Cli::Executable
     @opts[:indat] ||= @stdin.read() 
 
     indat = @opts.delete(:indat)
-    len = @opts.delete(:len)
+    len = (@opts.delete(:len) || indat.length)
 
-    self.exit(1) unless((len ||= indat.length) > 0)
+    bail("Length must be greater than zero") unless(len > 0)
 
     until (m = indat.slice!(0..len-1)).empty?
       @stdout << m.hexify(@opts)

data/lib/rbkb/cli/len.rb

@@ -2,23 +2,25 @@ require 'rbkb/cli'
 
 # Copyright 2009 emonti at matasano.com 
 # See README.rdoc for license information
-#
+
 # len prepends a binary length number in front of its input and outputs
 # raw on STDOUT
 class Rbkb::Cli::Len < Rbkb::Cli::Executable
 
   def initialize(*args)
-    super(*args)
-
     # endianness pair. index 0 is always the default
     @endpair = [:big, :little]
-    {
-      :nudge => 0, 
-      :size => 4, 
-      :endian => @endpair[0],
-    }.each {|k,v| @opts[k] ||= v}
-  end
 
+    super(*args) do |this|
+      {
+        :nudge => 0, 
+        :size => 4, 
+        :endian => @endpair[0],
+      }.each {|k,v| this.opts[k] ||= v}
+
+      yield this if block_given?
+    end
+  end
 
   def make_parser()
     super()
@@ -67,6 +69,7 @@ class Rbkb::Cli::Len < Rbkb::Cli::Executable
       len += @opts[:nudge]
     end
     @stdout << len.to_bytes(@opts[:endian], @opts[:size]) << @opts[:indat]
+    self.exit(0)
   end
 
 end

data/lib/rbkb/cli/rstrings.rb

@@ -6,16 +6,19 @@ require 'rbkb/cli'
 # rstrings is Unix "strings" in ruby... with some extra stuff
 class Rbkb::Cli::Rstrings < Rbkb::Cli::Executable
   def initialize(*args)
-    super(*args)
-    {
-      :start_off => 0, 
-      :end_off => -1, 
-      :encoding => :both, 
-      :minimum => 6,
-      :align => nil,
-      :indat => Array.new,
-      :fnames => Array.new,
-    }.each {|k,v| @opts[k] ||= v }
+    super(*args) do |this|
+      {
+        :start_off => 0, 
+        :end_off => -1, 
+        :encoding => :both, 
+        :minimum => 6,
+        :align => nil,
+        :indat => Array.new,
+        :fnames => Array.new,
+      }.each {|k,v| this.opts[k] ||= v }
+
+      yield this if block_given?
+    end
   end
 
   def make_parser()

data/lib/rbkb/cli/slice.rb

@@ -40,6 +40,7 @@ class Rbkb::Cli::Slice < Rbkb::Cli::Executable
   def go(*args)
     super(*args)
     @stdout << @opts[:indat][ @opts[:first] .. @opts[:last] ]
+    self.exit(0)
   end
 
 end

data/lib/rbkb/cli/telson.rb

@@ -1,6 +1,4 @@
-require 'rbkb/cli'
-require 'rbkb/plug'
-require 'eventmachine'
+require 'rbkb/plug/cli'
 
 # Copyright 2009 emonti at matasano.com 
 # See README.rdoc for license information
@@ -14,48 +12,21 @@ require 'eventmachine'
 #   - Observe client/server behaviors using different messages at
 #     various phases of a conversation.
 #
-class Rbkb::Cli::Telson < Rbkb::Cli::Executable
+class Rbkb::Cli::Telson < Rbkb::Cli::PlugCli
 
   def initialize(*args)
-    super(*args)
-    @b_addr = Plug::Blit::DEFAULT_IPADDR
-    @b_port = Plug::Blit::DEFAULT_PORT
-    @srced = @persist = false
-    @s_addr = "0.0.0.0"
-    @s_port = 0
-    @proto = :TCP
-
-    # XXX TODO Plug::UI obviously need fixing. It shouldn't be a module
-    # with constants for configuration
-    Plug::UI::LOGCFG[:verbose] = true
-    Plug::UI::LOGCFG[:dump] = :hex
-    Plug::UI::LOGCFG[:out] = @stderr
+    super(*args) do |this|
+      this.local_addr = "0.0.0.0"
+      this.local_port = 0
+    end
+
+    @srced = false
+    @persist = false
   end
 
 
   def make_parser()
     arg = super()
-    arg.banner += " host:port"
-
-    arg.on("-u", "--udp", "UDP mode") do
-      @proto=:UDP
-    end
-
-    arg.on("-b", "--blit=ADDR:PORT", "Where to listen for blit") do |b|
-      unless m=/^(?:([\w\.]+):)?(\d+)$/.match(b)
-        bail("Invalid blit address/port")
-      end
-      @b_port = m[2].to_i
-      @b_addr = m[1] if m[1]
-    end
-
-    arg.on("-o", "--output=FILE", "Output to file instead of screen") do |f|
-      Plug::UI::LOGCFG[:out] = File.open(f, "w") # XXX
-    end
-
-    arg.on("-q", "--quiet", "Turn off verbose logging") do
-      Plug::UI::LOGCFG[:verbose] = false # XXX
-    end
 
     arg.on("-r", "--reconnect", "Attempt to reconnect endlessly.") do
       @persist=true
@@ -63,8 +34,8 @@ class Rbkb::Cli::Telson < Rbkb::Cli::Executable
 
     arg.on("-s", "--source=(ADDR:?)PORT", "Bind on port (and addr?)") do |p|
       if m=/^(?:([\w\.]+):)?(\d+)$/.match(p)
-        @s_addr = $1 if $1
-        @s_port = $2.to_i
+        @local_addr = $1 if $1
+        @local_port = $2.to_i
         @srced = true
       else
         bail("Invalid listen argument: #{p.inspect}")
@@ -76,13 +47,8 @@ class Rbkb::Cli::Telson < Rbkb::Cli::Executable
   def parse(*args)
     super(*args)
 
-    # Get target argument
-    unless (m = /^([\w\.]+):(\d+)$/.match(@argv.shift)) and @argv.shift.nil?
-      bail "Invalid target #{arg}"
-    end
-
-    @t_addr = m[1]
-    @t_port = m[2].to_i
+    parse_target_argument()
+    parse_catchall()
   end
 
 
@@ -91,24 +57,22 @@ class Rbkb::Cli::Telson < Rbkb::Cli::Executable
 
     loop do
       EventMachine.run {
-        if @proto == :TCP
+        if @transport == :TCP
           bail("Sorry: --source only works with UDP.") if @srced
 
-          c=EventMachine.connect(@t_addr, @t_port, Plug::Telson, @proto)
+          c=EventMachine.connect(@target_addr, @target_port, Plug::Telson, @transport, @plug_opts)
 
-        elsif @proto == :UDP
-          c=EventMachine.open_datagram_socket(
-            @s_addr, @s_port, Plug::Telson, @proto
-          )
-          c.peers.add_peer_manually(@t_addr, @t_port)
+        elsif @transport == :UDP
+          c=EventMachine.open_datagram_socket( @local_addr, @local_port, Plug::Telson, @transport, @plug_opts)
+          c.peers.add_peer_manually(@target_addr, @target_port)
 
         ### someday maybe raw or others?
         else
-          raise "bad protocol"
+          raise "bad transport protocol"
         end
 
-        EventMachine.start_server(@b_addr, @b_port, Plug::Blit, :TCP, c)
-        Plug::UI::verbose("** BLITSRV-#{@b_addr}:#{@b_port}(TCP) Started") # XXX
+        EventMachine.start_server(@blit_addr, @blit_port, Plug::Blit, @blit_proto, c)
+        Plug::UI::verbose("** BLITSRV-#{@blit_addr}:#{@blit_port}(TCP) Started") # XXX
       }
       break unless @persist
       Plug::UI::verbose("** RECONNECTING") # XXX