librex 0.0.68 → 0.0.70

data/lib/rex/thread_factory.rb

@@ -10,34 +10,34 @@ module Rex
 
 class ThreadFactory
 
-	@@provider = nil
+  @@provider = nil
 
-	def self.provider=(val)
-		@@provider = val
-	end
+  def self.provider=(val)
+    @@provider = val
+  end
 
-	def self.spawn(name, crit, *args, &block)
-		if @@provider
-			if block
-				return @@provider.spawn(name, crit, *args){ |*args_copy| block.call(*args_copy) }
-			else
-				return @@provider.spawn(name, crit, *args)
-			end
-		else
-			t = nil
-			if block
-				t = ::Thread.new(*args){ |*args_copy| block.call(*args_copy) }
-			else
-				t = ::Thread.new(*args)
-			end
-			t[:tm_name] = name
-			t[:tm_crit] = crit
-			t[:tm_time] = Time.now
-			t[:tm_call] = caller
-			return t
-		end
+  def self.spawn(name, crit, *args, &block)
+    if @@provider
+      if block
+        return @@provider.spawn(name, crit, *args){ |*args_copy| block.call(*args_copy) }
+      else
+        return @@provider.spawn(name, crit, *args)
+      end
+    else
+      t = nil
+      if block
+        t = ::Thread.new(*args){ |*args_copy| block.call(*args_copy) }
+      else
+        t = ::Thread.new(*args)
+      end
+      t[:tm_name] = name
+      t[:tm_crit] = crit
+      t[:tm_time] = Time.now
+      t[:tm_call] = caller
+      return t
+    end
 
-	end
+  end
 end
 
 end

data/lib/rex/time.rb

@@ -8,58 +8,58 @@ module Rex
 ###
 module ExtTime
 
-	#
-	# Convert seconds to a string that is broken down into years, days, hours,
-	# minutes, and second.
-	#
-	def self.sec_to_s(seconds)
-		parts = [ 31536000, 86400, 3600, 60, 1 ].map { |d|
-			if ((c = seconds / d) > 0)
-				seconds -= c.truncate * d
-				c.truncate
-			else
-				0
-			end
-		}.reverse
+  #
+  # Convert seconds to a string that is broken down into years, days, hours,
+  # minutes, and second.
+  #
+  def self.sec_to_s(seconds)
+    parts = [ 31536000, 86400, 3600, 60, 1 ].map { |d|
+      if ((c = seconds / d) > 0)
+        seconds -= c.truncate * d
+        c.truncate
+      else
+        0
+      end
+    }.reverse
 
-		str = ''
+    str = ''
 
-		[ "sec", "min", "hour", "day", "year" ].each_with_index { |name, idx|
-			next if (!parts[idx] or parts[idx] == 0)
+    [ "sec", "min", "hour", "day", "year" ].each_with_index { |name, idx|
+      next if (!parts[idx] or parts[idx] == 0)
 
-			str = "#{parts[idx]} #{name + ((parts[idx] != 1) ? 's' :'')} " + str
-		}
+      str = "#{parts[idx]} #{name + ((parts[idx] != 1) ? 's' :'')} " + str
+    }
 
-		str.empty? ? "0 secs" : str.strip
-	end
+    str.empty? ? "0 secs" : str.strip
+  end
 
-	#
-	# Converts a string in the form n years g days x hours y mins z secs.
-	#
-	def self.str_to_sec(str)
-		fields = str.split(/ /)
-		secs   = 0
+  #
+  # Converts a string in the form n years g days x hours y mins z secs.
+  #
+  def self.str_to_sec(str)
+    fields = str.split(/ /)
+    secs   = 0
 
-		fields.each_with_index { |f, idx|
-			val = 0
-			case f
-				when /^year/
-					val = 31536000
-				when /^day/
-					val = 86400
-				when /^hour/
-					val = 3600
-				when /^min/
-					val = 60
-				when /^sec/
-					val = 1
-			end
+    fields.each_with_index { |f, idx|
+      val = 0
+      case f
+        when /^year/
+          val = 31536000
+        when /^day/
+          val = 86400
+        when /^hour/
+          val = 3600
+        when /^min/
+          val = 60
+        when /^sec/
+          val = 1
+      end
 
-			secs += val * fields[idx-1].to_i
-		}
+      secs += val * fields[idx-1].to_i
+    }
 
-		secs
-	end
+    secs
+  end
 
 end
 

data/lib/rex/transformer.rb

@@ -15,100 +15,100 @@ module Rex
 ###
 class Transformer
 
-	#
-	# Translates the object instance supplied in src_instance to an instance of
-	# dst_class.  The dst_class parameter's instance must support the <<
-	# operator.  An example call to this method looks something like:
-	#
-	# Transformer.transform(string, Array, [ String ], target)
-	#
-	def Transformer.transform(src_instance, dst_class, supported_classes,
-			target = nil)
-		dst_instance = dst_class.new
-
-		if (src_instance.kind_of?(Array))
-			src_instance.each { |src_inst|
-				Transformer.transform_single(src_inst, dst_instance,
-						supported_classes, target)
-			}
-		elsif (!src_instance.kind_of?(NilClass))
-			Transformer.transform_single(src_instance, dst_instance,
-					supported_classes, target)
-		end
-
-		return dst_instance
-	end
+  #
+  # Translates the object instance supplied in src_instance to an instance of
+  # dst_class.  The dst_class parameter's instance must support the <<
+  # operator.  An example call to this method looks something like:
+  #
+  # Transformer.transform(string, Array, [ String ], target)
+  #
+  def Transformer.transform(src_instance, dst_class, supported_classes,
+      target = nil)
+    dst_instance = dst_class.new
+
+    if (src_instance.kind_of?(Array))
+      src_instance.each { |src_inst|
+        Transformer.transform_single(src_inst, dst_instance,
+            supported_classes, target)
+      }
+    elsif (!src_instance.kind_of?(NilClass))
+      Transformer.transform_single(src_instance, dst_instance,
+          supported_classes, target)
+    end
+
+    return dst_instance
+  end
 
 protected
 
-	#
-	# Transform a single source instance.
-	#
-	def Transformer.transform_single(src_instance, dst_instance,
-			supported_classes, target)
-		# If the src instance's class is supported, just add it to the dst
-		# instance
-		if (supported_classes.include?(src_instance.class))
-			dst_instance << src_instance
-		# If the src instance's class is an array, then we should check to see
-		# if any of the supporting classes support from_a.
-		elsif (src_instance.kind_of?(Array))
-			new_src_instance = nil
-
-			# Walk each supported class calling from_a if exported
-			supported_classes.each { |sup_class|
-				next if (sup_class.respond_to?('from_a') == false)
-
-				new_src_instance = sup_class.from_a(src_instance)
-
-				if (new_src_instance != nil)
-					dst_instance << new_src_instance
-					break
-				end
-			}
-
-			# If we don't have a valid new src instance, then we suck
-			if (new_src_instance == nil)
-				bomb_translation(src_instance, target)
-			end
-
-		# If the source instance is a string, query each of the supported
-		# classes to see if they can serialize it to their particular data
-		# type.
-		elsif (src_instance.kind_of?(String))
-			new_src_instance = nil
-
-			# Walk each supported class calling from_s if exported
-			supported_classes.each { |sup_class|
-				next if (sup_class.respond_to?('from_s') == false)
-
-				new_src_instance = sup_class.from_s(src_instance)
-
-				if (new_src_instance != nil)
-					dst_instance << new_src_instance
-					break
-				end
-			}
-
-			# If we don't have a valid new src instance, then we suck
-			if (new_src_instance == nil)
-				bomb_translation(src_instance, target)
-			end
-		# Otherwise, bomb translation
-		else
-			bomb_translation(src_instance, target)
-		end
-	end
-
-	def Transformer.bomb_translation(src_instance, target) # :nodoc:
-		error = "Invalid source class (#{src_instance.class})"
-
-		if (target != nil)
-			error += " for #{target}"
-		end
-
-		raise ArgumentError, error, caller
-	end
+  #
+  # Transform a single source instance.
+  #
+  def Transformer.transform_single(src_instance, dst_instance,
+      supported_classes, target)
+    # If the src instance's class is supported, just add it to the dst
+    # instance
+    if (supported_classes.include?(src_instance.class))
+      dst_instance << src_instance
+    # If the src instance's class is an array, then we should check to see
+    # if any of the supporting classes support from_a.
+    elsif (src_instance.kind_of?(Array))
+      new_src_instance = nil
+
+      # Walk each supported class calling from_a if exported
+      supported_classes.each { |sup_class|
+        next if (sup_class.respond_to?('from_a') == false)
+
+        new_src_instance = sup_class.from_a(src_instance)
+
+        if (new_src_instance != nil)
+          dst_instance << new_src_instance
+          break
+        end
+      }
+
+      # If we don't have a valid new src instance, then we suck
+      if (new_src_instance == nil)
+        bomb_translation(src_instance, target)
+      end
+
+    # If the source instance is a string, query each of the supported
+    # classes to see if they can serialize it to their particular data
+    # type.
+    elsif (src_instance.kind_of?(String))
+      new_src_instance = nil
+
+      # Walk each supported class calling from_s if exported
+      supported_classes.each { |sup_class|
+        next if (sup_class.respond_to?('from_s') == false)
+
+        new_src_instance = sup_class.from_s(src_instance)
+
+        if (new_src_instance != nil)
+          dst_instance << new_src_instance
+          break
+        end
+      }
+
+      # If we don't have a valid new src instance, then we suck
+      if (new_src_instance == nil)
+        bomb_translation(src_instance, target)
+      end
+    # Otherwise, bomb translation
+    else
+      bomb_translation(src_instance, target)
+    end
+  end
+
+  def Transformer.bomb_translation(src_instance, target) # :nodoc:
+    error = "Invalid source class (#{src_instance.class})"
+
+    if (target != nil)
+      error += " for #{target}"
+    end
+
+    raise ArgumentError, error, caller
+  end
 
 end
 

data/lib/rex/ui/interactive.rb

@@ -10,292 +10,292 @@ module Ui
 ###
 module Interactive
 
-	#
-	# Interactive sessions by default may interact with the local user input
-	# and output.
-	#
-	include Rex::Ui::Subscriber
+  #
+  # Interactive sessions by default may interact with the local user input
+  # and output.
+  #
+  include Rex::Ui::Subscriber
 
-	#
-	# Starts interacting with the session at the most raw level, simply
-	# forwarding input from user_input to rstream and forwarding input from
-	# rstream to user_output.
-	#
-	def interact(user_input, user_output)
+  #
+  # Starts interacting with the session at the most raw level, simply
+  # forwarding input from user_input to rstream and forwarding input from
+  # rstream to user_output.
+  #
+  def interact(user_input, user_output)
 
-		# Detach from any existing console
-		if(self.interacting)
-			detach()
-		end
+    # Detach from any existing console
+    if(self.interacting)
+      detach()
+    end
 
-		init_ui(user_input, user_output)
+    init_ui(user_input, user_output)
 
-		self.interacting = true
-		self.completed = false
+    self.interacting = true
+    self.completed = false
 
-		eof = false
+    eof = false
 
-		# Start the readline stdin monitor
-		# XXX disabled
-		# user_input.readline_start() if user_input.supports_readline
+    # Start the readline stdin monitor
+    # XXX disabled
+    # user_input.readline_start() if user_input.supports_readline
 
-		# Handle suspend notifications
-		handle_suspend
+    # Handle suspend notifications
+    handle_suspend
 
-		# As long as we're interacting...
-		while (self.interacting == true)
+    # As long as we're interacting...
+    while (self.interacting == true)
 
-			begin
-				_interact
+      begin
+        _interact
 
-			rescue Interrupt
-				# If we get an interrupt exception, ask the user if they want to
-				# abort the interaction.  If they do, then we return out of
-				# the interact function and call it a day.
-				eof = true if (_interrupt)
+      rescue Interrupt
+        # If we get an interrupt exception, ask the user if they want to
+        # abort the interaction.  If they do, then we return out of
+        # the interact function and call it a day.
+        eof = true if (_interrupt)
 
-			rescue EOFError, Errno::ECONNRESET, IOError
-				# If we reach EOF or the connection is reset...
-				eof = true
+      rescue EOFError, Errno::ECONNRESET, IOError
+        # If we reach EOF or the connection is reset...
+        eof = true
 
-			end
+      end
 
-			break if eof
-		end
+      break if eof
+    end
 
-		begin
+    begin
 
-			# Restore the suspend handler
-			restore_suspend
+      # Restore the suspend handler
+      restore_suspend
 
-			# If we've hit eof, call the interact complete handler
-			_interact_complete if (eof == true)
+      # If we've hit eof, call the interact complete handler
+      _interact_complete if (eof == true)
 
-			# Shutdown the readline thread
+      # Shutdown the readline thread
  			# XXX disabled
-			# user_input.readline_stop() if user_input.supports_readline
-
-			# Detach from the input/output handles
-			reset_ui()
-
-		ensure
-			# Mark this as completed
-			self.completed = true
-		end
-
-		# Return whether or not EOF was reached
-		return eof
-	end
-
-	#
-	# Stops the current interaction
-	#
-	def detach
-		if (self.interacting)
-			self.interacting = false
-			while(not self.completed)
-				::IO.select(nil, nil, nil, 0.25)
-			end
-		end
-	end
-
-	#
-	# Whether or not the session is currently being interacted with
-	#
-	attr_accessor   :interacting
-
-	#
-	# Whether or not the session has completed interaction
-	#
-	attr_accessor	:completed
-
-	attr_accessor :on_print_proc
-	attr_accessor :on_command_proc
+      # user_input.readline_stop() if user_input.supports_readline
+
+      # Detach from the input/output handles
+      reset_ui()
+
+    ensure
+      # Mark this as completed
+      self.completed = true
+    end
+
+    # Return whether or not EOF was reached
+    return eof
+  end
+
+  #
+  # Stops the current interaction
+  #
+  def detach
+    if (self.interacting)
+      self.interacting = false
+      while(not self.completed)
+        ::IO.select(nil, nil, nil, 0.25)
+      end
+    end
+  end
+
+  #
+  # Whether or not the session is currently being interacted with
+  #
+  attr_accessor   :interacting
+
+  #
+  # Whether or not the session has completed interaction
+  #
+  attr_accessor	:completed
+
+  attr_accessor :on_print_proc
+  attr_accessor :on_command_proc
 
 protected
 
-	#
-	# The original suspend proc.
-	#
-	attr_accessor :orig_suspend
-
-	#
-	# Stub method that is meant to handler interaction
-	#
-	def _interact
-	end
-
-	#
-	# Called when an interrupt is sent.
-	#
-	def _interrupt
-		true
-	end
-
-	#
-	# Called when a suspend is sent.
-	#
-	def _suspend
-		false
-	end
-
-	#
-	# Called when interaction has completed and one of the sides has closed.
-	#
-	def _interact_complete
-		true
-	end
-
-	#
-	# Read from remote and write to local.
-	#
-	def _stream_read_remote_write_local(stream)
-		data = stream.get
-
-		self.on_print_proc.call(data) if self.on_print_proc
-		user_output.print(data)
-	end
-
-	#
-	# Read from local and write to remote.
-	#
-	def _stream_read_local_write_remote(stream)
-		data = user_input.gets
-
-		self.on_command_proc.call(data) if self.on_command_proc
-		stream.put(data)
-	end
-
-	#
-	# The local file descriptor handle.
-	#
-	def _local_fd
-		user_input.fd
-	end
-
-	#
-	# The remote file descriptor handle.
-	#
-	def _remote_fd(stream)
-		stream.fd
-	end
-
-	#
-	# Interacts with two streaming connections, reading data from one and
-	# writing it to the other.  Both are expected to implement Rex::IO::Stream.
-	#
-	def interact_stream(stream)
-		while self.interacting
-
-			# Select input and rstream
-			sd = Rex::ThreadSafe.select([ _local_fd, _remote_fd(stream) ], nil, nil, 0.25)
-
-			# Cycle through the items that have data
-			# From the stream?  Write to user_output.
-			sd[0].each { |s|
-				if (s == _remote_fd(stream))
-					_stream_read_remote_write_local(stream)
-				# From user_input?  Write to stream.
-				elsif (s == _local_fd)
-					_stream_read_local_write_remote(stream)
-				end
-			} if (sd)
-
-			Thread.pass
-		end
-	end
-
-
-	#
-	# Interacts between a local stream and a remote ring buffer. This has to use
-	# a secondary thread to prevent the select on the local stream from blocking
-	#
-	def interact_ring(ring)
-		begin
-
-		rdr = Rex::ThreadFactory.spawn("RingMonitor", false) do
-			seq = nil
-			while self.interacting
-
-				# Look for any pending data from the remote ring
-				nseq,data = ring.read_data(seq)
-
-				# Update the sequence number if necessary
-				seq = nseq || seq
-
-				# Write output to the local stream if successful
-				user_output.print(data) if data
-
-				# Wait for new data to arrive on this session
-				ring.wait(seq)
-			end
-		end
-
-		while self.interacting
-
-			# Look for any pending input from the local stream
-			sd = Rex::ThreadSafe.select([ _local_fd ], nil, [_local_fd], 5.0)
-
-			# Write input to the ring's input mechanism
-			if sd
-				data = user_input.gets
-				ring.put(data)
-			end
-		end
-
-		ensure
-			rdr.kill
-		end
-	end
-
-
-	#
-	# Installs a signal handler to monitor suspend signal notifications.
-	#
-	def handle_suspend
-		if (orig_suspend == nil)
-			begin
-				self.orig_suspend = Signal.trap("TSTP") {
-					_suspend
-				}
-			rescue
-			end
-		end
-	end
-
-	#
-	# Restores the previously installed signal handler for suspend
-	# notifications.
-	#
-	def restore_suspend
-		begin
-			if (orig_suspend)
-				Signal.trap("TSTP", orig_suspend)
-			else
-				Signal.trap("TSTP", "DEFAULT")
-			end
-			self.orig_suspend = nil
-		rescue
-		end
-	end
-
-	#
-	# Prompt the user for input if possible.
-	# XXX: This is not thread-safe on Windows
-	#
-	def prompt(query)
-		if (user_output and user_input)
-			user_output.print("\n" + query)
-			user_input.sysread(2)
-		end
-	end
-
-	#
-	# Check the return value of a yes/no prompt
-	#
-	def prompt_yesno(query)
-		(prompt(query + " [y/N]  ") =~ /^y/i) ? true : false
-	end
+  #
+  # The original suspend proc.
+  #
+  attr_accessor :orig_suspend
+
+  #
+  # Stub method that is meant to handler interaction
+  #
+  def _interact
+  end
+
+  #
+  # Called when an interrupt is sent.
+  #
+  def _interrupt
+    true
+  end
+
+  #
+  # Called when a suspend is sent.
+  #
+  def _suspend
+    false
+  end
+
+  #
+  # Called when interaction has completed and one of the sides has closed.
+  #
+  def _interact_complete
+    true
+  end
+
+  #
+  # Read from remote and write to local.
+  #
+  def _stream_read_remote_write_local(stream)
+    data = stream.get
+
+    self.on_print_proc.call(data) if self.on_print_proc
+    user_output.print(data)
+  end
+
+  #
+  # Read from local and write to remote.
+  #
+  def _stream_read_local_write_remote(stream)
+    data = user_input.gets
+
+    self.on_command_proc.call(data) if self.on_command_proc
+    stream.put(data)
+  end
+
+  #
+  # The local file descriptor handle.
+  #
+  def _local_fd
+    user_input.fd
+  end
+
+  #
+  # The remote file descriptor handle.
+  #
+  def _remote_fd(stream)
+    stream.fd
+  end
+
+  #
+  # Interacts with two streaming connections, reading data from one and
+  # writing it to the other.  Both are expected to implement Rex::IO::Stream.
+  #
+  def interact_stream(stream)
+    while self.interacting
+
+      # Select input and rstream
+      sd = Rex::ThreadSafe.select([ _local_fd, _remote_fd(stream) ], nil, nil, 0.25)
+
+      # Cycle through the items that have data
+      # From the stream?  Write to user_output.
+      sd[0].each { |s|
+        if (s == _remote_fd(stream))
+          _stream_read_remote_write_local(stream)
+        # From user_input?  Write to stream.
+        elsif (s == _local_fd)
+          _stream_read_local_write_remote(stream)
+        end
+      } if (sd)
+
+      Thread.pass
+    end
+  end
+
+
+  #
+  # Interacts between a local stream and a remote ring buffer. This has to use
+  # a secondary thread to prevent the select on the local stream from blocking
+  #
+  def interact_ring(ring)
+    begin
+
+    rdr = Rex::ThreadFactory.spawn("RingMonitor", false) do
+      seq = nil
+      while self.interacting
+
+        # Look for any pending data from the remote ring
+        nseq,data = ring.read_data(seq)
+
+        # Update the sequence number if necessary
+        seq = nseq || seq
+
+        # Write output to the local stream if successful
+        user_output.print(data) if data
+
+        # Wait for new data to arrive on this session
+        ring.wait(seq)
+      end
+    end
+
+    while self.interacting
+
+      # Look for any pending input from the local stream
+      sd = Rex::ThreadSafe.select([ _local_fd ], nil, [_local_fd], 5.0)
+
+      # Write input to the ring's input mechanism
+      if sd
+        data = user_input.gets
+        ring.put(data)
+      end
+    end
+
+    ensure
+      rdr.kill
+    end
+  end
+
+
+  #
+  # Installs a signal handler to monitor suspend signal notifications.
+  #
+  def handle_suspend
+    if (orig_suspend == nil)
+      begin
+        self.orig_suspend = Signal.trap("TSTP") {
+          _suspend
+        }
+      rescue
+      end
+    end
+  end
+
+  #
+  # Restores the previously installed signal handler for suspend
+  # notifications.
+  #
+  def restore_suspend
+    begin
+      if (orig_suspend)
+        Signal.trap("TSTP", orig_suspend)
+      else
+        Signal.trap("TSTP", "DEFAULT")
+      end
+      self.orig_suspend = nil
+    rescue
+    end
+  end
+
+  #
+  # Prompt the user for input if possible.
+  # XXX: This is not thread-safe on Windows
+  #
+  def prompt(query)
+    if (user_output and user_input)
+      user_output.print("\n" + query)
+      user_input.sysread(2)
+    end
+  end
+
+  #
+  # Check the return value of a yes/no prompt
+  #
+  def prompt_yesno(query)
+    (prompt(query + " [y/N]  ") =~ /^y/i) ? true : false
+  end
 
 end