librex 0.0.13 → 0.0.15

data/lib/rex/struct2/c_struct_template.rb

@@ -1,39 +0,0 @@
-#!/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

@@ -1,26 +0,0 @@
-#!/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

@@ -1,44 +0,0 @@
-#!/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

@@ -1,73 +0,0 @@
-#!/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

@@ -1,54 +0,0 @@
-#!/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

@@ -1,72 +0,0 @@
-#!/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

@@ -1,111 +0,0 @@
-#!/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

@@ -1,6 +0,0 @@
-#!/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

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