librex 0.0.17 → 0.0.18

data/lib/rex/socket/tcp_server.rb

@@ -1,66 +0,0 @@
-require 'rex/socket'
-require 'rex/socket/tcp'
-require 'rex/io/stream_server'
-
-###
-#
-# This class provides methods for interacting with a TCP server.  It
-# implements the Rex::IO::StreamServer interface.
-#
-###
-module  Rex::Socket::TcpServer
-
-	include Rex::Socket
-	include Rex::IO::StreamServer
-
-	##
-	#
-	# Factory
-	#
-	##
-
-	#
-	# Creates the server using the supplied hash.
-	#
-	def self.create(hash = {})
-		hash['Proto'] = 'tcp'
-		hash['Server'] = true
-		self.create_param(Rex::Socket::Parameters.from_hash(hash))
-	end
-
-	#
-	# Wrapper around the base class' creation method that automatically sets
-	# the parameter's protocol to TCP and sets the server flag to true.
-	#
-	def self.create_param(param)
-		param.proto  = 'tcp'
-		param.server = true
-		Rex::Socket.create_param(param)
-	end
-
-	#
-	# Accepts a child connection.
-	#
-	def accept(opts = {})
-		t = super()
-
-		# jRuby compatibility
-		if t.respond_to?('[]')
-			t = t[0]
-		end
-
-		if (t)
-			t.extend(Rex::Socket::Tcp)
-			t.context = self.context
-
-			pn = t.getpeername
-
-			t.peerhost = pn[1]
-			t.peerport = pn[2]
-		end
-
-		t
-	end
-
-end
-

data/lib/rex/socket/tcp_server.rb.ut.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/socket/tcp_server'
-
-class Rex::Socket::TcpServer::UnitTest < Test::Unit::TestCase
-
-	def test_tcp_server
-		serv_port = 65433
-		serv = Rex::Socket.create_tcp_server(
-			'LocalPort' => serv_port)
-		ccli = nil
-
-		begin
-			assert_kind_of(Rex::Socket::TcpServer, serv, "valid TcpServer")
-			assert_kind_of(Rex::IO::StreamServer, serv, "valid StreamServer")
-
-			# Connect to the server
-			assert_nothing_raised {
-				ccli = Rex::Socket.create_tcp(
-					'PeerHost' => '127.0.0.1',
-					'PeerPort' => serv_port)
-			}
-			assert_kind_of(Rex::Socket::Tcp, ccli, "valid client client Tcp")
-
-			# Accept the client connection
-			scli = serv.accept
-			assert_kind_of(Rex::Socket::Tcp, scli, "valid server client Tcp")
-
-			assert_equal(2, scli.put("Yo"), "scli: put Yo")
-			assert_equal("Yo", ccli.get(), "ccli: get Yo")
-			assert(scli.methods.include?('<<'))
-			assert(scli.methods.include?('>>'))
-			assert(scli.methods.include?('has_read_data?'))
-			
-		ensure
-			ccli.close if (ccli)
-			serv.close
-		end
-	end
-
-end

data/lib/rex/socket/udp.rb

@@ -1,164 +0,0 @@
-require 'rex/socket'
-
-###
-#
-# This class provides methods for interacting with a UDP socket.
-#
-###
-module Rex::Socket::Udp
-
-	include Rex::Socket
-
-	##
-	#
-	# Factory
-	#
-	##
-
-	#
-	# Creates the client using the supplied hash.
-	#
-	def self.create(hash = {})
-		hash['Proto'] = 'udp'
-		# If we have are to bind to a LocalHost we must be a Server to avail of pivoting.
-		# Rex::Socket::Parameters will subsequently turn off the sever flag after the correct
-		# comm has been chosen.
-		if( hash['LocalHost'] )
-			hash['Server'] = true
-		end
-		self.create_param(Rex::Socket::Parameters.from_hash(hash))
-	end
-
-	#
-	# Wrapper around the base socket class' creation method that automatically
-	# sets the parameter's protocol to UDP.
-	#
-	def self.create_param(param)
-		param.proto = 'udp'
-		Rex::Socket.create_param(param)
-	end
-
-	##
-	#
-	# UDP connected state methods
-	#
-	##
-
-	#
-	# Write the supplied datagram to the connected UDP socket.
-	#
-	def write(gram)
-		begin
-			return syswrite(gram)
-		rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
-			return nil
-		end
-	end
-
-	alias put write
-
-	#
-	# Read a datagram from the UDP socket.
-	#
-	def read(length = 65535)
-		if length < 0
-			length = 65535
-		end
-		return sysread(length)
-	end
-
-	#
-	# Read a datagram from the UDP socket with a timeout
-	#
-	def timed_read(length = 65535, timeout=def_read_timeout)
-		begin
-			if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
-			    (rv[0]) and (rv[0][0] == fd)
-			   )
-					return read(length)
-			else
-				return ''
-			end
-		rescue Exception
-			return ''
-		end
-	end
-
-	#alias send write
-	#alias recv read
-
-	##
-	#
-	# UDP non-connected state methods
-	#
-	##
-
-	#
-	# Sends a datagram to the supplied host:port with optional flags.
-	#
-	def sendto(gram, peerhost, peerport, flags = 0)
-
-		# Catch unconnected IPv6 sockets talking to IPv4 addresses
-		peer = Rex::Socket.resolv_nbo(peerhost)
-		if (peer.length == 4 and self.ipv == 6)
-			peerhost = Rex::Socket.getaddress(peerhost)
-			if peerhost[0,7].downcase != '::ffff:'
-				peerhost = '::ffff:' + peerhost
-			end
-		end
-
-		begin
-			send(gram, flags, Rex::Socket.to_sockaddr(peerhost, peerport))
-		rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
-			return nil
-		end
-
-	end
-
-	#
-	# Receives a datagram and returns the data and host:port of the requestor
-	# as [ data, host, port ].
-	#
-	def recvfrom(length = 65535, timeout=def_read_timeout)
-
-		begin
-			if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
-			    (rv[0]) and (rv[0][0] == fd)
-			   )
-					data, saddr    = recvfrom_nonblock(length)
-					af, host, port = Rex::Socket.from_sockaddr(saddr)
-
-					return [ data, host, port ]
-			else
-				return [ '', nil, nil ]
-			end
-		rescue ::Timeout::Error
-			return [ '', nil, nil ]
-		rescue ::Interrupt
-			raise $!
-		rescue ::Exception
-			return [ '', nil, nil ]
-		end
-	end
-
-	#
-	# Calls recvfrom and only returns the data
-	#
-	def get(timeout=nil)
-		data, saddr, sport = recvfrom(65535, timeout)
-		return data
-	end
-
-	#
-	# The default number of seconds to wait for a read operation to timeout.
-	#
-	def def_read_timeout
-		10
-	end
-
-	def type?
-		return 'udp'
-	end
-
-end
-

data/lib/rex/socket/udp.rb.ut.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/socket/udp'
-
-class Rex::Socket::Udp::UnitTest < Test::Unit::TestCase
-
-	def test_udp
-		serv_port = 55432
-		serv = Rex::Socket::Udp.create(
-			'LocalHost' => '127.0.0.1',
-			'LocalPort' => serv_port)
-
-		begin
-			assert_kind_of(Rex::Socket::Udp, serv, "valid Udp server instance")
-
-			# Test connected socket
-			concli = Rex::Socket::Udp.create(
-				'PeerHost' => '127.0.0.1',
-				'PeerPort' => serv_port)
-
-			assert_equal('127.0.0.1', concli.peerhost, "matching peerhost")
-			assert_equal(serv_port, concli.peerport, "matching peerport")
-			assert_equal(2, concli.write('yo'), "write succeeded")
-
-			data, host, port = serv.recvfrom
-
-			assert_equal('yo', data, "read data match")
-			assert_equal('127.0.0.1', host, "matching client host")
-
-			# Test non-connected socket
-			concli = Rex::Socket::Udp.create
-
-			assert_equal(3, concli.sendto('bob', '127.0.0.1', serv_port), "sendto")
-			data, host, port = serv.recvfrom
-			assert_equal('bob', data, "read data match")
-		ensure
-			serv.close
-		end
-	end
-
-end

data/lib/rex/struct2.rb

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-# just a shim to load all of the Struct2 libraries
-
-require 'rex/struct2/c_struct_template'

data/lib/rex/struct2/c_struct.rb

@@ -1,181 +0,0 @@
-#!/usr/bin/env ruby
-
-# Rex::Struct2
-module Rex
-module Struct2
-
-require 'rex/struct2/s_struct'
-
-class CStruct_Values
-
-	def initialize(obj)
-		@obj = obj
-	end
-
-	def [](*args)
-		o = @obj[*args]
-		return if !o
-		return o.value
-	end
-
-	def []=(*args)
-		o = @obj[*args[0 .. -2]]
-		return if !o
-		o.value = args[-1]
-	end
-
-	# this one is for HD, the whiniest girl around...
-	# allow for like v.field = whatever
-	def method_missing(sym, *args)
-		if sym.to_s[-1] == "="[0]
-			return self[sym.to_s[0 .. -2]] = args[0]
-		else
-			return self[sym.to_s]
-		end
-	end
-end
-
-class CStruct < SStruct
-
-	require 'rex/struct2/element'
-	require 'rex/struct2/generic'
-	require 'rex/struct2/s_string'
-	require 'rex/struct2/c_struct_template'
-	require 'rex/struct2/restraint'
-
-	include Rex::Struct2::Element
-
-	attr_reader  :v
-
-	@@dt_table = {
-	  'int8'      => proc { |*a| Rex::Struct2::Generic.new('C',  true, *a) },
-	  'uint8'     => proc { |*a| Rex::Struct2::Generic.new('C', false, *a) },
-	  'int16v'    => proc { |*a| Rex::Struct2::Generic.new('v',  true, *a) },
-	  'uint16v'   => proc { |*a| Rex::Struct2::Generic.new('v', false, *a) },
-	  'int32v'    => proc { |*a| Rex::Struct2::Generic.new('V',  true, *a) },
-	  'uint32v'   => proc { |*a| Rex::Struct2::Generic.new('V', false, *a) },
-	  'int64v'    => proc { |*a| Rex::Struct2::Generic.new('q',  true, *a) },
-	  'uint64v'   => proc { |*a| Rex::Struct2::Generic.new('Q', false, *a) },
-	  'int16n'    => proc { |*a| Rex::Struct2::Generic.new('n',  true, *a) },
-	  'uint16n'   => proc { |*a| Rex::Struct2::Generic.new('n', false, *a) },
-	  'int32n'    => proc { |*a| Rex::Struct2::Generic.new('N',  true, *a) },
-	  'uint32n'   => proc { |*a| Rex::Struct2::Generic.new('N', false, *a) },
-	  'string'    => proc { |*a| Rex::Struct2::SString.new(*a) },
-	  'sstruct'   => proc { |*a| Rex::Struct2::SStruct.new(*a) },
-	  'object'    => proc { |o| o },
-	  'template'  => proc { |o| o.make_struct },
-	}
-
-	# CStruct.typedef(name, factory, ... )
-	def CStruct.typedef(*args)
-		while args.length >= 2
-			name    = args.shift
-			factory = args.shift
-			@@dt_table[name] = factory
-		end
-	end
-
-	def initialize(*dts)
-		super()
-		@name_table = [ ]
-		@v = Rex::Struct2::CStruct_Values.new(self)
-
-		return self.add_from_dt(*dts)
-	end
-
-	def add_from_dt(*dts)
-		dts.each { | dt |
-			return if !dt.kind_of?(Array) || dt.length < 2
-
-			type = dt[0]
-			name = dt[1]
-
-			factory = @@dt_table[type]
-
-			return if !factory
-
-			# call with the arguments passed in
-			obj = factory.call(*(dt[2 .. -1]))
-
-			self.add_object(name, obj)
-		}
-
-		return dts.length
-	end
-
-	def add_object(*objs)
-		while objs.length >= 2
-			@name_table << objs.shift
-			self        << objs.shift
-		end
-	end
-	# apply_restraint( name, restraint, name2, restraint2 ... )
-	def apply_restraint(*ress)
-		while ress.length >= 2
-			name = ress.shift
-			res  = ress.shift
-			self[name].restraint = res
-
-			# update the restrainted object, so it will update the value
-			# of the restrainter, with the initial size.  If you don't
-			# want this behavior, um, you'll have to be careful with what
-			# you supply as default values...
-			self[name].update_restraint
-		end
-		return self
-	end
-
-	# create_restraints( [ name, stuff_to_restraint_constructor ] ... )
-	def create_restraints(*ress)
-		ress.each { |r|
-			# make a copy before we modify...
-			r = r.dup
-			# resolve names into objects
-			r[1] = self[r[1]] if r[1]
-			r[2] = self[r[2]] if r[2]
-
-			# build and apply the restraint
-			self.apply_restraint(r[0], Rex::Struct2::Restraint.new(*r[1 .. -1]))
-		}
-
-		return self
-	end
-
-	# ya ya, I know, these are weird.  I'm not sure why I even bothered
-	# to inherit from array...
-	def [](index, *other)
-		if index.kind_of?(String)
-			i = @name_table.index(index)
-			return if !i
-			return super(i)
-		else
-			return super(index, *other)
-		end
-	end
-
-	def []=(index, *other)
-		if index.kind_of?(String)
-			i = @name_table.index(index)
-			return if !i
-			return super(i, *other)
-		else
-			return super(index, *other)
-		end
-	end
-	
-	# Produce a list of field names
-	def keys
-		@name_table
-	end
-	
-	# Iterate through all fields and values
-	def each_pair(&block)
-		@name_table.each do |k|
-			block.call(k, self.v[k])
-		end
-	end
-end
-
-# end Rex::Struct2
-end
-end