librex 0.0.20 → 0.0.21

data/lib/rex/io/stream_server.rb

@@ -0,0 +1,211 @@
+module Rex
+module IO
+
+###
+#
+# This mixin provides the framework and interface for implementing a streaming
+# server that can listen for and accept stream client connections.  Stream
+# servers extend this class and are required to implement the following
+# methods:
+#
+#   accept
+#   fd
+#
+###
+module StreamServer
+
+	##
+	#
+	# Abstract methods
+	#
+	##
+
+	##
+	#
+	# Default server monitoring and client management implementation follows
+	# below.
+	#
+	##
+
+	#
+	# This callback is notified when a client connects.
+	#
+	def on_client_connect(client)
+		if (on_client_connect_proc)
+			on_client_connect_proc.call(client)
+		end
+	end
+
+	#
+	# This callback is notified when a client connection has data that needs to
+	# be processed.
+	#
+	def on_client_data(client)
+		if (on_client_data_proc)
+			on_client_data_proc.call(client)
+		end
+	end
+
+	#
+	# This callback is notified when a client connection has closed.
+	#
+	def on_client_close(client)
+		if (on_client_close_proc)
+			on_client_close_proc.call(client)
+		end
+	end
+
+	#
+	# Start monitoring the listener socket for connections and keep track of
+	# all client connections.
+	#
+	def start
+		self.clients = []
+
+		self.listener_thread = Rex::ThreadFactory.spawn("StreamServerListener", false) {
+			monitor_listener
+		}
+		self.clients_thread = Rex::ThreadFactory.spawn("StreamServerClientMonitor", false) {
+			monitor_clients
+		}
+	end
+
+	#
+	# Terminates the listener monitoring threads and closes all active clients.
+	#
+	def stop
+		self.listener_thread.kill
+		self.clients_thread.kill
+
+		self.clients.each { |cli|
+			close_client(cli)
+		}
+	end
+
+	#
+	# This method closes a client connection and cleans up the resources
+	# associated with it.
+	#
+	def close_client(client)
+		if (client)
+			clients.delete(client)
+
+			begin
+				client.close
+			rescue IOError
+			end
+		end
+	end
+
+	#
+	# This method waits on the server listener thread
+	#
+	def wait
+		self.listener_thread.join if self.listener_thread
+	end
+
+	##
+	#
+	# Callback procedures.
+	#
+	##
+
+	#
+	# This callback procedure can be set and will be called when new clients
+	# connect.
+	#
+	attr_accessor :on_client_connect_proc
+	#
+	# This callback procedure can be set and will be called when clients
+	# have data to be processed.
+	#
+	attr_accessor :on_client_data_proc
+	#
+	# This callback procedure can be set and will be called when a client
+	# disconnects from the server.
+	#
+	attr_accessor :on_client_close_proc
+
+	attr_accessor :clients # :nodoc:
+	attr_accessor :listener_thread, :clients_thread # :nodoc:
+
+protected
+
+	#
+	# This method monitors the listener socket for new connections and calls
+	# the +on_client_connect+ callback routine.
+	#
+	def monitor_listener
+
+		while true
+			begin
+				cli = accept
+				if not cli
+					elog("The accept() returned nil in stream server listener monitor:  #{fd.inspect}")
+					::IO.select(nil, nil, nil, 0.10)
+					next
+				end
+
+				# Append to the list of clients
+				self.clients << cli
+
+				# Initialize the connection processing
+				on_client_connect(cli)
+
+			# Skip exceptions caused by accept() [ SSL ]
+			rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+			rescue ::Interrupt
+				raise $!
+			rescue ::Exception
+				elog("Error in stream server server monitor: #{$!}")
+				rlog(ExceptionCallStack)
+				break
+			end
+		end
+	end
+
+	#
+	# This method monitors client connections for data and calls the
+	# +on_client_data+ routine when new data arrives.
+	#
+	def monitor_clients
+		begin
+			if (clients.length == 0)
+				Rex::ThreadSafe::sleep(0.25)
+				next
+			end
+
+			sd = Rex::ThreadSafe.select(clients)
+
+			sd[0].each { |cfd|
+				begin
+					on_client_data(cfd)
+				rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+					on_client_close(cfd)
+					close_client(cfd)
+				rescue ::Interrupt
+					raise $!
+				rescue ::Exception
+					close_client(cfd)
+					elog("Error in stream server client monitor: #{$!}")
+					rlog(ExceptionCallStack)
+
+				end
+			}
+
+		rescue ::Rex::StreamClosedError => e
+			# Remove the closed stream from the list
+			clients.delete(e.stream)
+		rescue ::Interrupt
+			raise $!
+		rescue ::Exception
+			elog("Error in stream server client monitor: #{$!}")
+			rlog(ExceptionCallStack)
+		end while true
+	end
+
+end
+
+end
+end
+

data/lib/rex/job_container.rb

@@ -0,0 +1,187 @@
+module Rex
+
+###
+#
+# This class is the concrete representation of an abstract job.
+#
+###
+class Job
+
+	#
+	# Creates an individual job instance and initializes it with the supplied
+	# parameters.
+	#
+	def initialize(container, jid, name, ctx, run_proc, clean_proc)
+		self.container  = container
+		self.jid        = jid
+		self.name       = name
+		self.run_proc   = run_proc
+		self.clean_proc = clean_proc
+		self.ctx        = ctx
+		self.start_time = nil
+	end
+
+	#
+	# Runs the job in the context of its own thread if the async flag is false.
+	# Otherwise, the job is run inline.
+	#
+	def start(async = false)
+		self.start_time = Time.now
+		if (async)
+			self.job_thread = Rex::ThreadFactory.spawn("JobID(#{jid})-#{name}", false) {
+				# Deschedule our thread momentarily
+				::IO.select(nil, nil, nil, 0.01)
+
+				begin
+					run_proc.call(ctx)
+				ensure
+					clean_proc.call(ctx)
+					container.remove_job(self)
+				end
+			}
+		else
+			begin
+				run_proc.call(ctx)
+			rescue ::Exception
+				container.stop_job(jid)
+				raise $!
+			end
+		end
+	end
+
+	#
+	# Stops the job if it's currently running and calls its cleanup procedure
+	#
+	def stop
+		if (self.job_thread)
+			self.job_thread.kill
+			self.job_thread = nil
+		end
+
+		clean_proc.call(ctx) if (clean_proc)
+	end
+
+	#
+	# The name of the job.
+	#
+	attr_reader :name
+
+	#
+	# The job identifier as assigned by the job container.
+	#
+	attr_reader :jid
+
+	#
+	# The time at which this job was started.
+	#
+	attr_reader :start_time
+
+	#
+	# Some job context.
+	#
+	attr_reader :ctx
+
+protected
+
+	attr_writer   :name #:nodoc:
+	attr_writer   :jid #:nodoc:
+	attr_accessor :job_thread #:nodoc:
+	attr_accessor :container #:nodoc:
+	attr_accessor :run_proc #:nodoc:
+	attr_accessor :clean_proc #:nodoc:
+	attr_writer   :ctx #:nodoc:
+	attr_writer   :start_time #:nodoc:
+
+end
+
+###
+#
+# This class contains zero or more abstract jobs that can be enumerated and
+# stopped in a generic fashion.  This is used to provide a mechanism for
+# keeping track of arbitrary contexts that may or may not require a dedicated
+# thread.
+#
+###
+class JobContainer < Hash
+
+	def initialize
+		self.job_id_pool = 0
+	end
+
+	#
+	# Adds an already running task as a symbolic job to the container.
+	#
+	def add_job(name, ctx, run_proc, clean_proc)
+		real_name = name
+		count     = 0
+		jid       = job_id_pool
+
+		self.job_id_pool += 1
+
+		# If we were not supplied with a job name, pick one from the hat
+		if (real_name == nil)
+			real_name = '#' + jid.to_s
+		end
+
+		# Find a unique job name
+		while (j = self[real_name])
+			real_name  = name + " #{count}"
+			count     += 1
+		end
+
+		j = Job.new(self, jid, real_name, ctx, run_proc, clean_proc)
+
+		self[jid.to_s] = j
+	end
+
+	#
+	# Starts a job using the supplied name and run/clean procedures.
+	#
+	def start_job(name, ctx, run_proc, clean_proc = nil)
+		j = add_job(name, ctx, run_proc, clean_proc)
+		j.start
+
+		j.jid
+	end
+
+	#
+	# Starts a background job that doesn't call the cleanup routine or run
+	# the run_proc in its own thread.  Rather, the run_proc is called
+	# immediately and the clean_proc is never called until the job is removed
+	# from the job container.
+	#
+	def start_bg_job(name, ctx, run_proc, clean_proc = nil, async = true)
+		j = add_job(name, ctx, run_proc, clean_proc)
+		j.start(async)
+
+		j.jid
+	end
+
+	#
+	# Stops the job with the supplied name and forces it to cleanup.  Stopping
+	# the job also leads to its removal.
+	#
+	def stop_job(jid)
+		if (j = self[jid.to_s])
+			j.stop
+
+			remove_job(j)
+		end
+	end
+
+	#
+	# Removes a job that was previously running.  This is typically called when
+	# a job completes its task.
+	#
+	def remove_job(inst)
+		self.delete(inst.jid.to_s)
+	end
+
+protected
+
+	attr_accessor :job_id_pool # :nodoc:
+
+end
+
+end
+

data/lib/rex/logging.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'rex/constants' # for LEV_'s
+require 'rex/logging/log_dispatcher'

data/lib/rex/logging/log_dispatcher.rb

@@ -0,0 +1,179 @@
+require 'rex/sync'
+require 'rex/logging/log_sink'
+
+module Rex
+module Logging
+
+###
+#
+# The log dispatcher associates log sources with log sinks.  A log source
+# is a unique identity that is associated with one and only one log sink.
+# For instance, the framework-core registers the 'core' 
+#
+###
+class LogDispatcher
+
+	#
+	# Creates the global log dispatcher instance and initializes it for use.
+	#
+	def initialize()
+		self.log_sinks      = {}
+		self.log_levels     = {}
+		self.log_sinks_lock = Mutex.new
+	end
+
+	#
+	# Returns the sink that is associated with the supplied source.
+	#
+	def [](src)
+		sink = nil
+
+		log_sinks_lock.synchronize {
+			sink = log_sinks[src]
+		}
+
+		return sink
+	end
+
+	#
+	# Calls the source association routie.
+	#
+	def []=(src, sink)
+		store(src, sink)
+	end
+
+	#
+	# Associates the supplied source with the supplied sink.  If a log level
+	# has already been defined for the source, the level argument is ignored.
+	# Use set_log_level to alter it.
+	#
+	def store(src, sink, level = 0)
+		log_sinks_lock.synchronize {
+			if (log_sinks[src] == nil)
+				log_sinks[src] = sink
+
+				set_log_level(src, level) if (log_levels[src] == nil)
+			else
+				raise(
+					RuntimeError, 
+					"The supplied log source #{src} is already registered.",
+					caller)
+			end
+		}
+	end
+
+	#
+	# Removes a source association if one exists.
+	#
+	def delete(src)
+		sink = nil
+
+		log_sinks_lock.synchronize {
+			sink = log_sinks[src]
+			
+			log_sinks.delete(src)
+		}
+
+		if (sink)
+			sink.cleanup
+
+			return true
+		end
+
+		return false
+	end
+
+	#
+	# Performs the actual log operation against the supplied source
+	#
+	def log(sev, src, level, msg, from)
+		log_sinks_lock.synchronize {
+			if ((sink = log_sinks[src]))
+				next if (log_levels[src] and level > log_levels[src])
+
+				sink.log(sev, src, level, msg, from)
+			end
+		}
+	end
+
+	#
+	# This method sets the log level threshold for a given source.
+	#
+	def set_level(src, level)
+		log_levels[src] = level.to_i
+	end
+
+	#
+	# This method returns the log level threshold of a given source.
+	#
+	def get_level(src)
+		log_levels[src]
+	end
+
+	attr_accessor :log_sinks, :log_sinks_lock # :nodoc:
+	attr_accessor :log_levels # :nodoc:
+end
+
+end
+end
+
+###
+#
+# An instance of the log dispatcher exists in the global namespace, along
+# with stubs for many of the common logging methods.  Various sources can
+# register themselves as a log sink such that logs can be directed at
+# various targets depending on where they're sourced from.  By doing it
+# this way, things like sessions can use the global logging stubs and
+# still be directed at the correct log file.
+#
+###
+ExceptionCallStack = "__EXCEPTCALLSTACK__"
+
+def dlog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_DEBUG, src, level, msg, from)
+end
+
+def elog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_ERROR, src, level, msg, from)
+end
+
+def wlog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_WARN, src, level, msg, from)
+end
+
+def ilog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_INFO, src, level, msg, from)
+end
+
+def rlog(msg, src = 'core', level = 0, from = caller)
+	if (msg == ExceptionCallStack)
+		msg = "\nCall stack:\n" + $@.join("\n") + "\n"
+	end
+
+	$dispatcher.log(LOG_RAW, src, level, msg, from)
+end
+
+def log_source_registered?(src)
+	($dispatcher[src] != nil)
+end
+
+def register_log_source(src, sink, level = nil)
+	$dispatcher[src] = sink
+
+	set_log_level(src, level) if (level)
+end
+
+def deregister_log_source(src)
+	$dispatcher.delete(src)
+end
+
+def set_log_level(src, level)
+	$dispatcher.set_level(src, level)
+end
+
+def get_log_level(src)
+	$dispatcher.get_level(src)
+end
+
+# Creates the global log dispatcher
+$dispatcher = Rex::Logging::LogDispatcher.new