librex 0.0.20 → 0.0.21

data/lib/rex/struct2/c_struct_template.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+class CStructTemplate
+
+	require 'rex/struct2/c_struct'
+
+	attr_reader  :template, :template_create_restraints, :template_apply_restraint
+	attr_writer  :template, :template_create_restraints, :template_apply_restraint
+
+	def initialize(*tem)
+		self.template = tem
+		self.template_create_restraints = [ ]
+		self.template_apply_restraint = [ ]
+	end
+
+	def create_restraints(*ress)
+		self.template_create_restraints = ress
+		return self
+	end
+
+	def apply_restraint(*ress)
+		self.template_apply_restraint = ress
+		return self
+	end
+
+	def make_struct
+		Rex::Struct2::CStruct.new(*self.template).
+		  create_restraints(*self.template_create_restraints).
+		  apply_restraint(*self.template_apply_restraint)
+	end
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/constant.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+# this is a "constant" element.  It's not actually constant, you can set it
+# via the constructor and value.  It doesn't do from_s/to_s, etc.
+
+# what use is it? Well it's useful for doing constant restraints (like fix
+# sized arrays), and probably not a ton more.
+
+class Constant
+	
+	require 'rex/struct2/element'
+	include Rex::Struct2::Element
+
+	def initialize(value)
+		self.value = value
+	end
+
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/element.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+module Element
+
+	# elements should have to_s, but we don't define it here because
+	# it will just overlap with inheritence and cause issues
+
+	attr_reader  :value, :restraint, :container
+	attr_writer  :restraint, :container
+
+	# update the restraints on any value change
+	def value=(newval)
+		@value = newval
+		self.update_restraint
+	end
+
+	# avoid conflicting with normal namespace length()
+	def slength
+		to_s().length()
+	end
+
+	def update_restraint
+		if self.restraint
+			# Sort of a hack, but remove the restraint before we update, so we aren't using
+			# the old restraint during calculating the restraint update value
+			old_restraint, self.restraint = self.restraint, nil
+			old_restraint.update(self.slength)
+			self.restraint = old_restraint
+		end
+
+		if self.container
+			self.container.update_restraint
+		end
+	end
+
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/generic.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+class Generic
+	
+	require 'rex/struct2/element'
+	include Rex::Struct2::Element
+
+	attr_reader  :default
+	attr_writer  :default
+
+	attr_accessor :mask, :check_mask
+
+	def initialize(packspec, signed=false, default=nil)
+		@packspec = packspec
+		@default  = default
+
+		bytelen = [ -1 ].pack(@packspec).length
+		self.mask = (1 << (8 * bytelen)) - 1
+
+		if signed
+			self.check_mask = 1 << (8 * bytelen - 1)
+		else
+			self.check_mask = 0
+		end
+
+		reset()
+	end
+
+	def reset
+		self.value = @default
+	end
+
+	def to_s
+		# I realize this will bomb out if this isn't an integer, for
+		# example if it is nil.  That should only happen for a user
+		# error so that's what I want it to do...
+		string = [ @value ].pack(@packspec)
+		
+		if restraint && restraint.max
+			return string.slice(0, restraint.max)
+		else
+			return string
+		end
+		# what to do for restraint.min?!?
+	end
+
+	def from_s(bytes)
+		value = bytes.unpack(@packspec)[0]
+		# return nil on unpack error
+		return if !value
+		len = slength()
+		# error on any restraint issues
+		return if restraint && restraint.max && len > restraint.max
+		return if restraint && restraint.min && len < restraint.min
+		# else set our value and return length used for this element
+
+		if (value & check_mask) != 0
+			value = -((~value & mask) + 1)
+		end
+
+		self.value = value
+		return(len)
+	end
+
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/restraint.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+class Restraint
+
+	attr_reader  :max_object, :min_object, :should_update,
+	  :max_transform, :min_transform, :max_inv_transform, :min_inv_transform
+	attr_writer  :max_object, :min_object, :should_update,
+	  :max_transform, :min_transform, :max_inv_transform, :min_inv_transform
+
+
+	def initialize(
+	  max_object=nil, min_object=nil, should_update=false,
+	  max_transform=nil, min_transform=nil,
+	  max_inv_transform=nil, min_inv_transform=nil
+	)
+		@max_object    = max_object
+		@min_object    = min_object
+		@should_update = should_update
+
+		def_trans = proc {|i| i}
+
+		@max_transform       = max_transform == nil ? def_trans : max_transform
+		@min_transform       = min_transform == nil ? def_trans : min_transform
+		@max_inv_transform   = max_inv_transform == nil ? def_trans : max_inv_transform
+		@min_inv_transform   = min_inv_transform == nil ? def_trans : min_inv_transform
+	end
+
+	def min
+		return if !min_object
+		return min_object.value
+	end
+
+	def max
+		return if !max_object
+		return max_object.value
+	end
+
+	# update values if request (ie string set field to its length)
+	def update(value)
+		return if !@should_update
+
+		max_object.value = max_inv_transform.call(value) if max_object
+		min_object.value = min_inv_transform.call(value) if min_object
+	end
+
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/s_string.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+class SString
+	
+	require 'rex/struct2/element'
+	require 'rex/struct2/constant'
+	include Rex::Struct2::Element
+
+	attr_reader  :size, :default, :pad
+	attr_writer  :default, :pad
+
+	def initialize(size=nil, default=nil, pad=nil)
+		self.size = size
+		@default  = default
+		@pad      = pad
+		reset()
+	end
+
+	def size=(newsize)
+		if !newsize
+			self.restraint = nil
+		else
+			res = Rex::Struct2::Constant.new(newsize)
+			self.restraint = Rex::Struct2::Restraint.new(res, res, false)
+		end
+	end
+
+	def reset
+		self.value = @default
+	end
+
+	def to_s
+		string = self.value
+
+		return if !string
+
+		# pad if short
+		if restraint && restraint.min && self.pad && restraint.min > string.length
+			string += self.pad * (restraint.min - string.length)
+		end
+		# truncate if long
+		if restraint && restraint.max
+			string = string.slice(0, restraint.max)
+		end
+
+		return string
+	end
+
+	def from_s(bytes)
+		# we don't have enough bytes to satisfy our minimum
+		if restraint && restraint.min && bytes.length < restraint.min
+			return
+		end
+
+		if restraint && restraint.max
+			self.value = bytes.slice(0, restraint.max)
+		else
+			self.value = bytes.dup
+		end
+
+
+		return(self.slength)
+	end
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/struct2/s_struct.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+class SStruct
+
+	require 'rex/struct2/element'
+	include Rex::Struct2::Element
+
+	attr_reader  :leftover, :elements
+	attr_writer  :leftover, :elements
+
+	private :elements, :elements=
+
+	# watch out!, leftover returns our copy of the string!  so don't do
+	# anything stupid like struct.leftover.slice! !!
+
+	def initialize(*opts)
+		self.elements = [ ]
+		self.add_element(*opts)
+	end
+
+
+	def reset
+		elements.each {|e| e.reset}
+		return self
+	end
+
+	def add_element(*objs)
+		objs.each { |o|
+			elements << o
+			o.container = self
+		}
+		return self
+	end
+
+	def <<(obj)
+		self.add_element(obj)
+	end
+
+	def to_s
+		# !!! what do we do on mix restraint issues? just fail?
+		# maybe throw an exception, because that is most likely
+		# a usage error
+
+		buff = ""
+		elements.each do |e|
+			buff << e.to_s
+		end
+		
+		if restraint && restraint.max
+			return buff.slice(0, restraint.max)
+		else
+			return buff
+		end
+	end
+
+	def length
+		return elements.length
+	end
+
+	def [](obj)
+		return elements[obj]
+	end
+
+	def each(&block)
+		return elements.each(&block)
+	end
+
+	def from_s(obytes)
+		# make my own copy so I can chop it up
+		bytes = obytes.dup
+		length = 0
+
+		# I don't think we should call update_restraint here, but
+		# I could have mis thought or something
+
+		# if we have a restraint (and if there is a val) truncate
+		if restraint
+			max = restraint.max
+			bytes = bytes.slice(0, max) if max
+		end
+
+		elements.each { |e|
+			used = e.from_s(bytes)
+			return if !used
+			bytes.slice!(0, used)
+			length += used
+		}
+
+		# make sure we matched out min restraint, else return failure
+		if restraint
+			min = restraint.min
+			return if min && length < min
+		end
+
+		# I guess this is me getting "set", so I should have a value
+		# and I should update my restraints on set
+		self.value = obytes.slice(0, length)
+
+		self.leftover = bytes
+		return(length)
+	end
+
+end
+
+# end Rex::Struct2
+end
+end

data/lib/rex/sync.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rex/sync/thread_safe'
+require 'rex/sync/ref'
+require 'rex/sync/read_write_lock'
+require 'rex/sync/event'

data/lib/rex/sync/event.rb

@@ -0,0 +1,94 @@
+require 'thread'
+
+module Rex
+module Sync
+
+###
+#
+# This class wraps the logical ConditionVariable class to make it an easier to
+# work with interface that is similar to Windows' synchronization events.
+#
+###
+class Event
+
+	Infinite = 10000
+
+	#
+	# Initializes a waitable event.  The state parameter initializes the
+	# default state of the event.  If auto_reset is true, any calls to set()
+	# will automatically reset the event back to an unset state.
+	#
+	def initialize(state = false, auto_reset = true, param = nil)
+		self.state      = state
+		self.auto_reset = auto_reset
+		self.param      = param
+		self.mutex      = Mutex.new
+		self.cond       = ConditionVariable.new
+	end
+
+	#
+	# Sets the event and wakes up anyone who was waiting.
+	#
+	def set(param = nil)
+		self.param = param
+
+		self.mutex.synchronize {
+			# If this event does not automatically reset its state,
+			# set the state to true
+			if (auto_reset == false)
+				self.state = true
+			end
+
+			self.cond.broadcast
+		}
+	end
+
+	#
+	# Resets the signaled state to false.
+	#
+	def reset
+		self.param = nil
+		self.state = false
+	end
+
+	#
+	# Alias notify with set.
+	#
+	alias notify set
+
+	#
+	# Waits for the event to become signaled.  Timeout is measured in
+	# seconds.  Raises TimeoutError if the condition does not become signaled.
+	#
+
+	begin
+		# XXX: we need to replace this code
+		#      continuations slow down YARV
+		require "continuation" if not defined? callcc
+	rescue ::LoadError
+	end
+
+	def wait(t = Infinite)
+		callcc { |ctx|
+			self.mutex.synchronize {
+				ctx.call if (self.state == true)
+
+				Timeout.timeout(t) {
+					self.cond.wait(self.mutex)
+				}
+			}
+		}
+
+		return self.param
+	end
+
+protected
+
+	attr_accessor :state, :auto_reset # :nodoc:
+	attr_accessor :param, :mutex, :cond # :nodoc:
+
+end
+
+end
+end
+