libsl 0.0.2

data/lib/packet.rb

@@ -0,0 +1,279 @@
+
+module LibSL
+	class Packet
+		def self.packet_id()
+			0
+		end
+
+		def self.decode(data)
+			flags, data = LLU8.decode(data)
+			sequence_number, data = LLSequenceNumber.decode(data)
+			extra, data = LLU8.decode(data)
+			if extra.value > 0 then
+				extra, data = LLFixed.decode(data, extra)
+			end
+			data = zero_decode(data) if flags.value & 0x80 == 0x80
+			packet_number, data = LLPacketNumber.decode(data)
+			klass = MESSAGE_MAP[packet_number.number]
+			throw "Unknown message type!" if klass.nil?
+
+			packet = klass.new
+			packet.zero_coded_flag = flags.value & 0x80 == 0x80
+			packet.reliable_flag = flags.value & 0x40 == 0x40
+			packet.resent_flag = flags.value & 0x20 == 0x20
+			packet.acks_flag = flags.value & 0x10 == 0x10
+			packet.sequence_number = sequence_number
+			data = packet.decode_msg(data)
+			if packet.acks_flag && data.length > 0 then
+				# Extract acks
+				ack_count = data[-1]
+				packet.acks = data.unpack('N'+ack_count)
+			end
+			packet
+		end
+
+		def self.zero_decode(data)
+			# Decode 0x00 0xXX to a sequence of 0xXX zeros
+			decoded = []
+			zero = false
+			data.bytes do |byte|
+				if byte == 0x00
+					zero = true
+				elsif zero == true
+					byte.times{ decoded << 0x00 }
+					zero = false
+				else
+					decoded << byte
+				end
+			end
+			decoded.pack('C*')
+		end
+
+		attr_accessor :acks, :zero_coded_flag, :reliable_flag, :resent_flag, :acks_flag,
+			:sequence_number, :resent_count
+
+		# Create a new packet
+		# @param [Hash] blocks (optional) Data blocks
+		# Example:
+		# {
+		# 	:Block1 => { # Block
+		# 		:Var1 => LLU8.new(0xff),
+		# 		:Var2 => LLVariable1.new("abcd")
+		# 	},
+		# 	:Block2 => [ # Block collection
+		# 		{
+		# 			:Var1 => LLFixed.new("block1"),
+		# 			:Var2 => LLS32.new(0x12345678)
+		# 		},
+		# 		{
+		# 			:Var1 => LLFixed.new("block2"),
+		# 			:Var2 => LLS32.new(0x12345678)
+		# 		}
+		# 	]
+		# }
+		def initialize(blocks={})
+			@zero_coded_flag = false
+			@reliable_flag = false
+			@resent_flag = false
+			@acks_flag = false
+			@acks = []
+			@resent_count = 0
+			build_structure
+			blocks.each do |name, block|
+				case block
+				when Array then
+					block.each_index do |i|
+						collection = self.send(name)
+						case collection
+						when VariableBlockCollection then
+							b = collection.add
+						when FixedBlockCollection then
+							b = collection[i]
+						end
+
+						block[i].each do |v|
+							b.send((v[0].to_s + "=").to_sym, v[1])
+						end
+					end
+				when Hash then
+					block.each do |v|
+						self.send(name).send((v[0].to_s + "=").to_sym, v[1])
+					end
+				end
+			end
+		end
+
+		def encode()
+			flags = 0
+			flags |= 0x80 if @zero_coded_flag
+			flags |= 0x40 if @reliable_flag
+			flags |= 0x20 if @resent_flag
+			flags |= 0x10 if @acks_flag
+			
+			data = LLU8.new(flags).encode +
+				LLSequenceNumber.new(@sequence_number).encode +
+				LLU8.new(0).encode
+			pid = LLPacketNumber.new(self.class.packet_id).encode
+			data += pid
+			data += encode_msg
+			# append acks
+			data += ([*@acks] + [@acks.length]).pack("N#{@acks.length}C") if @acks_flag
+			data
+		end
+
+		# Subclasses have to override this method to build the message structure
+		# IMPORTANT: Use arrays to describe the structure, as hashes don't preserve the order
+		# Example:
+		# def build_structure()
+		# 	  @blocks = [
+		# 	  	  [:AgentData, Block.new([
+		# 	  	  	  [:AgentID, :LLUUID],
+		# 	  	  	  [:SessionID, :LLUUID]
+		# 	  	  ])],
+		# 	  	  [:SomeData, FixedBlockCollection.new(4, [
+		# 	  	  	  [:Data, :LLVariable1]
+		# 	  	  ])]
+		# 	  ]
+		# end
+		def build_structure()
+		end
+
+		def decode_msg(data)
+			@blocks.each do |block|
+				data = block[1].decode(data)
+			end
+			data
+		rescue => e
+			puts "[ERROR] #{self.class.name}: #{self.inspect}"
+			raise e
+		end
+
+		def encode_msg()
+			data = ""
+			@blocks.each{ |block| data += block[1].encode }
+			data
+		end
+
+		def method_missing(name, *args)
+			block = @blocks.assoc(name)
+			throw "The method #{name} does not exist in #{self.class.name}" if block.nil?
+			block[1]
+		end
+	end
+
+	class Block
+		def initialize(structure)
+			@structure = structure
+			@data = []
+			@structure.length.times{ @data << nil }
+		end
+
+		def decode(data)
+			@data = []
+			@structure.each do |var|
+				begin
+					args = [data]
+					args << var[2] if var[1] == :LLFixed
+					value, data = LibSL.const_get(var[1]).decode(*args)
+				#rescue => e
+				#	throw e
+				#	throw "Type #{type.to_s} does not exist!"
+				end
+				@data << [var[0], value]
+			end
+			data
+		end
+
+		def encode()
+			throw "Data has to be an array." unless @data.is_a? Array
+			throw "Block is missing data." if @data.length != @structure.length
+			data = ""
+			@data.each{ |var| data += var[1].encode }
+			data
+		end
+
+		def method_missing(name, *args)
+			name = name.to_s
+			if name[-1..-1] == "=" then
+				# Setter
+				var = name[0..-2].to_sym
+				throw "The method #{name} does not exist in #{self.class.name}" if @structure.assoc(var).nil?
+				index = @structure.index{|v| v[0] == var}
+				@data[index] = [var, args[0]]
+			else
+				# Getter
+				var = name.to_sym
+				throw "The method #{name} does not exist in #{self.class.name}" if @structure.assoc(var).nil?
+				@data.assoc(var)[1]
+			end
+		end
+	end
+
+	class FixedBlockCollection
+		attr_reader :blocks
+		def initialize(size, structure)
+			@size = size
+			@blocks = []
+			@size.times{@blocks << Block.new(structure)}
+		end
+
+		def length()
+			@size
+		end
+
+		def [](index)
+			throw "Index out of range: #{index} is not in [0, #{length - 1}]" if index < 0 or index >= length
+			@blocks[index]
+		end
+
+		def each(&block)
+			@blocks.each{|block| yield block}
+		end
+
+		def decode(data)
+			@blocks.each{ |block| data = block.decode(data) }
+			data
+		end
+
+		def encode()
+			data = ""
+			@blocks.each{ |block| data += block.encode }
+			data
+		end
+	end
+
+	class VariableBlockCollection < FixedBlockCollection
+		def initialize(structure)
+			@structure = structure
+			@blocks = []
+		end
+
+		def length()
+			@blocks.length
+		end
+
+		def add()
+			@blocks << Block.new(@structure)
+			@blocks.last
+		end
+
+		def decode(data)
+			size, data = LLU8.decode(data)
+			size.value.times{ data = add.decode(data) }
+			data
+		end
+
+		def encode()
+			data = LLU8.new(length).encode
+			@blocks.each{ |block| data += block.encode }
+			data
+		end
+	end
+end
+
+# Include packet types generated from the specification
+begin
+	require File.join File.dirname(__FILE__), "_packets"
+rescue LoadError => e
+	puts "Packets not found! Please build them."
+end