rbkb 0.7.1 → 0.7.3

data/lib/rbkb/extends/symbol.rb

@@ -1,8 +1,6 @@
-
 class Symbol
   # looks up this symbol as a constant defined in 'ns' (Object by default)
-  def const_lookup(ns=Object)
-    self.to_s.const_lookup(ns)
+  def const_lookup(ns = Object)
+    to_s.const_lookup(ns)
   end
 end
-

data/lib/rbkb/extends.rb

@@ -1,4 +1,3 @@
-
 require_relative 'extends/array'
 require_relative 'extends/enumerable'
 require_relative 'extends/float'

data/lib/rbkb/plug/blit.rb

@@ -1,12 +1,12 @@
-# Copyright 2009 emonti at matasano.com 
+# 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_IPADDR = '127.0.0.1'
+    DEFAULT_PORT = 25_195
     DEFAULT_PROTOCOL = :TCP
 
     OPCODES = {
@@ -18,7 +18,7 @@ module Plug
       7 => :starttls,
 
       0xfe => :clear,
-      0xff => :kill,
+      0xff => :kill
     }
 
     attr_accessor :kind
@@ -40,94 +40,91 @@ module Plug
       # override so we don't get unneccessary "closed" message from Base
     end
 
-
     ### Blit protocol stuff
-    SIG = "BLT"
+    SIG = 'BLT'
 
     # (re)initializes the blit buffer
     def initbuf
       @buf = StringIO.new
     end
-    
-    def receive_data dat
+
+    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] ]
+                    op = OPCODES[@buf.read(1)[0]]
 
-      initbuf if self.send(op)
+      initbuf if send(op)
     end
-    
 
     def self.blit_header(op)
       return nil unless opno = OPCODES.invert[op]
+
       SIG + opno.chr
     end
 
     def starttls
-      unless ( peerno=@buf.read(2) and peerno.size == 2 and
-               peer=@peers[peerno.dat_to_num(:big)] )
+      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 starttls)"
+        UI.log '** BLIT-ERROR(Malformed or missing peer for starttls)'
         return true
       end
 
       peer.start_tls(self)
     end
- 
+
     def self.make_starttls(peerno)
-      self.blit_header(:starttls) + peerno.to_bytes(:big, 2)
+      blit_header(:starttls) + peerno.to_bytes(:big, 2)
     end
 
     def mute
-      unless ( peerno=@buf.read(2) and peerno.size == 2 and
-               peer=@peers[peerno.dat_to_num(:big)] )
+      unless peerno = @buf.read(2) and peerno.size == 2 and
+             @peers[peerno.dat_to_num(:big)]
 
-        UI.log "** BLIT-ERROR(Malformed or missing peer for mute)"
-        return true
+        UI.log '** BLIT-ERROR(Malformed or missing peer for mute)'
+        true
       end
     end
 
     def self.make_mute(peerno)
-      self.blit_header(:squelch) +
+      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
+      unless peerno = @buf.read(2) and peerno.size == 2 and
+             @peers[peerno.dat_to_num(:big)]
+        UI.log '** BLIT-ERROR(Malformed or missing peer for unmute)'
+        true
       end
     end
 
     def self.make_squelch(peerno)
-      self.blit_header(:squelch) +
+      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)"
+      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]
+      if (rdat = @buf.read(bufsiz)).size == bufsiz
+        if peer = @peers[peerno]
           peer.say(rdat, self)
-          return true
+          true
         else
           UI.log "** BLIT-ERROR(Invalid peer index #{peerno})"
-          return true
+          true
         end
-      else
-        return nil
       end
     end
 
@@ -138,19 +135,19 @@ module Plug
     #   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) + 
+      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")
+      UI.log('** BLIT-KILL - Received shutdown command')
       EM.stop
     end
 
-    def self.make_kill(idx=nil)
-      self.blit_header(:kill)
+    def self.make_kill(_idx = nil)
+      blit_header(:kill)
     end
 
     def clear
@@ -159,27 +156,27 @@ module Plug
     end
 
     def self.make_clear
-      self.blit_header(:clear)
+      blit_header(:clear)
     end
 
     def delete(peerno)
       @peers.delete(peerno)
     end
 
-    def self.make_delete(idx=0)
-      self.blit_header(:delete) +
+    def self.make_delete(idx = 0)
+      blit_header(:delete) +
         idx.to_bytes(:big, 2)
     end
 
     def list_peers
-      UI.log("** BLIT-LISTPEERS - Received list peers command")
+      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")
+      @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)
+      blit_header(:list_peers)
     end
 
     #----------------------------------------------------------------------
@@ -187,33 +184,33 @@ module Plug
     #----------------------------------------------------------------------
 
     BLIT_HANDLERS = {
-      :TCP => lambda {|msg| 
-        s=TCPSocket.new(@blit_addr, @blit_port)
-        wl=s.write(msg)
+      TCP: lambda { |msg|
+        s = TCPSocket.new(@blit_addr, @blit_port)
+        wl = s.write(msg)
         s.close
-        return wl
+        wl
       },
-      :UDP => lambda {|msg|
-        s=UDPSocket.new
-        wl=s.send( msg, 0, @blit_addr, @blit_port)
+      UDP: lambda { |msg|
+        s = UDPSocket.new
+        wl = s.send(msg, 0, @blit_addr, @blit_port)
         s.close
-        return wl
+        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
+    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)
+    def self.blit_send(data, idx = 0)
       msg = make_sendmsg(idx, data)
       blit_raw(msg)
     end
@@ -224,19 +221,19 @@ module Plug
     end
 
     def self.blit_raw(buf)
-      raise "use blit_init first!" unless self.initialized?
+      raise 'use blit_init first!' unless initialized?
+
       @blit_handler.call buf
     end
-
-  end  # of module Blit
-
+  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?
+  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

@@ -2,19 +2,17 @@ require 'rbkb/cli'
 require 'rbkb/plug'
 require 'eventmachine'
 
-
-# Copyright 2009 emonti at matasano.com 
+# 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+)$/
+    RX_HOST_AND_PORT = /^([\w._-]+):(\d+)$/
+    RX_PORT_OPT_ADDR = /^(?:([\w._-]+):)?(\d+)$/
 
-    attr_accessor :blit_addr, :blit_port, :blit_proto, 
+    attr_accessor :blit_addr, :blit_port, :blit_proto,
                   :local_addr, :local_port, :transport,
                   :target_addr, :target_port, :plug_opts
 
@@ -27,57 +25,56 @@ module Rbkb::Cli
         yield this if block_given?
       end
 
-      # TODO Plug::UI obviously need fixing. 
+      # 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()
+    def make_parser
       arg = super()
-      arg.banner << " host:port"
+      arg.banner << ' host:port'
 
-      arg.on("-o", "--output=FILE", "Output to file") do |o|
-        Plug::UI::LOGCFG[:out] = File.open(o, "w") # XXX
+      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
+      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)
+      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")
+      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('-u', '--udp', 'UDP mode') { @transport = :UDP }
 
-      arg.on("-S", "--start-tls", "Initiate TLS") {|s| @plug_opts[:tls]=true }
+      arg.on('-S', '--start-tls', 'Initiate TLS') { |_s| @plug_opts[:tls] = true }
 
-      return arg
+      arg
     end
 
-    def parse_target_argument()
-      unless (m = RX_HOST_AND_PORT.match(tgt=@argv.shift))
+    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
+      m
     end
   end
 end
-

data/lib/rbkb/plug/feed_import.rb

@@ -1,4 +1,4 @@
-# Copyright 2009 emonti at matasano.com 
+# Copyright 2009 emonti at matasano.com
 # See README.rdoc for license information
 #
 
@@ -6,60 +6,57 @@ 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
+    $VERBOSE = nil
     require 'pcaplet'
-    $VERBOSE=false
+    $VERBOSE = false
 
     # Imports an array from pcap
-    def import_pcap(file, filter=nil)
-      ret = Array.new
+    def import_pcap(file, filter = nil)
+      ret = []
       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
+        next unless (pkt.udp? and dat = pkt.udp_data) or
+                    (pkt.tcp? and dat = pkt.tcp_data and !dat.empty?)
+
+        ret << dat
       end
-      return ret
+      ret
     end
   rescue LoadError
-    def import_pcap(*args)
-      raise "you must install ruby-pcap to use this feature"
+    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
+    unless (ret = YAML.load_file(file)).is_a? Array
       raise "#{file.inspect} did not provide an array"
     end
-    return ret
+
+    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 << ""
+      ret << ''
       msg.strip.split(/^,$/).each do |chunk|
         ret[-1] << chunk.strip.dehexdump
       end
     end
-    return ret
+    ret
   end
   module_function :import_dump
 
@@ -71,4 +68,3 @@ module FeedImport
   end
   module_function :import_rawfiles
 end
-

data/lib/rbkb/plug/peer.rb

@@ -1,11 +1,10 @@
-# Copyright 2009 emonti at matasano.com 
+# Copyright 2009 emonti at matasano.com
 # See README.rdoc for license information
 #
 
 require 'socket'
 
 module Plug
-
   class Peer
     attr_reader :addr, :transport, :name, :owner, :host, :port
     attr_accessor :mute
@@ -20,7 +19,7 @@ module Plug
     end
 
     def say(dat, sender)
-      UI.dump(sender.name, self.name, dat)
+      UI.dump(sender.name, name, dat)
 
       if @transport == :UDP
         @owner.send_datagram(dat, @host, @port)
@@ -30,7 +29,7 @@ module Plug
     end
 
     def start_tls(sender)
-      UI.logmsg(self.name, "#{sender.name} initiated TLS")
+      UI.logmsg(name, "#{sender.name} initiated TLS")
       @owner.start_tls
     end
 
@@ -39,34 +38,33 @@ module Plug
     end
   end
 
-
   class PeerList < Array
     def initialize(owner, *args)
       @owner = owner
       @transport = @owner.transport
-      
+
       super(*args)
     end
 
     def find_peer(addr)
-      self.find {|p| p.addr == addr }
+      find { |p| p.addr == addr }
     end
 
     def add_peer(addr)
       self << Peer.new(addr, @owner)
-      self.last
+      last
     end
 
     def add_peer_manually(host, port)
       addr = Socket.pack_sockaddr_in(port, host)
-      return (find_peer(addr) || add_peer(addr))
+      find_peer(addr) || add_peer(addr)
     end
 
     def delete(addr)
-      if p=find_peer(addr)
-        p.close
-        super(p)
-      end
+      return unless p = find_peer(addr)
+
+      p.close
+      super(p)
     end
   end
 end