librex 0.0.20 → 0.0.21

data/lib/rex/ui.rb

@@ -0,0 +1,21 @@
+#
+# This file includes everything needed to interact with the user interface
+# wrappers of the rex library.
+#
+
+# General classes
+require 'rex/ui/output'
+require 'rex/ui/progress_tracker'
+
+# Text-based user interfaces
+require 'rex/ui/text/input'
+require 'rex/ui/text/shell'
+require 'rex/ui/text/dispatcher_shell'
+require 'rex/ui/text/irb_shell'
+
+require 'rex/ui/text/color'
+require 'rex/ui/text/table'
+
+# Ui subscriber
+require 'rex/ui/subscriber'
+require 'rex/ui/interactive'

data/lib/rex/ui/interactive.rb

@@ -0,0 +1,298 @@
+module Rex
+module Ui
+
+###
+#
+# This class implements the stubs that are needed to provide an interactive
+# user interface that is backed against something arbitrary.
+#
+###
+module Interactive
+
+	#
+	# 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)
+
+		# Detach from any existing console
+		if(self.interacting)
+			detach()
+		end
+
+		init_ui(user_input, user_output)
+
+		self.interacting = true
+		self.completed = false
+
+		eof = false
+
+		# Start the readline stdin monitor
+		# XXX disabled
+		# user_input.readline_start() if user_input.supports_readline
+
+		# Handle suspend notifications
+		handle_suspend
+
+		# As long as we're interacting...
+		while (self.interacting == true)
+
+			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 EOFError, Errno::ECONNRESET, IOError
+				# If we reach EOF or the connection is reset...
+				eof = true
+
+			end
+
+			break if eof
+		end
+
+		begin
+
+			# Restore the suspend handler
+			restore_suspend
+
+			# If we've hit eof, call the interact complete handler
+			_interact_complete if (eof == true)
+
+			# 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
+
+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
+
+		user_output.print(data)
+	end
+
+	#
+	# Read from local and write to remote.
+	#
+	def _stream_read_local_write_remote(stream)
+		data = user_input.gets
+
+		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
+
+end
+end
+

data/lib/rex/ui/output.rb

@@ -0,0 +1,78 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+
+###
+#
+# This class acts as a generic base class for outputing data.  It
+# only provides stubs for the simplest form of outputing information.
+#
+###
+class Output
+
+	# General output
+	require 'rex/ui/output/none'
+
+	# Text-based output
+	require 'rex/ui/text/output'
+
+	#
+	# Prints an error message.
+	#
+	def print_error(msg='')
+	end
+
+	#
+	# Prints a 'good' message.
+	#
+	def print_good(msg='')
+	end
+
+	def print_debug(msg='')
+	end
+
+	#
+	# Prints a status line.
+	#
+	def print_status(msg='')
+	end
+
+	#
+	# Prints an undecorated line of information.
+	#
+	def print_line(msg='')
+	end
+
+	#
+	# Prints a message with no decoration.
+	#
+	def print(msg='')
+	end
+
+	#
+	# Flushes any buffered output.
+	#
+	def flush
+	end
+
+	#
+	# Called to tell the output medium that we're at a prompt.
+	# This is used to allow the output medium to display an extra
+	# carriage return
+	#
+	def prompting(v = true)
+		@at_prompt = v
+	end
+
+	#
+	# Returns whether or not we're at a prompt currently
+	#
+	def prompting?
+		@at_prompt
+	end
+
+end
+
+end
+end

data/lib/rex/ui/output/none.rb

@@ -0,0 +1,18 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+
+###
+#
+# This output medium implements all the required output routines but does not
+# back them against any sort of device.  This is basically meant to be put in
+# place of something that expects to be able to deal with a functional output
+# device when one does not actually exist.
+#
+###
+class Output::None < Rex::Ui::Output
+end
+
+end
+end

data/lib/rex/ui/progress_tracker.rb

@@ -0,0 +1,96 @@
+module Rex
+module Ui
+
+###
+#
+# This module tracks the progress of an arbitrary task in a generic fashion.
+# The actual implementation is left up to the thing that derives from this
+# module.
+#
+###
+class ProgressTracker
+
+	require 'rex/ui/text/progress_tracker'
+
+	def initialize
+		self.start = 0
+		self.stop  = 0
+		self.pos   = 0
+	end
+
+	#
+	# Sets start and step using a range.
+	#
+	def range=(rng)
+		self.start = rng.begin
+		self.stop  = rng.end
+	end
+
+	#
+	# Sets the start and resets the position.
+	#
+	def start=(start)
+		@start   = start
+		self.pos = start
+	end
+
+	#
+	# Steps with a given message and step size.
+	#
+	def step(status = nil, n = 1)
+		self.pos += n if (self.pos + n <= self.stop)
+
+		step_status(status)
+
+		self.pos
+	end
+
+	#
+	# Resets the current step location.
+	#
+	def reset(n = self.start)
+		self.pos = n
+	end
+
+	#
+	# Passes a generic status message that isn't necessarily associated
+	# with a step event.
+	#
+	def status(msg = nil)
+	end
+
+	#
+	# Updates the status associated with the current step.
+	#
+	def step_status(msg = nil)
+	end
+
+	#
+	# An error occurred that may result in aborting the progress.
+	#
+	def error(msg = nil)
+	end
+
+	#
+	# Progress has been aborted, the reason is supplied in msg.
+	#
+	def abort(msg = nil)
+	end
+
+	#
+	# The start of the progress.
+	#
+	attr_reader   :start
+	#
+	# The last position in the progress.
+	#
+	attr_accessor :stop
+	#
+	# The current position in the progress.
+	#
+	attr_accessor :pos
+
+end
+
+end
+end