librex 0.0.19 → 0.0.20

data/lib/rex/io/stream_server.rb

@@ -1,211 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

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

data/lib/rex/logging/log_dispatcher.rb

@@ -1,179 +0,0 @@
-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