libsl 0.0.2

data/lib/types.rb

@@ -0,0 +1,490 @@
+
+module LibSL
+	class LLPacketNumber
+		def self.decode(data)
+			data = data.unpack('C1a*')
+			num = data.shift()
+			unless num < 0xff then
+				data = data[0].unpack('C1a*')
+				num = (num << 8) + data.shift()
+			end
+			unless num < 0xffff then
+				data = data[0].unpack('C2a*')
+				num = (num << 16) + (data.shift() << 8) + data.shift()
+			end
+			if [*data].length > 0 then
+				data = data[0]
+			else
+				data = nil
+			end
+			return self.new(num), data
+		end
+
+		def encode()
+			case @frequency
+			when :high then data = [@number].pack('C')
+			when :medium then data = [@number].pack('n')
+			else data = [@number].pack('N')
+			end
+			return data
+		end
+
+		attr_accessor :number, :frequency
+		def initialize(number)
+			@number = number
+			if @number < 0xff then
+				@frequency = :high
+			elsif @number < 0xffff then
+				@frequency = :medium
+			elsif @number < 0xfffffffa then
+				@frequency = :low
+			else
+				@frequency = :fixed
+			end
+		end
+	end
+
+	class LLSequenceNumber
+		def self.decode(data)
+			data = data.unpack('N1a*')
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@number].pack('N')
+		end
+
+		attr_accessor :number
+		def initialize(num)
+			@number = num
+		end
+
+		def inc()
+			@number += 1
+			@number
+		end
+	end
+
+	class LLNull
+		def self.decode(data)
+			return self.new, data
+		end
+
+		def encode()
+			""
+		end
+
+		def initialize(val)
+		end
+	end
+
+	class LLFixed
+		def self.decode(data, len)
+			data = data.unpack("a#{len}a*")
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			@data
+		end
+
+		attr_accessor :data
+		def initialize(data)
+			@data = data
+		end
+	end
+
+	class LLVariable1
+		def self.decode(data)
+			data = data.unpack('C1a*')
+			data = data[1].unpack("a#{data[0]}a*")
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@data.length, @data].pack('C1a*')
+		end
+
+		attr_accessor :data
+		def initialize(data)
+			@data = data
+		end
+	end
+
+	class LLVariable2 < LLVariable1
+		def self.decode(data)
+			data = data.unpack('n1a*')
+			data = data[1].unpack("a#{data[0]}a*")
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@data.length, @data].pack('n1a*')
+		end
+	end
+
+	class LLNumber
+		def self.decode(data, pattern, klass)
+			data = data.unpack(pattern)
+			return klass.new(data[0]), data[1]
+		end
+
+		def self.endianness()
+			little = "78563412"
+			big = "12345678"
+			case "%8x" % ([0x12345678].pack('l').unpack('N')[0])
+			when little then :little
+			when big then :big
+			else :other
+			end
+		end
+
+		def encode(pattern)
+			[@value].pack(pattern)
+		end
+
+		attr_accessor :value
+		def initialize(value)
+			@value = value
+		end
+	end
+
+	class LLU8 < LLNumber
+		def self.decode(data)
+			LLNumber.decode(data, 'C1a*', LLU8)
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < 0 or @value > 0xff
+			super('C')
+		end
+	end
+
+	class LLU16 < LLNumber
+		def self.decode(data)
+			LLNumber.decode(data, 'v1a*', LLU16)
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < 0 or @value > 0xffff
+			super('v1')
+		end
+	end
+
+	class LLU32 < LLNumber
+		def self.decode(data)
+			LLNumber.decode(data, 'V1a*', LLU32)
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < 0 or @value > 0xffffffff
+			super('V1')
+		end
+	end
+
+	class LLU64 < LLNumber
+		def self.decode(data)
+			u64, data = LLNumber.decode(data, 'Q1a*', LLU64)
+			if self.endianness == :big
+				# Convert to little endian
+				u64.value = u64.value >> 56 |
+					(u64.value & 0xff000000000000) >> 40 |
+					(u64.value & 0xff0000000000) >> 24 |
+					(u64.value & 0xff00000000) >> 8 |
+					(u64.value & 0xff000000) << 8 |
+					(u64.value & 0xff0000) << 24 |
+					(u64.value & 0xff00) << 40 |
+					(u64.value & 0xff) << 56
+			end
+			return u64, data
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < 0 or @value > 0xffffffffffffffff
+			ms = @value >> 32
+			ls = @value - (ms << 32)
+			[ls, ms].pack('V2')
+		end
+	end
+
+	class LLS8 < LLNumber
+		def self.decode(data)
+			LLNumber.decode(data, 'c1a*', LLS8)
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < -0x80 or @value > 0x7f
+			super('c1')
+		end
+	end
+
+	class LLS16 < LLNumber
+		def self.decode(data)
+			s16, data = LLNumber.decode(data, 's1a*', LLS16)
+			if self.endianness == :big
+				# Convert to little endian
+				ms = s16.value >> 8
+				ls = s16 - (ms << 8)
+				s16.value = (ls << 8) + ms
+			end
+			return s16, data
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < -0x8000 or @value > 0x7fff
+			data = super('s')
+			if LLNumber::endianness == :big
+				data = data.unpack('C2').reverse.pack('C2')
+			end
+			return data
+		end
+	end
+
+	class LLS32 < LLNumber
+		def self.decode(data)
+			s32, data = LLNumber.decode(data, 'l1a*', LLS32)
+			if self.endianness == :big
+				# Convert to little endian
+				s32.value = s32.value >> 24 |
+					(s32.value & 0xff0000) >> 8 |
+					(s32.value & 0xff00) << 8 |
+					(s32.value & 0xff) << 24
+			end
+			return s32, data
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < -0x80000000 or @value > 0x7fffffff
+			data = super('l')
+			if LLNumber::endianness == :big
+				data = data.unpack('C4').reverse.pack('C4')
+			end
+			return data
+		end
+	end
+
+	class LLS64 < LLNumber
+		def self.decode(data)
+			s64, data = LLNumber.decode(data, 'q1a*', LLS64)
+			if self.endianness == :big
+				# Convert to little endian
+				s64.value = s64.value >> 56 |
+					(s64.value & 0xff000000000000) >> 40 |
+					(s64.value & 0xff0000000000) >> 24 |
+					(s64.value & 0xff00000000) >> 8 |
+					(s64.value & 0xff000000) << 8 |
+					(s64.value & 0xff0000) << 24 |
+					(s64.value & 0xff00) << 40 |
+					(s64.value & 0xff) << 56
+			end
+			return s64, data
+		end
+
+		def encode()
+			raise ArgumentError, "Value out of range: #{@value}" if @value < -0x8000000000000000 or @value > 0x7fffffffffffffff
+			data = super('q')
+			if LLNumber::endianness == :big
+				data = data.unpack('C8').reverse.pack('C8')
+			end
+			return data
+		end
+	end
+
+	class LLF32 < LLNumber
+		def self.decode(data)
+			data = data.unpack('ea*')
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@value].pack('e')
+		end
+	end
+
+	class LLF64 < LLNumber
+		def self.decode(data)
+			data = data.unpack('Ea*')
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@value].pack('E')
+		end
+	end
+
+	class LLVector3
+		def self.decode(data)
+			data = data.unpack('e3a*')
+			return self.new(data[0], data[1], data[2]), data[3]
+		end
+
+		def encode()
+			[@x, @y, @z].pack('e3')
+		end
+
+		attr_accessor :x, :y, :z
+		def initialize(x, y, z)
+			@x, @y, @z = x, y, z
+		end
+	end
+
+	class LLVector3d < LLVector3
+		def self.decode(data)
+			data = data.unpack('E3a*')
+			return self.new(data[0], data[1], data[2]), data[3]
+		end
+
+		def encode()
+			[@x, @y, @z].pack('E3')
+		end
+	end
+
+	class LLVector4
+		def self.decode(data)
+			data = data.unpack('e4a*')
+			return self.new(data[0], data[1], data[2], data[3]), data[4]
+		end
+
+		def encode()
+			[@a, @b, @c, @d].pack('e4')
+		end
+
+		attr_accessor :a, :b, :c, :d
+		def initialize(a, b, c, d)
+			@a, @b, @c, @d = a, b, c, d
+		end
+	end
+
+	class LLQuaternion
+		def self.decode(data)
+			data = data.unpack 'e3a*'
+			return self.new(data[0], data[1], data[2]), data[3]
+		end
+
+		def encode()
+			[@x, @y, @z].pack 'e3'
+		end
+
+		attr_accessor :x, :y, :z, :w
+		def initialize(x, y, z, w=nil)
+			@x, @y, @z = x, y, z
+			if w.nil? then
+				sum = 1 - @x**2 - @y**2 - @z**2
+				@w = if sum > 0 then Math.sqrt sum else 0 end
+			else
+				@w = w
+			end
+		end
+	end
+
+	class LLUUID
+		attr_reader :uuid
+
+		def self.decode(data)
+			data = data.unpack 'a16a*'
+			return self.new(data[0]), data[1]
+		end
+
+		def self.null()
+			return self.new("00000000-0000-0000-0000-000000000000")
+		end
+
+		def encode()
+			to_bytes
+		end
+
+		def initialize(uuid=nil)
+			if uuid.nil?
+				# Generate a random UUID
+				uuid = [
+					rand(0x100000000),
+					rand(0x100000000),
+					rand(0x100000000),
+					rand(0x100000000),
+				].pack "N4"
+				uuid[6] &= 0b00001111
+				uuid[6] |= 48
+				uuid[8] &= 0b00111111
+				uuid[8] |= 0b10000000
+			end
+
+			raise "Invalid uuid format" unless uuid.is_a? String
+			@uuid = if uuid.length == 36 and uuid.count("-") == 4 then
+					# String representation (Guid)
+					uuid.delete("-").scan(/../).map{|s| s.to_i(16)}
+				else
+					# Unpack from binary string
+					uuid.unpack('C16')
+				end
+		end
+
+		def to_s()
+			sprintf('%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x', *(@uuid)).upcase
+		end
+
+		def to_bytes()
+			@uuid.pack('C16')
+		end
+	end
+
+	class LLBool
+		def self.decode(data)
+			data = data.unpack('C1a*')
+			return self.new(data[0] == 1), data[1]
+		end
+
+		def encode()
+			[@value ? 1 : 0].pack('C')
+		end
+
+		def eql?(val)
+			@value == val
+		end
+
+		def ==(val)
+			@value == val
+		end
+
+		attr_accessor :value
+		def initialize(value)
+			@value = value
+		end
+	end
+
+	class LLIPAddress
+		def self.decode(data)
+			data = data.unpack('C4a*')
+			return self.new(sprintf("%d.%d.%d.%d", data[0], data[1], data[2], data[3])), data[4]
+		end
+
+		def encode()
+			@ip.scan(/[0-9]+/).map {|s| s.to_i}.pack('C4')
+		end
+
+		attr_accessor :ip
+		def initialize(ip)
+			raise ArgumentError, "ip must be a string (e.g. 1.2.3.4)" unless ip.is_a? String
+			@ip = ip
+		end
+
+		def to_s()
+			@ip.to_s
+		end
+	end
+
+	class LLIPPort
+		def self.decode(data)
+			data = data.unpack('n1a*')
+			return self.new(data[0]), data[1]
+		end
+
+		def encode()
+			[@port].pack('n1')
+		end
+
+		attr_accessor :port
+		def initialize(port)
+			@port = port
+		end
+	end
+end

data/libsl.gemspec

@@ -0,0 +1,30 @@
+
+Gem::Specification.new do |s|
+	s.name              = "libsl"
+	s.version           = File.read('VERSION')
+	s.platform          = Gem::Platform::RUBY
+	s.authors           = ["Lukas Botsch"]
+	s.email             = ["lukas.botsch@gmail.com"]
+	s.homepage          = "http://github.com/lbotsch/libsl-ruby"
+	s.summary           = "Library for building SecondLife client applications"
+	s.description       = "Build SecondLife clients using a simple DSL"
+	s.rubyforge_project = s.name
+
+	s.required_rubygems_version = ">= 1.3.6"
+
+	# If you have runtime dependencies, add them here
+	s.add_runtime_dependency "eventmachine", ">= 0.12.10"
+
+	# If you have development dependencies, add them here
+	# s.add_development_dependency "another", "= 0.9"
+
+	# The list of files to be contained in the gem
+	s.files         = `git ls-files`.split("\n").delete_if{|f| f =~ /^(example|scripts|\.)\//}
+	# s.executables   = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+	# s.extensions    = `git ls-files ext/extconf.rb`.split("\n")
+
+	s.require_path = 'lib'
+
+	# For C extensions
+	# s.extensions = "ext/extconf.rb"
+end

data/test/tc_packet.rb

@@ -0,0 +1,99 @@
+require 'test/unit'
+%w{types packet}.each{|f|
+	require File.join File.dirname(__FILE__), "..", "lib", f
+}
+
+module LibSL
+	class StubPacket < Packet
+		def self.packet_id()
+			1
+		end
+
+		def build_structure()
+			@blocks = [
+				[:SomeBlock, Block.new([
+					[:Data, :LLU8]
+				])],
+				[:FixedCollection, FixedBlockCollection.new(2, [
+					[:Data, :LLU8]
+				])],
+				[:VariableCollection, VariableBlockCollection.new([
+					[:Data, :LLU8]
+				])]
+			]
+		end
+	end
+
+	MESSAGE_MAP = {1 => StubPacket}
+
+	class TestPacket < Test::Unit::TestCase
+		def test_decode()
+			packet = Packet.decode(
+				"\x40" +				# Flags
+				"\x00\x00\x00\x01" +	# Sequence Number
+				"\x00" +				# Extra header length
+				"\x01" +				# Message Number
+				"\xff" +				# SomeBlock
+				"\xff\xff" +			# FixedCollection
+				"\x02\xff\xff")			# VariableCollection
+			assert_equal(StubPacket, packet.class)
+			assert_equal(true, packet.reliable_flag)
+			assert_equal(0xff, packet.SomeBlock.Data.value)
+			assert_equal(0xff, packet.FixedCollection[0].Data.value)
+			assert_equal(0xff, packet.FixedCollection[1].Data.value)
+			assert_equal(0xff, packet.VariableCollection[0].Data.value)
+			assert_equal(0xff, packet.VariableCollection[1].Data.value)
+		end
+		
+		def test_zero_decode()
+			packet = Packet.decode(
+				"\x80" +				# Flags zero_coded
+				"\x00\x00\x00\x01" +	# Sequence Number
+				"\x00" +				# Extra header length
+				"\x01" +				# Message Number
+				"\x00\x01" +			# SomeBlock
+				"\x00\x02" +			# FixedCollection
+				"\x02\x00\x02")			# VariableCollection
+			assert_equal(StubPacket, packet.class)
+			assert_equal(true, packet.zero_coded_flag)
+			assert_equal(0x00, packet.SomeBlock.Data.value)
+			assert_equal(0x00, packet.FixedCollection[0].Data.value)
+			assert_equal(0x00, packet.FixedCollection[1].Data.value)
+			assert_equal(0x00, packet.VariableCollection[0].Data.value)
+			assert_equal(0x00, packet.VariableCollection[1].Data.value)
+		end
+
+		def test_encode()
+			packet = StubPacket.new
+			packet.reliable_flag = true
+			packet.sequence_number = 1
+			packet.SomeBlock.Data = LLU8.new(0xff)
+			packet.FixedCollection[0].Data = LLU8.new(0xff)
+			packet.FixedCollection[1].Data = LLU8.new(0xff)
+			packet.VariableCollection.add.Data = LLU8.new(0xff)
+			packet.VariableCollection.add.Data = LLU8.new(0xff)
+			
+			data = packet.encode
+			assert_equal("\x40\x00\x00\x00\x01\x00\x01\xff\xff\xff\x02\xff\xff", data)
+		end
+
+		def test_new()
+			packet = StubPacket.new({
+				:SomeBlock => { :Data => LLU8.new(0xff) },
+				:FixedCollection => [
+					{ :Data => LLU8.new(0xff) },
+					{ :Data => LLU8.new(0xff) }
+				],
+				:VariableCollection => [
+					{ :Data => LLU8.new(0xff) },
+					{ :Data => LLU8.new(0xff) }
+				]
+			})
+			assert_equal(0xff, packet.SomeBlock.Data.value)
+			assert_equal(0xff, packet.FixedCollection[0].Data.value)
+			assert_equal(0xff, packet.FixedCollection[1].Data.value)
+			assert_equal(0xff, packet.VariableCollection[0].Data.value)
+			assert_equal(0xff, packet.VariableCollection[1].Data.value)
+		end
+	end
+end