emonti-rbkb 0.6.2.1 → 0.6.6

data/lib/rbkb/http/request.rb

@@ -0,0 +1,58 @@
+module Rbkb::Http
+
+  # A Request encapsulates all the entities in a HTTP request message
+  # including the action header, general headers, and body.
+  class Request < Base
+    attr_accessor :action
+
+    alias first_entity action
+    alias first_entity= action=
+
+    def request_parameters
+      @action.parameters
+    end
+
+    # Returns a new Headers object extended as RequestHeaders. This is the 
+    # default object which will be used when composing fresh Request header
+    # entities.
+    def default_headers_obj(*args)
+      Headers.new(*args).extend(RequestHeaders)
+    end
+
+    # Returns a new BoundBody object. This is the default object which will 
+    # be used when composing fresh Request body entities.
+    def default_body_obj(*args)
+      Body.new(*args)
+    end
+
+    # Returns a raw HTTP request for this instance. The instance must have 
+    # an action element defined at the bare minimum.
+    def to_raw(tmp_body=@body)
+      raise "this request has no action entity" unless first_entity()
+      self.headers ||= default_headers_obj()
+      self.body ||= default_body_obj()
+
+      if len=@opts[:static_length]
+        @body = Body.new(@body, @body.opts) {|x| x.base = self}
+        @headers.set_header("Content-Length", len.to_i)
+      elsif @opts[:ignore_content_length]
+        @headers.delete_header("Content-Length")
+      end
+
+      bstr = tmp_body.to_raw
+      hdrs = (@headers).to_raw_array.unshift(first_entity.to_raw)
+      return "#{hdrs.join("\r\n")}\r\n\r\n#{bstr}"
+    end
+
+
+    # Parses a raw HTTP request and captures data into the current instance.
+    def capture(str)
+      raise "arg 0 must be a string" unless String === str
+      hstr, bstr = str.split(/\s*\r?\n\r?\n/, 2)
+      capture_headers(hstr)
+      self.body = content_length ? BoundBody.new : Body.new
+      capture_body(bstr)
+      return self
+    end
+  end
+end

data/lib/rbkb/http/response.rb

@@ -0,0 +1,86 @@
+
+module Rbkb::Http
+  # A Response encapsulates all the entities in a HTTP response,
+  # including the status header, general headers, and body.
+  class Response < Base
+    attr_accessor :status
+
+    alias first_entity status
+    alias first_entity= status=
+
+    # Returns a raw HTTP response for this instance. Must have a status
+    # element defined at a bare minimum.
+    def to_raw(raw_body=nil)
+      raise "this response has no status" unless first_entity()
+      self.headers ||= default_headers_obj()
+      self.body = raw_body if raw_body
+
+      if do_chunked_encoding?(@headers)
+        unless @body.is_a? ChunkedBody
+          @body = ChunkedBody.new(@body, @body.opts)
+        end
+        @headers.delete_header("Content-Length")
+      elsif not opts[:ignore_content_length]
+        unless @body.is_a? BoundBody
+          @body = BoundBody.new(@body, @body.opts)
+        end
+        @headers.delete_header("Transfer-Encoding")
+      else
+        @body = Body.new(@body, @body.opts)
+      end
+      @body.base = self
+
+      yield(self) if block_given?
+
+      bstr = @body.to_raw
+      hdrs = @headers.to_raw_array.unshift(self.first_entity.to_raw)
+      return "#{hdrs.join("\r\n")}\r\n\r\n#{bstr}"
+    end
+
+    # Parses a raw HTTP response and captures data into the current instance.
+    def capture(str)
+      raise "arg 0 must be a string" unless String === str
+      hstr, bstr = str.split(/\s*\r?\n\r?\n/, 2)
+
+      capture_headers(hstr)
+
+      yield(self, bstr) if block_given?
+
+      unless @body and @body.capture_complete?
+        @body =
+          if do_chunked_encoding?
+            ChunkedBody.new {|b| b.base = self }
+          elsif content_length()
+            BoundBody.new {|b| b.base = self }
+          else
+            Body.new {|b| b.base = self }
+          end
+      end
+
+      capture_body(bstr)
+
+      return self
+    end
+
+    # Indicates whether to use chunked encoding based on presence of 
+    # the "Transfer-Encoding: chunked" header or the :ignore_chunked_encoding
+    # opts parameter.
+    def do_chunked_encoding?(hdrs=@headers)
+      ( (not @opts[:ignore_chunked_encoding]) and 
+        (hdrs.get_header_value("Transfer-Encoding").first =~ /(?:^|\W)chunked(?:\W|$)/) )
+    end
+
+    # Returns a new Headers object extended as ResponseHeaders. This is the 
+    # default object which will be used when composing fresh Response header
+    # entities.
+    def default_headers_obj(*args)
+      Headers.new(*args).extend(ResponseHeaders)
+    end
+
+    # Returns a new BoundBody object. This is the default object which will 
+    # be used when composing fresh Response body entities.
+    def default_body_obj(*args)
+      BoundBody.new(*args)
+    end
+  end
+end

data/lib/rbkb/plug.rb

@@ -2,8 +2,8 @@
 # See README.rdoc for license information
 #
 
-require "rbkb.rb"
+require "rbkb"
 
-require "rbkb/plug/plug.rb"
-require "rbkb/plug/blit.rb"
+require "rbkb/plug/plug"
+require "rbkb/plug/blit"
 

data/lib/rbkb/plug/cli.rb

@@ -0,0 +1,83 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+require 'eventmachine'
+
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+module Rbkb::Cli
+
+  # Rbkb::Cli::Executable is an abstract class for creating command line
+  # executables using the Ruby Black Bag framework.
+  class PlugCli < Executable
+    RX_HOST_AND_PORT = /^([\w\._-]+):(\d+)$/
+    RX_PORT_OPT_ADDR = /^(?:([\w\._-]+):)?(\d+)$/
+
+    attr_accessor :blit_addr, :blit_port, :blit_proto, 
+                  :local_addr, :local_port, :transport,
+                  :target_addr, :target_port, :plug_opts
+
+    def initialize(*args)
+      super(*args) do |this|
+        this.blit_addr ||= Plug::Blit::DEFAULT_IPADDR
+        this.blit_port ||= Plug::Blit::DEFAULT_PORT
+        this.transport ||= :TCP
+        this.plug_opts ||= {}
+        yield this if block_given?
+      end
+
+      # 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") # XXX
+      end
+
+      arg.on("-q", "--quiet", "Turn off verbose logging") do
+        Plug::UI::LOGCFG[:verbose] = false # XXX
+      end
+
+      arg.on("-d", "--dump-format=hex/raw", 
+             "Output conversations in hexdump or raw") do |d|
+        if m=/^(hex|raw)$/i.match(d)
+          Plug::UI::LOGCFG[:dump] = m[1].downcase.to_sym # XXX
+        else
+          bail "Invalid dump format: #{d.inspect}"
+        end
+      end
+
+      arg.on("-b", "--blit=ADDR:PORT", "Where to listen for blit") do |b|
+        unless m=RX_PORT_OPT_ADDR.match(b)
+          bail("Invalid blit address/port")
+        end
+        @blit_port = m[2].to_i
+        @blit_addr = m[1] if m[1]
+      end
+
+      arg.on("-u", "--udp", "UDP mode") { @transport=:UDP }
+
+      arg.on("-S", "--start-tls", "Initiate TLS") {|s| @plug_opts[:tls]=true }
+
+      return arg
+    end
+
+    def parse_target_argument()
+      unless (m = RX_HOST_AND_PORT.match(tgt=@argv.shift))
+        bail "Invalid target: #{tgt}\n  Hint: use -h"
+      end
+      @target_addr = m[1]
+      @target_port = m[2].to_i
+      return m
+    end
+  end
+end
+

data/lib/rbkb/plug/feed_import.rb

@@ -0,0 +1,74 @@
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+
+require 'yaml'
+require 'rbkb'
+
+module FeedImport
+
+  ## TODO switch to pcaprub or some other up to date pcap lib. make it a dep.
+  begin
+    ## This requires the 'ruby-pcap' library from:
+    ##   http://raa.ruby-lang.org/project/pcap/
+    ## ... which is old and krufty...
+    $VERBOSE=nil
+    require 'pcaplet'
+    $VERBOSE=false
+
+    # Imports an array from pcap
+    def import_pcap(file, filter=nil)
+      ret = Array.new
+      pcap = Pcap::Capture.open_offline(file)
+      pcap.setfilter filter if filter
+      pcap.each_packet do |pkt|
+        if ( (pkt.udp? and dat=pkt.udp_data) or 
+             (pkt.tcp? and dat=pkt.tcp_data and not dat.empty?)
+           ) 
+             ret <<  dat 
+        end
+      end
+      return ret
+    end
+  rescue LoadError
+    def import_pcap(*args)
+      raise "you must install ruby-pcap to use this feature"
+    end
+  end
+
+  module_function :import_pcap
+
+
+  # Imports an array from yaml
+  def import_yaml(file)
+    unless ( ret = YAML.load_file(file) ).kind_of? Array
+      raise "#{file.inspect} did not provide an array"
+    end
+    return ret
+  end
+  module_function :import_yaml
+
+
+  # Imports from hexdumps separated by "%" and merged by ','
+  def import_dump(file)
+    ret = []
+    dat = File.read(file)
+    dat.strip.split(/^%$/).each do |msg|
+      ret << ""
+      msg.strip.split(/^,$/).each do |chunk|
+        ret[-1] << chunk.strip.dehexdump
+      end
+    end
+    return ret
+  end
+  module_function :import_dump
+
+  # Imports raw messages in files by a glob pattern (i.e. /tmp/foo/msgs.*)
+  # Manage filenames so that they're in the right order on import.
+  # See Dir.glob for valid globbing patterns.
+  def import_rawfiles(glob_pat)
+    Dir.glob(glob_pat).map { |f| File.read(f) }
+  end
+  module_function :import_rawfiles
+end
+

data/lib/rbkb/plug/plug.rb

@@ -21,21 +21,37 @@ module Plug
 
     def self.dump(from, to, dat)
       if dump=LOGCFG[:dump]
-        LOGCFG[:out].puts "%% #{from} SAYS TO #{to} LEN=#{dat.size}", 
-          (dump == :hex)? dat.hexdump(:out => StringIO.new) : dat,
-          "%%"
+        LOGCFG[:out].puts "%% #{from} SAYS TO #{to} LEN=#{dat.size}" if LOGCFG[:verbose]
+        case dump
+        when :hex
+          dat.hexdump(:out => LOGCFG[:out])
+        when :raw
+          LOGCFG[:out].puts dat
+        else
+          LOGCFG[:out].puts dat
+        end
+        LOGCFG[:out].puts "%%" if LOGCFG[:verbose]
       end
     end
   end
 
 
   module Base
-    attr_accessor :peers, :transport, :kind
+    attr_accessor :peers, :transport, :kind, :tls, :tls_opts, :no_stop_on_unbind
 
-    def initialize(transport)
+    def initialize(transport, opts={})
 #      raise "Invalid transport #{transport.inspect}" unless (:UDP, :TCP).include?(transport)
       @transport = transport
       @peers = PeerList.new(self)
+
+      opts.each_pair do |k,v|
+        accessor = k.to_s + "="
+        if self.respond_to?(accessor)
+          self.send(accessor, v)
+        else
+          raise "Bad attribute: #{k}"
+        end
+      end
     end
 
     def name
@@ -81,6 +97,9 @@ module Plug
       UI.verbose "** #{name} Started"
       if @kind==:server and peer=plug_peer
         UI.log "** #{name} CONNECTED TO #{peer.name}"
+        if tls
+          start_tls(tls_opts || {})
+        end
       end
     end
 
@@ -94,12 +113,18 @@ module Plug
     def connection_completed
       peer = plug_peer
       UI.log "** #{name} CONNECTED TO #{peer.name}"
+      if tls
+        start_tls(tls_opts || {})
+      end
       return peer
     end
 
     def unbind
       UI.log "** Connection " + ((@peers.empty?)? "refused." : "closed.")
-      EM.stop
+      unless @no_stop_on_unbind
+        UI.log "STOPPING!!"
+        EM.stop  
+      end
     end
   end
 
@@ -137,21 +162,13 @@ module Plug
     attr_accessor :pos, :feed, :step, :close_at_end, :go_first, 
                   :squelch_exhausted
     
-    def initialize(transport, opts={})
-      super(transport)
+    def initialize(*args)
+      super(*args)
 
-      @pos = 0
-      @feed = []
+      @pos ||= 0
+      @feed ||= []
 
-      opts.each_pair do |k,v|
-        accessor = k.to_s + "="
-        if self.respond_to?(accessor)
-          self.send(accessor, v)
-        else
-          raise "Bad attribute: #{k}"
-        end
-      end
-      raise "feed must be enumerable" unless @feed.kind_of? Enumerable
+      raise "feed must be enumerable" unless Enumerable === @feed
     end
     
     def go

data/lib/rbkb/plug/unix_domain.rb

@@ -0,0 +1,75 @@
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+
+# Experimental!!!
+
+require 'eventmachine'
+require 'rbkb/plug'
+require 'rbkb'
+
+module Plug
+  class PeerStub
+    attr_reader :owner
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def [](junk)
+      @owner
+    end
+
+    def []=(junk)
+      [@owner]
+    end
+
+    def peers
+      nil
+    end
+  end
+
+  module UnixDomain
+    attr_accessor :mute, :peers
+
+    def initialize
+      @peers = PeerStub.new(self)
+    end
+
+    def name
+      "a domain socket"
+    end
+
+    def receive_data(dat)
+      puts "Got:", dat.hexdump
+    end
+
+    def say(dat, sender)
+      UI.dump(sender.name, self.name, dat)
+      send_data(dat)
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  Plug::UI::LOGCFG[:verbose] = true
+
+  b_addr = Plug::Blit::DEFAULT_IPADDR
+  b_port = Plug::Blit::DEFAULT_PORT
+  unless (sock=ARGV.shift and ARGV.shift.nil?)
+    STDERR.puts "usage: #{File.basename $0} unix_socket"
+    exit 1
+  end
+
+
+  EventMachine.run {
+    s = EventMachine.connect_unix_domain(sock, Plug::UnixDomain)
+    Plug::UI::verbose("** UNIX-DOMAIN-#{sock.inspect} Started")
+
+    # connect a blit channel:
+    EventMachine.start_server(b_addr, b_port, Plug::Blit, :TCP, s)
+    Plug::UI::verbose("** BLITSRV-#{b_addr}:#{b_port}(TCP) Started")
+  }
+
+end