libsl 0.0.2

data/lib/agent.rb

@@ -0,0 +1,119 @@
+
+
+module LibSL
+	class AgentManager
+		attr_accessor :client
+		attr_reader :position, :look_at, :region_handle, :region_name
+
+		# New AgentManager
+		# @param [Client] client The client
+		def initialize(client)
+			@client = client
+			@position = LLVector3.new(0, 0, 0)
+			@look_at = LLVector3.new(0, 0, 0)
+			@region_handle = LLU64.new(0)
+			@region_name = ""
+			init_handlers
+		end
+
+
+		# Complete a transfer to a sim (e.g. after login or teleport)
+		# @param [Simulator] sim The sim you have been transfered to
+		def move_to_sim(simulator)
+
+		#	EventManager.register_handler(EventHandler.new(Proc.new do |type|
+		#		EventMachine::add_periodic_timer(2) do
+		#			packet = AgentUpdatePacket.new({
+		#				:AgentData => {
+		#					:AgentID => @client.network_manager.agent_id,
+		#					:SessionID => @client.network_manager.session_id,
+		#					:BodyRotation => LLQuaternion.new(1, 1, 1),
+		#					:HeadRotation => LLQuaternion.new(1, 1, 1),
+		#					:State => LLU8.new(0),
+		#					:CameraCenter => @position,
+		#					:CameraAtAxis => LLVector3.new(),
+		#					:CameraLeftAxis => LLVector3.new(),
+		#					:CameraUpAxis => LLVector3.new(),
+		#					:Far => LLF32.new(64),
+		#					:ControlFlags => LLU32.new(0),
+		#					:Flags => LLU8.new(0)
+		#				}
+		#			})
+		#			@client.network_manager.send_packet packet, true
+		#		end
+		#	end, :movement_complete))
+
+			packet = CompleteAgentMovementPacket.new({
+				:AgentData => {
+					:AgentID => @client.network_manager.agent_id,
+					:SessionID => @client.network_manager.session_id,
+					:CircuitCode => @client.network_manager.circuit_code
+				}
+			})
+			simulator.send_packet(packet)
+		end
+
+		# Send a chat message to the simulator
+		# @param [Symbol] type The chat type (:normal, :whisper or :shout)
+		# @param [Integer] channel (optional) should be 0 (public)
+		# or >0 (for scripts listening on that channel)
+		def chat(message, type=:normal, channel=0)
+			type = case type
+				   when :whisper then 0
+				   when :shout then 2
+				   else 1
+				   end
+			throw "Channel has to be >=0, #{channel} given!" if channel < 0
+			packet = ChatFromViewerPacket.new({
+				:AgentData => {
+					:AgentID => @client.network_manager.agent_id,
+					:SessionID => @client.network_manager.session_id
+				},
+				:ChatData => {
+					:Message => message,
+					:Type => type,
+					:Channel => channel
+				}
+			})
+			@client.network_manager.send_packet packet
+		end
+
+		# Send an instant message to another agent
+		# @param [String] message the message to send
+		# @param [LLUUID] to The recepients id
+		def im(message, to)
+		end
+
+		# Send Linden$ to another agent
+		# @param [Integer] amount The amount of L$ to send
+		# @param [LLUUID] to The recepient
+		def send_money(amount, to)
+		end
+
+		private
+
+		def init_handlers()
+			handler = EventHandler.new(Proc.new do |type, packet, sim|
+				@position = packet.Data.Position
+				@look_at = packet.Data.LookAt
+				@region_handle = packet.Data.RegionHandle
+				sim.send_packet(RegionHandshakeReplyPacket.new({
+					:AgentData => {
+						:AgentID => @client.network_manager.agent_id,
+						:SessionID => @client.network_manager.session_id
+					},
+					:RegionInfo => {
+						:Flags => LLU32.new(0)
+					}
+				}))
+				EventManager.fire_event :movement_complete, sim
+			end, :AgentMovementCompletePacket_Received)
+			EventManager.register_handler(handler)
+
+			handler = EventHandler.new(Proc.new do |type, packet, sim|
+				@region_name = packet.RegionInfo.SimName.data
+			end, :RegionHandshakePacket_Received)
+			EventManager.register_handler(handler)
+		end
+	end
+end

data/lib/client.rb

@@ -0,0 +1,57 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+%w{ types packet events agent network dsl }.each { |file|
+	require File.expand_path File.join(File.dirname(__FILE__), file)
+}
+
+require 'rubygems'
+require 'eventmachine'
+
+module LibSL
+	class Client
+		attr_accessor :event_manager, :network_manager, :agent_manager
+
+		def initialize()
+			@is_setup = false
+			#@event_manager = EventManager.new self
+			@network_manager = NetworkManager.new self
+			@agent_manager = AgentManager.new self
+		end
+
+		def login()
+			@network_manager.login @firstname, @lastname, @password, @start_location, @grid
+		end
+
+		def setup(firstname, lastname, password, start='last', grid=:agni)
+			@firstname = firstname
+			@lastname = lastname
+			@password = password
+			@start_location = start
+			@grid = grid
+			@is_setup = true
+		end
+
+		def setup?()
+			@is_setup
+		end
+
+		def run()
+			login
+		rescue LoginError => e
+			puts "[ERROR] #{e.message}"
+			EventMachine::stop_event_loop()
+		end
+
+		def stop()
+			EventManager::fire_event(:stopping)
+			@network_manager.logout
+			# Wait for all sims to disconnect
+			EventMachine::add_timer(5) {
+				EventManager::fire_event(:stopped)
+				EventMachine::stop_event_loop()
+			}
+		end
+	end
+end

data/lib/dsl.rb

@@ -0,0 +1,54 @@
+
+module LibSL
+	module DSL
+		# Client getter
+		def client
+			@client ||= Client.new
+		end
+		module_function :client
+
+		# Setup the client
+		# @param [String] firstname Avatar firstname or account username
+		# @param [String] lastname (optional) Account lastname. Or 'Resident' if a username
+		# is given
+		# @param [String] password Password
+		# @param [String] start (optional) The starting location to connect to. 'last' or 'home' or [REGION NAME]&[X]&[Y]
+		# @param [Symbol] grid (optional) The grid to connect to (:agni for Main grid or :aditi for beta grid)
+		def setup(firstname, lastname, password, start='last', grid=:agni)
+			client.setup firstname, lastname, password, start, grid
+		end
+
+		# Handle the :ready event (syntactic sugar)
+		# @param [Proc] cb (optional) An optional Proc that is called when the event is fired
+		# @yield [Symbol] Event type
+		# @yield [*args] Event specific arguments
+		def when_ready(cb=nil, &block)
+			handle(:ready, cb, &block)
+		end
+
+		def when_stopping(cb=nil, &block)
+			handle(:stopping, cb, &block)
+		end
+
+		def when_stopped(cb=nil, &block)
+			handle(:stopped, cb, &block)
+		end
+
+		# Handle the event type given a Proc cb or a block
+		# @param [Symbol] type The event type 
+		def handle(type, cb=nil, &block)
+			cb ||= Proc.new
+			EventManager::register_handler EventHandler.new(Proc.new, type)
+		end
+
+		# Send packet
+		# @param [Packet] packet
+		def send_packet(packet, reliable=false)
+			client.network_manager.send_packet(packet, reliable)
+		end
+
+		def shutdown
+			client.stop
+		end
+	end
+end

data/lib/events.rb

@@ -0,0 +1,59 @@
+
+module LibSL
+	class EventHandler
+		attr_accessor :types
+
+		# New event handler
+		# @param [Proc] handler Called to handle an event when it is fired
+		# @param [Symbol/Array] type (optional) The type(s) of event to handle
+		def initialize(handler, type=:all)
+			@handler = handler
+			@types = [*type]
+		end
+
+		# Check if this handler can handle one specific event
+		# @param [Symbol] type Event type
+		def accept?(type)
+			if @types.include? :all
+				return true
+			elsif @types.include? type
+				return true
+			else
+				return false
+			end
+		end
+
+		# Handle the event
+		# @param [Symbol] type Event type
+		# @param [args] args (optional) Arguments passed to the handler
+		def handle(type, *args)
+			@handler.call(type, *args)
+		end
+	end
+			
+	class EventManager
+		def self.handlers
+			@@handlers ||= []
+			@@handlers
+		end
+
+		# Register an event handler if it does not already exist
+		# @param [EventHandler] handler The handler
+		def self.register_handler(handler)
+			handlers << handler unless handlers.include? handler
+		end
+
+		# Removes an event handler
+		# @param [EventHandler] handler The handler
+		def self.remove_handler(handler)
+			handlers.delete handler
+		end
+
+		# Fires an event that will be handled by registered handlers
+		# @param [Symbol] type Event type
+		# @param [args] args (optional) Arguments passed to the handlers
+		def self.fire_event(type, *args)
+			handlers.each { |h| h.handle(type, *args) if h.accept?(type) }
+		end
+	end
+end

data/lib/libsl.rb

@@ -0,0 +1,14 @@
+require File.join File.dirname(__FILE__), "client"
+
+include LibSL
+include LibSL::DSL
+
+at_exit do
+	unless client.setup?
+		throw "You need to setup the client!"
+	end
+
+	trap(:INT) {client.stop}
+	trap(:TERM) {client.stop}
+	EventMachine::run { client.run }
+end

data/lib/network.rb

@@ -0,0 +1,305 @@
+require 'xmlrpc/client'
+require 'digest/md5'
+require 'observer'
+require 'rubygems'
+require 'eventmachine'
+
+module LibSL
+	class CircuitHandler < EventMachine::Connection
+		# Handles the connection (or circuit in SL)
+		# @param [Simulator] sim The simulator this connection is managed for
+		def initialize(sim)
+			@sim = sim
+		end
+
+		# Called when data is received from the circuit
+		# @param [String] data The received data
+		def receive_data(data)
+			packet = Packet::decode(data)
+			@sim.packet_received packet
+		end
+
+		def unbind
+			EventManager::fire_event :disconnected, @sim
+		end
+	end
+
+	class Simulator
+		attr_accessor :client, :packets_sent_reliably, :packets_received_reliably, :connected
+		attr_reader :connect_packet_ack_handler
+
+		# Manages the connection to a Simulator 
+		# @param [Client] client The client
+		# @param [String] ip The simulator ip
+		# @param [Integer] port The simulator port
+		# @param [LLU32] circuit_code The circuit code
+		# @param [LLUUID] session_id The current session id
+		# @param [LLUUID] agent_id The id of the agent that logs into the sim
+		def initialize(client, ip, port, circuit_code, session_id, agent_id)
+			@client = client
+			@connected = false
+			@sim_ip = ip
+			@sim_port = port
+			@circuit_code = circuit_code
+			@session_id = session_id
+			@agent_id = agent_id
+			@sequence_number = 0
+			@connection = EventMachine::open_datagram_socket "0.0.0.0", 0, CircuitHandler, self
+			@packets_sent_reliably = {}
+			@packets_received_reliably = {}
+			
+			# Start ack timers
+			@ack_timer = EventMachine::add_periodic_timer(1) do
+				send_acks
+			end
+			@resend_timer = EventMachine::add_periodic_timer 2 do
+				@packets_sent_reliably.each { |sequence_num, packet|
+					if packet.resent_count < 3
+						send_packet(packet, false, true)
+					else
+						@packets_sent_reliably.delete sequence_num
+					end
+				}
+			end
+		end
+
+		# Open the connection to the simulator
+		def connect(move_to=true)
+
+			# First PacketAck means connection is established
+			@connect_packet_ack_handler = EventHandler.new(Proc.new do |type, packet, sim|
+				EventManager::remove_handler(sim.connect_packet_ack_handler)
+				# Add ping handler
+				EventManager::register_handler(EventHandler.new(Proc.new do |type, packet, sim|
+					packet = CompletePingCheckPacket.new({
+						:PingID => {
+							:PingID => packet.PingID.PingID
+						}
+					})
+					send_packet packet
+				end, :StartPingCheckPacket_Received))
+				connected = true
+				sim.client.agent_manager.move_to_sim(sim) if move_to
+			end, :PacketAckPacket_Received)
+			EventManager::register_handler(@connect_packet_ack_handler)
+
+			packet = UseCircuitCodePacket.new({
+				:CircuitCode => {
+					:Code => @circuit_code,
+					:SessionID => @session_id,
+					:ID => @agent_id
+				}
+			})
+			send_packet packet, true
+		end
+
+		# Check whether we are connected to the sim
+		def connected?
+			@connected
+		end
+
+		def connected=(val)
+			@connected = val
+			type = val ? :connected : :disconnected
+			EventManager::fire_event(type, self)
+		end
+
+		# Disconnect from the sim
+		def disconnect
+			send_acks
+			#send_packet CloseCircuitPacket.new
+			self.connected = false
+			@connection.close_connection_after_writing
+		end
+
+		# Send a packet to the simulator
+		# @param [Packet] packet The packet to send to the sim
+		# @param [Bool] reliable Whether to send the packet reliably
+		# @param [Bool] resend Whether the packet has already been sent and should
+		# be resent
+		def send_packet(packet, reliable=false, resend=false)
+			# If we resend a packet we keep the flags as they were
+			packet.resent_flag = resend
+			packet.resent_count += 1 if resend
+			unless resend
+				@sequence_number += 1
+				packet.reliable_flag = reliable
+				packet.sequence_number = @sequence_number
+			end
+
+			# Add packet to the reliably sent packets map
+			@packets_sent_reliably[packet.sequence_number] = packet if packet.reliable_flag
+			
+			append_acks packet
+			data = packet.encode()
+			@connection.send_datagram data, @sim_ip, @sim_port
+		end
+
+		# Called when a packet is received from the simulator
+		# @param [Packet] packet The received packet
+		def packet_received(packet)
+			@packets_received_reliably[packet.sequence_number.number] = packet if packet.reliable_flag
+			type = (packet.class.name.split("::")[-1] + "_Received").to_sym
+			EventManager::fire_event(:PacketReceived, packet, self)
+			EventManager::fire_event(type, packet, self)
+		end
+
+		def append_acks(packet)
+			return if @packets_received_reliably.length == 0
+			packet.acks = @packets_received_reliably.keys
+			packet.acks_flag = true
+		end
+
+		def send_acks()
+			return if @packets_received_reliably.length == 0
+			packet = PacketAckPacket.new
+			@packets_received_reliably.keys.each do |seq|
+				packet.Packets.add.ID = LLU32.new(seq)
+				@packets_received_reliably.delete seq
+			end
+			send_packet packet
+		end
+	end
+
+	class LoginError < StandardError; end
+	class SessionNotTimedoutError < LoginError; end
+	class RequiredUpdateError < LoginError; end
+	class OptionalUpdateError < LoginError; end
+	class LoginFailureError < LoginError; end
+	class AccountBannedError < LoginError; end
+
+	class NetworkManager
+
+		GRIDS = {
+			:agni => "https://login.agni.lindenlab.com/cgi-bin/login.cgi",
+			:aditi => "https://login.aditi.lindenlab.com/cgi-bin/login.cgi"
+		}
+
+		attr_accessor :client, :sims
+		attr_reader :first_name, :last_name, :circuit_code, :sims,
+			:session_id, :secure_session_id, :agent_id, :message_of_the_day,
+			:ready_handler
+
+		# Initialize the network manager
+		# @param [Client] client The client
+		def initialize(client)
+			@client = client
+			@sims = []
+		end
+
+		# Login to the grid
+		# @param [String] first Avatar firstname or account username
+		# @param [String] last (optional) Avatar lastname or "Resident"
+		# @param [String] pass The password
+		# @param [String] start (optional) The starting location to connect to
+		# @param [Symbol] grid (optional) The grid to connect to (:agni or :aditi)
+		def login(first, last, pass, start="last", grid=:agni)
+			client = XMLRPC::Client.new2(GRIDS[grid])
+			client.http_header_extra = {"Content-Type" => "text/xml"}
+			
+			os = "Win"
+			os = "Mac" if RUBY_PLATFORM.downcase.include?("darwin")
+			os = "Lin" if RUBY_PLATFORM.downcase.include?("linux")
+
+			res = client.call("login_to_simulator", {
+				"first" => first,
+				"last" => last,
+				"passwd" => "$1$" + Digest::MD5.hexdigest(pass),
+				"start" => start,
+				"channel" => "libsl",
+				"version" => "1.0",
+				"platform" => os,
+				"mac" => 6.times.map{sprintf("%02x", rand(255))}.join(":"),
+				"options" => [],
+				"id0" => LLUUID.new.to_s,
+				"agree_to_tos" => "true",
+				"read_critical" => "true",
+				"viewer_digest" => "00000000-0000-0000-0000-000000000000"})
+
+			unless res["login"] == "true"
+				case res["reason"]
+				when "presence" then raise SessionNotTimedoutError, res["message"]
+				when "update" then raise RequiredUpdateError, res["message"]
+				when "optional" then raise OptionalUpdateError, res["message"]
+				when "key" then raise LoginFailureError, res["message"]
+				when "ban" then raise AccountBannedError, res["message"]
+				else raise LoginError, res["message"]
+				end
+			end
+
+			@circuit_code = LLU32.new(res["circuit_code"])
+			@session_id = LLUUID.new res["session_id"]
+			@secure_session_id = LLUUID.new res["secure_session_id"]
+			@agent_id = LLUUID.new res["agent_id"]
+			@first_name = res["first_name"]
+			@last_name = res["last_name"]
+			@message_of_the_day = res["message"]
+			setup_handlers
+			connect_to_simulator res["sim_ip"], res["sim_port"]
+		end
+
+		# Logout the client and disconnect from each connected simulator
+		def logout
+			EventManager::register_handler(EventHandler.new(Proc.new do |type, sim|
+				sim.client.network_manager.sims.delete sim
+			end, :disconnected))
+
+			EventManager::register_handler(EventHandler.new(Proc.new do |type, packet, sim|
+				sim.client.network_manager.sims.each { |sim|
+					sim.disconnect
+				}
+				EventManager::fire_event(:logout)
+			end, :LogoutReplyPacket_Received))
+			packet = LogoutRequestPacket.new({
+				:AgentData => {
+					:AgentID => @agent_id,
+					:SessionID => @session_id
+				}
+			})
+			send_packet packet, true
+		end
+
+		def setup_handlers()
+			# PacketAck handler
+			EventManager::register_handler(EventHandler.new(Proc.new do |type, packet, sim|
+				packet.Packets.each{|b| sim.packets_sent_reliably.delete(b.ID.value)}
+			end, :PacketAckPacket_Received))
+			# Handle acks on received packets
+			EventManager::register_handler(EventHandler.new(Proc.new do |type, packet, sim|
+				packet.acks.each{|ack| sim.packets_sent_reliably.delete(ack)}
+			end, :PacketReceived))
+			# Ready handler
+			@ready_handler = EventManager::register_handler(EventHandler.new(Proc.new do |type, sim|
+				EventManager::remove_handler(sim.client.network_manager.ready_handler)
+				EventManager::fire_event(:ready, sim.client)
+			end, :movement_complete))
+		end
+
+		# Connects to a simulator
+		# @param [String] ip The simulator ip
+		# @param [Integer] port The simulator port
+		def connect_to_simulator(ip, port)
+			@sims << Simulator.new(@client, ip, port, @circuit_code, @session_id, @agent_id)
+			@sims.last.connect
+			@active_sim = @sims.last
+		end
+
+		# Activates a simulator as the main simulator
+		# @param [Simulator] sim The simulator to activate
+		def activate_simulator(sim)
+			@sims << sim unless @sims.include? sim
+			sim.connect unless sim.connected?
+			@active_sim = sim
+			AgentManager.move_to_sim sim
+		end
+
+		# Send a packet to a specific simulator
+		# @param [Packet] packet The packet to send
+		# @param [Bool] reliable (optional) Whether to send the packet reliably
+		# @param [Simulator] sim (optional) The sim to send the packet to (or the active sim)
+		def send_packet(packet, reliable=false, sim=nil)
+			sim = @active_sim if sim.nil?
+			@active_sim.send_packet packet, reliable
+		end
+	end
+end