rbkb 0.6.10

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").to_s =~ /(?:^|\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

@@ -0,0 +1,9 @@
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+
+require "rbkb"
+
+require "rbkb/plug/plug"
+require "rbkb/plug/blit"
+

data/lib/rbkb/plug/blit.rb

@@ -0,0 +1,222 @@
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+module Plug
+  module Blit
+    include Base
+
+    DEFAULT_IPADDR = "127.0.0.1"
+    DEFAULT_PORT = 25195
+    DEFAULT_PROTOCOL = :TCP
+
+    OPCODES = {
+      0 => :squelch,
+      1 => :unsquelch,
+      2 => :delete,
+      5 => :sendmsg,
+      6 => :list_peers,
+
+      0xfe => :clear,
+      0xff => :kill,
+    }
+
+    attr_accessor :kind
+
+    def initialize(transport, slave)
+      super(transport)
+
+      @kind = :blitsrv
+      @slave = slave
+      @peers = slave.peers
+      initbuf
+    end
+
+    def post_init
+      # override so we don't get unneccessary "Start" message from Base
+    end
+
+    def unbind
+      # override so we don't get unneccessary "closed" message from Base
+    end
+
+
+    ### Blit protocol stuff
+    SIG = "BLT"
+
+    # (re)initializes the blit buffer
+    def initbuf
+      @buf = StringIO.new
+    end
+    
+    def receive_data dat
+      return unless (@buf.write(dat) > SIG.size) or (@buf.pos > (SIG.size + 1))
+
+      @buf.rewind
+
+      return unless @buf.read(SIG.size) == SIG and
+                    op = OPCODES[ @buf.read(1)[0] ]
+
+      initbuf if self.send(op)
+    end
+    
+
+    def self.blit_header(op)
+      return nil unless opno = OPCODES.invert[op]
+      SIG + opno.chr
+    end
+
+    def mute
+      unless ( peerno=@buf.read(2) and peerno.size == 2 and
+               peer=@peers[peerno.dat_to_num(:big)] )
+
+        UI.log "** BLIT-ERROR(Malformed or missing peer for mute)"
+        return true
+      end
+    end
+
+    def self.make_mute(peerno)
+      self.blit_header(:squelch) +
+        peerno.to_bytes(:big, 2)
+    end
+
+    def unmute
+      unless ( peerno=@buf.read(2) and peerno.size == 2 and
+               peer=@peers[peerno.dat_to_num(:big)] )
+        UI.log "** BLIT-ERROR(Malformed or missing peer for unmute)"
+        return true
+      end
+    end
+
+    def self.make_squelch(peerno)
+      self.blit_header(:squelch) +
+        peerno.to_bytes(:big, 2)
+    end
+
+    def sendmsg
+      unless peerno=@buf.read(2) and peerno.size == 2 and
+             bufsiz=@buf.read(4) and bufsiz.size == 4
+        UI.log "** BLIT-ERROR(Malformed sendmsg)"
+        return true
+      end
+
+      peerno = peerno.dat_to_num(:big)
+      bufsiz = bufsiz.dat_to_num(:big)
+
+      if (rdat=@buf.read(bufsiz)).size == bufsiz
+        if peer=@peers[peerno]
+          peer.say(rdat, self)
+          return true
+        else
+          UI.log "** BLIT-ERROR(Invalid peer index #{peerno})"
+          return true
+        end
+      else
+        return nil
+      end
+    end
+
+    # Blit packed message format is (SUBJECT TO CHANGE):
+    #   "BLT"
+    #   char   opcode
+    #   uint16be idx   = index of slave peer to send to
+    #   uint32le size  = length of data
+    #   str      data
+    def self.make_sendmsg(idx, dat)
+      self.blit_header(:sendmsg) +
+        idx.to_bytes(:big, 2) + 
+        dat.size.to_bytes(:big, 4) + 
+        dat
+    end
+
+    def kill
+      UI.log("** BLIT-KILL - Received shutdown command")
+      EM.stop
+    end
+
+    def self.make_kill(idx=nil)
+      self.blit_header(:kill)
+    end
+
+    def clear
+      @peers.each { |p| p.close }
+      @peers.replace []
+    end
+
+    def self.make_clear
+      self.blit_header(:clear)
+    end
+
+    def delete(peerno)
+      @peers.delete(peerno)
+    end
+
+    def self.make_delete(idx=0)
+      self.blit_header(:delete) +
+        idx.to_bytes(:big, 2)
+    end
+
+    def list_peers
+      UI.log("** BLIT-LISTPEERS - Received list peers command")
+
+      @peers.each_index {|i| UI.log "**   #{i} - #{@peers[i].name}"}
+      UI.log("** BLIT-LISTPEERS-END - End of peer list")
+    end
+
+    def self.make_list_peers
+      self.blit_header(:list_peers)
+    end
+
+    #----------------------------------------------------------------------
+    # Convenience methods for blit clients
+    #----------------------------------------------------------------------
+
+    BLIT_HANDLERS = {
+      :TCP => lambda {|msg| 
+        s=TCPSocket.new(@blit_addr, @blit_port)
+        wl=s.write(msg)
+        s.close
+        return wl
+      },
+      :UDP => lambda {|msg|
+        s=UDPSocket.new
+        wl=s.send( msg, 0, @blit_addr, @blit_port)
+        s.close
+        return wl
+      }
+    }
+
+    def self.blit_init(opts={})
+      @blit_addr = (opts[:addr] || DEFAULT_IPADDR)
+      @blit_port = (opts[:port] || DEFAULT_PORT)
+      proto = (opts[:protocol] || DEFAULT_PROTOCOL)
+      @blit_handler = BLIT_HANDLERS[ proto ]
+      raise "invalid blit transport protocol" unless @blit_handler
+    end
+
+    def self.initialized?
+      @blit_addr and @blit_port and @blit_handler
+    end
+
+    def self.blit_send(data, idx=0)
+      msg = make_sendmsg(idx, data)
+      blit_raw(msg)
+    end
+
+    def self.blit_raw(buf)
+      raise "use blit_init first!" unless self.initialized?
+      @blit_handler.call buf
+    end
+
+  end  # of module Blit
+
+
+end # of module Plug
+
+class String
+  #----------------------------------------------------------------------
+  # A Blit sender convenience method for strings
+  def blit(idx=0)
+    raise "blit must be initialized with blit_init" unless Plug::Blit.initialized?
+    Plug::Blit.blit_send(self, idx)
+  end
+end

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
+