librex 0.0.68 → 0.0.70

data/lib/rex/struct2/s_struct.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 # Rex::Struct2
@@ -7,103 +6,103 @@ 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
+  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
 

data/lib/rex/sync.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/sync/thread_safe'

data/lib/rex/sync/event.rb

@@ -12,81 +12,71 @@ module Sync
 ###
 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
+  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.
+  #
+  def wait(t = Infinite)
+    self.mutex.synchronize {
+      break 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:
+  attr_accessor :state, :auto_reset # :nodoc:
+  attr_accessor :param, :mutex, :cond # :nodoc:
 
 end
 

data/lib/rex/sync/read_write_lock.rb

@@ -18,158 +18,158 @@ module Rex
 ###
 class ReadWriteLock
 
-	#
-	# Initializes a reader/writer lock instance.
-	#
-	def initialize
-		@read_sync_mutex  = Mutex.new
-		@write_sync_mutex = Mutex.new
-		@exclusive_mutex  = Mutex.new
-		@readers          = 0
-		@writer           = false
-	end
-
-	#
-	# Acquires the read lock for the calling thread.
-	#
-	def lock_read
-		read_sync_mutex.lock
-
-		begin
-			# If there are a non-zero number of readers and a
-			# writer is waiting to acquire the exclusive lock,
-			# free up the sync mutex temporarily and lock/unlock
-			# the exclusive lock.  This is to give the writer
-			# thread a chance to acquire the lock and prevents
-			# it from being constantly starved.
-			if ((@readers > 0) and
-			    (@writer))
-				read_sync_mutex.unlock
-				exclusive_mutex.lock
-				exclusive_mutex.unlock
-				read_sync_mutex.lock
-			end
-
-			# Increment the active reader count
-			@readers += 1
-
-			# If we now have just one reader, acquire the exclusive
-			# lock.  Track the thread owner so that we release the
-			# lock from within the same thread context later on.
-			if (@readers == 1)
-				exclusive_mutex.lock
-
-				@owner = Thread.current
-			end
-		ensure
-			read_sync_mutex.unlock
-		end
-	end
-
-	#
-	# Releases the read lock for the calling thread.
-	#
-	def unlock_read
-		read_sync_mutex.lock
-
-		begin
-			unlocked = false
-
-			# Keep looping until we've lost this thread's reader
-			# lock
-			while (!unlocked)
-				# If there are no more readers left after this one
-				if (@readers - 1 == 0)
-					# If the calling thread is the owner of the exclusive
-					# reader lock, then let's release it
-					if (Thread.current == @owner)
-						@owner = nil
-
-						exclusive_mutex.unlock
-					end
-				# If there is more than one reader left and this thread is
-				# the owner of the exclusive lock, then keep looping so that
-				# we can eventually unlock the exclusive mutex in this thread's
-				# context
-				elsif (Thread.current == @owner)
-					read_sync_mutex.unlock
-
-					next
-				end
-
-				# Unlocked!
-				unlocked = true
-
-				# Decrement the active reader count
-				@readers -= 1
-			end
-		ensure
-			read_sync_mutex.unlock
-		end
-	end
-
-	#
-	# Acquire the exclusive write lock.
-	#
-	def lock_write
-		write_sync_mutex.lock
-
-		begin
-			@writer = true
-
-			exclusive_mutex.lock
-
-			@owner  = Thread.current
-		ensure
-			write_sync_mutex.unlock
-		end
-	end
-
-	#
-	# Release the exclusive write lock.
-	#
-	def unlock_write
-		# If the caller is not the owner of the write lock, then someone is
-		# doing something broken, let's let them know.
-		if (Thread.current != @owner)
-			raise RuntimeError, "Non-owner calling thread attempted to release write lock", caller
-		end
-
-		# Otherwise, release the exclusive write lock
-		@writer = false
-
-		exclusive_mutex.unlock
-	end
-
-	#
-	# Synchronize a block for read access.
-	#
-	def synchronize_read
-		lock_read
-		begin
-			yield
-		ensure
-			unlock_read
-		end
-	end
-
-	#
-	# Synchronize a block for write access.
-	#
-	def synchronize_write
-		lock_write
-		begin
-			yield
-		ensure
-			unlock_write
-		end
-	end
+  #
+  # Initializes a reader/writer lock instance.
+  #
+  def initialize
+    @read_sync_mutex  = Mutex.new
+    @write_sync_mutex = Mutex.new
+    @exclusive_mutex  = Mutex.new
+    @readers          = 0
+    @writer           = false
+  end
+
+  #
+  # Acquires the read lock for the calling thread.
+  #
+  def lock_read
+    read_sync_mutex.lock
+
+    begin
+      # If there are a non-zero number of readers and a
+      # writer is waiting to acquire the exclusive lock,
+      # free up the sync mutex temporarily and lock/unlock
+      # the exclusive lock.  This is to give the writer
+      # thread a chance to acquire the lock and prevents
+      # it from being constantly starved.
+      if ((@readers > 0) and
+          (@writer))
+        read_sync_mutex.unlock
+        exclusive_mutex.lock
+        exclusive_mutex.unlock
+        read_sync_mutex.lock
+      end
+
+      # Increment the active reader count
+      @readers += 1
+
+      # If we now have just one reader, acquire the exclusive
+      # lock.  Track the thread owner so that we release the
+      # lock from within the same thread context later on.
+      if (@readers == 1)
+        exclusive_mutex.lock
+
+        @owner = Thread.current
+      end
+    ensure
+      read_sync_mutex.unlock
+    end
+  end
+
+  #
+  # Releases the read lock for the calling thread.
+  #
+  def unlock_read
+    read_sync_mutex.lock
+
+    begin
+      unlocked = false
+
+      # Keep looping until we've lost this thread's reader
+      # lock
+      while (!unlocked)
+        # If there are no more readers left after this one
+        if (@readers - 1 == 0)
+          # If the calling thread is the owner of the exclusive
+          # reader lock, then let's release it
+          if (Thread.current == @owner)
+            @owner = nil
+
+            exclusive_mutex.unlock
+          end
+        # If there is more than one reader left and this thread is
+        # the owner of the exclusive lock, then keep looping so that
+        # we can eventually unlock the exclusive mutex in this thread's
+        # context
+        elsif (Thread.current == @owner)
+          read_sync_mutex.unlock
+
+          next
+        end
+
+        # Unlocked!
+        unlocked = true
+
+        # Decrement the active reader count
+        @readers -= 1
+      end
+    ensure
+      read_sync_mutex.unlock
+    end
+  end
+
+  #
+  # Acquire the exclusive write lock.
+  #
+  def lock_write
+    write_sync_mutex.lock
+
+    begin
+      @writer = true
+
+      exclusive_mutex.lock
+
+      @owner  = Thread.current
+    ensure
+      write_sync_mutex.unlock
+    end
+  end
+
+  #
+  # Release the exclusive write lock.
+  #
+  def unlock_write
+    # If the caller is not the owner of the write lock, then someone is
+    # doing something broken, let's let them know.
+    if (Thread.current != @owner)
+      raise RuntimeError, "Non-owner calling thread attempted to release write lock", caller
+    end
+
+    # Otherwise, release the exclusive write lock
+    @writer = false
+
+    exclusive_mutex.unlock
+  end
+
+  #
+  # Synchronize a block for read access.
+  #
+  def synchronize_read
+    lock_read
+    begin
+      yield
+    ensure
+      unlock_read
+    end
+  end
+
+  #
+  # Synchronize a block for write access.
+  #
+  def synchronize_write
+    lock_write
+    begin
+      yield
+    ensure
+      unlock_write
+    end
+  end
 
 protected
 
-	attr_accessor :read_sync_mutex # :nodoc:
-	attr_accessor :write_sync_mutex # :nodoc:
-	attr_accessor :exclusive_mutex # :nodoc:
+  attr_accessor :read_sync_mutex # :nodoc:
+  attr_accessor :write_sync_mutex # :nodoc:
+  attr_accessor :exclusive_mutex # :nodoc:
 
 end