* Adding generic HttpServer to OpenMetaverse.Capabilites

* LoginResponseData can now serialize to XmlRpc
* Adding new Simian project, ultra-lightweight simulator for testing and development
* Shuffling OpenMetaverse.Capabilities around a bit in preparation for CAPS server implementation

git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@2094 52acb1d6-8a22-11de-b505-999d5b087335

OpenMetaverse/Capabilities/EventQueueListener.cs

@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2007-2008, openmetaverse.org
- * All rights reserved.
- *
- * - Redistribution and use in source and binary forms, with or without
- *   modification, are permitted provided that the following conditions are met:
- *
- * - Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- * - Neither the name of the openmetaverse.org nor the names
- *   of its contributors may be used to endorse or promote products derived from
- *   this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-using System;
-using System.Net;
-
-#if !PocketPC
-
-namespace OpenMetaverse.Capabilities
-{
-    public class EventQueueListener
-    {
-    }
-}
-
-#endif

OpenMetaverse/Capabilities/EventQueueServer.cs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2008, openmetaverse.org
+ * Copyright (c) 2008, openmetaverse.org
  * All rights reserved.
  *
  * - Redistribution and use in source and binary forms, with or without
@@ -31,7 +31,7 @@ using System.Net;
 
 namespace OpenMetaverse.Capabilities
 {
-    public class CapsListener
+    public class EventQueueServer
     {
     }
 }

OpenMetaverse/Capabilities/HttpRequestSignature.cs

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2008, openmetaverse.org
+ * All rights reserved.
+ *
+ * - Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * - Neither the name of the openmetaverse.org nor the names
+ *   of its contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Net;
+using System.Text.RegularExpressions;
+
+namespace OpenMetaverse.Capabilities
+{
+    /// <summary>
+    /// Used to match incoming HTTP requests against registered handlers.
+    /// Matches based on any combination of HTTP Method, Content-Type header,
+    /// and URL path. URL path matching supports the * wildcard character
+    /// </summary>
+    public struct HttpRequestSignature : IEquatable<HttpRequestSignature>
+    {
+        private string method;
+        private string contentType;
+        private string path;
+        private bool pathIsWildcard;
+
+        public string Method
+        {
+            get { return method; }
+            set
+            {
+                if (!String.IsNullOrEmpty(value)) method = value.ToLower();
+                else method = String.Empty;
+            }
+        }
+        public string ContentType
+        {
+            get { return contentType; }
+            set
+            {
+                if (!String.IsNullOrEmpty(value)) contentType = value.ToLower();
+                else contentType = String.Empty;
+            }
+        }
+        public string Path
+        {
+            get { return path; }
+            set
+            {
+                pathIsWildcard = false;
+
+                if (!String.IsNullOrEmpty(value))
+                {
+                    // Regex to tear apart URLs, used to extract just a URL
+                    // path from any data we're given
+                    string regexPattern =
+                        @"^(?<s1>(?<s0>[^:/\?#]+):)?(?<a1>"
+                      + @"//(?<a0>[^/\?#]*))?(?<p0>[^\?#]*)"
+                      + @"(?<q1>\?(?<q0>[^#]*))?"
+                      + @"(?<f1>#(?<f0>.*))?";
+                    Regex re = new Regex(regexPattern, RegexOptions.ExplicitCapture);
+                    Match m = re.Match(value);
+                    string newPath = m.Groups["p0"].Value.ToLower();
+
+                    // Remove any trailing forward-slashes
+                    if (newPath.EndsWith("/"))
+                        newPath = newPath.Substring(0, newPath.Length - 1);
+
+                    // Check if this path contains a wildcard. If so, convert it to a regular expression
+                    if (newPath.Contains("*"))
+                    {
+                        pathIsWildcard = true;
+                        newPath = String.Format("^{0}$", newPath.Replace("\\*", ".*"));
+                    }
+
+                    path = newPath;
+                }
+                else
+                {
+                    path = String.Empty;
+                }
+            }
+        }
+        public bool PathIsWildcard
+        {
+            get { return pathIsWildcard; }
+        }
+
+        public HttpRequestSignature(HttpListenerContext context)
+        {
+            method = contentType = path = String.Empty;
+            pathIsWildcard = false;
+
+            Method = context.Request.HttpMethod;
+            ContentType = context.Request.ContentType;
+            Path = context.Request.RawUrl;
+        }
+
+        public bool ExactlyEquals(HttpRequestSignature signature)
+        {
+            return (method.Equals(signature.Method) && contentType.Equals(signature.ContentType) && path.Equals(signature.Path));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj is HttpRequestSignature) ? this == (HttpRequestSignature)obj : false;
+        }
+
+        public bool Equals(HttpRequestSignature signature)
+        {
+            return (this == signature);
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = (method != null) ? method.GetHashCode() : 0;
+            hash ^= (contentType != null) ? contentType.GetHashCode() : 0;
+            hash ^= (path != null) ? path.GetHashCode() : 0;
+            return hash;
+        }
+
+        public static bool operator ==(HttpRequestSignature lhs, HttpRequestSignature rhs)
+        {
+            bool methodMatch = (String.IsNullOrEmpty(lhs.Method) || String.IsNullOrEmpty(rhs.Method) || lhs.Method.Equals(rhs.Method));
+            bool contentTypeMatch = (String.IsNullOrEmpty(lhs.ContentType) || String.IsNullOrEmpty(rhs.ContentType) || lhs.ContentType.Equals(rhs.ContentType));
+            bool pathMatch = false;
+
+            if (methodMatch && contentTypeMatch)
+            {
+                if (!String.IsNullOrEmpty(lhs.Path) && !String.IsNullOrEmpty(rhs.Path))
+                {
+                    // Do wildcard matching if there is any to be done
+                    if (lhs.PathIsWildcard)
+                        pathMatch = Regex.IsMatch(rhs.Path, lhs.Path);
+                    else if (rhs.PathIsWildcard)
+                        pathMatch = Regex.IsMatch(lhs.Path, rhs.Path);
+                    else
+                        pathMatch = lhs.Path.Equals(rhs.Path);
+                }
+                else
+                {
+                    pathMatch = true;
+                }
+            }
+
+            return (methodMatch && contentTypeMatch && pathMatch);
+        }
+
+        public static bool operator !=(HttpRequestSignature lhs, HttpRequestSignature rhs)
+        {
+            return !(lhs == rhs);
+        }
+    }
+}

OpenMetaverse/Capabilities/HttpServer.cs

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2008, openmetaverse.org
+ * All rights reserved.
+ *
+ * - Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * - Neither the name of the openmetaverse.org nor the names
+ *   of its contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+
+namespace OpenMetaverse.Capabilities
+{
+    public class HttpServer
+    {
+        public delegate void HttpRequestCallback(ref HttpListenerContext context);
+
+        public struct HttpRequestHandler : IEquatable<HttpRequestHandler>
+        {
+            public HttpRequestSignature Signature;
+            public HttpRequestCallback Callback;
+
+            public HttpRequestHandler(HttpRequestSignature signature, HttpRequestCallback callback)
+            {
+                Signature = signature;
+                Callback = callback;
+            }
+
+            public override bool Equals(object obj)
+            {
+                return (obj is HttpRequestHandler) ? this.Signature == ((HttpRequestHandler)obj).Signature : false;
+            }
+
+            public override int GetHashCode()
+            {
+                return Signature.GetHashCode();
+            }
+
+            public bool Equals(HttpRequestHandler handler)
+            {
+                return this.Signature == handler.Signature;
+            }
+        }
+
+        HttpListener server;
+        AsyncCallback serverCallback;
+        int serverPort;
+        bool sslEnabled;
+        List<HttpRequestHandler> requestHandlers;
+
+        bool isRunning;
+
+        public HttpServer(int port, bool ssl)
+        {
+            serverPort = port;
+            sslEnabled = ssl;
+            server = new HttpListener();
+            serverCallback = new AsyncCallback(BeginGetContextCallback);
+
+            if (ssl)
+                server.Prefixes.Add(String.Format("https://+:{0}/", port));
+            else
+                server.Prefixes.Add(String.Format("http://+:{0}/", port));
+
+            requestHandlers = new List<HttpRequestHandler>();
+
+            isRunning = false;
+        }
+
+        public void AddHandler(HttpRequestHandler handler)
+        {
+            if (!isRunning)
+                requestHandlers.Add(handler);
+            else
+                throw new InvalidOperationException("Cannot add HTTP request handlers while the server is running");
+        }
+
+        public void RemoveHandler(HttpRequestHandler handler)
+        {
+            if (!isRunning)
+                requestHandlers.Remove(handler);
+            else
+                throw new InvalidOperationException("Cannot add HTTP request handlers while the server is running");
+        }
+
+        public void Start()
+        {
+            server.Start();
+            server.BeginGetContext(serverCallback, server);
+            isRunning = true;
+        }
+
+        public void Stop()
+        {
+            isRunning = false;
+            try { server.Stop(); }
+            catch (ObjectDisposedException) { }
+        }
+
+        protected void BeginGetContextCallback(IAsyncResult result)
+        {
+            HttpListenerContext context = null;
+
+            // Retrieve the incoming request
+            try { context = server.EndGetContext(result); }
+            catch (Exception)
+            {
+            }
+
+            if (isRunning)
+            {
+                // Immediately start listening again
+                try { server.BeginGetContext(serverCallback, server); }
+                catch (Exception)
+                {
+                    // Something went wrong, can't resume listening. Bail out now
+                    // since this is a shutdown (whether it was meant to be or not)
+                    return;
+                }
+
+                // Process the incoming request
+                if (context != null)
+                {
+                    // Create a request signature
+                    HttpRequestSignature signature = new HttpRequestSignature(context);
+
+                    // Look for a signature match in our handlers
+                    for (int i = 0; i < requestHandlers.Count; i++)
+                    {
+                        HttpRequestHandler handler = requestHandlers[i];
+
+                        if (handler.Signature == signature)
+                        {
+                            // Request signature matched, handle it
+                            try
+                            {
+                                handler.Callback(ref context);
+                            }
+                            catch (Exception e)
+                            {
+                                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                                context.Response.StatusDescription = e.ToString();
+                            }
+
+                            context.Response.Close();
+                            return;
+                        }
+                    }
+
+                    // No registered handler matched this request's signature. Send a 404
+                    context.Response.StatusCode = (int)HttpStatusCode.NotFound;
+                    context.Response.StatusDescription = String.Format(
+                        "No request handler registered for Method=\"{0}\", Content-Type=\"{1}\", Path=\"{2}\"",
+                        signature.Method, signature.ContentType, signature.Path);
+                    context.Response.Close();
+                }
+            }
+        }
+    }
+}

OpenMetaverse/EventDictionary.cs

@@ -110,18 +110,28 @@ namespace OpenMetaverse
         {
             NetworkManager.PacketCallback callback;
 
-            if (_EventTable.TryGetValue(packetType, out callback))
+            // Default handler first, if one exists
+            if (_EventTable.TryGetValue(PacketType.Default, out callback))
             {
-                try
-                {
-                    callback(packet, simulator);
-                }
+                try { callback(packet, simulator); }
                 catch (Exception ex)
                 {
-                    Logger.Log("Packet Event Handler: " + ex.ToString(), Helpers.LogLevel.Error, Client);
+                    Logger.Log("Default packet event handler: " + ex.ToString(), Helpers.LogLevel.Error, Client);
                 }
             }
-            else if (packetType != PacketType.Default && packetType != PacketType.PacketAck)
+
+            if (_EventTable.TryGetValue(packetType, out callback))
+            {
+                try { callback(packet, simulator); }
+                catch (Exception ex)
+                {
+                    Logger.Log("Packet event handler: " + ex.ToString(), Helpers.LogLevel.Error, Client);
+                }
+
+                return;
+            }
+            
+            if (packetType != PacketType.Default && packetType != PacketType.PacketAck)
             {
                 Logger.DebugLog("No handler registered for packet event " + packetType, Client);
             }
@@ -136,12 +146,24 @@ namespace OpenMetaverse
         internal void BeginRaiseEvent(PacketType packetType, Packet packet, Simulator simulator)
         {
             NetworkManager.PacketCallback callback;
+            PacketCallbackWrapper wrapper;
+
+            // Default handler first, if one exists
+            if (_EventTable.TryGetValue(PacketType.Default, out callback))
+            {
+                if (callback != null)
+                {
+                    wrapper.Callback = callback;
+                    wrapper.Packet = packet;
+                    wrapper.Simulator = simulator;
+                    ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
+                }
+            }
 
             if (_EventTable.TryGetValue(packetType, out callback))
             {
                 if (callback != null)
                 {
-                    PacketCallbackWrapper wrapper;
                     wrapper.Callback = callback;
                     wrapper.Packet = packet;
                     wrapper.Simulator = simulator;

OpenMetaverse/Login.cs

@@ -29,6 +29,7 @@ using System.Collections.Generic;
 using System.Threading;
 using System.IO;
 using System.Net;
+using System.Xml;
 using System.Security.Cryptography.X509Certificates;
 using OpenMetaverse.StructuredData;
 using OpenMetaverse.Capabilities;
@@ -100,6 +101,9 @@ namespace OpenMetaverse
 
     public struct LoginResponseData
     {
+        public bool Success;
+        public string Reason;
+        public string Message;
         public UUID AgentID;
         public UUID SessionID;
         public UUID SecureSessionID;
@@ -140,9 +144,7 @@ namespace OpenMetaverse
             }
             catch (LLSDException e)
             {
-                // FIXME: sometimes look_at comes back with invalid values e.g: 'look_at':'[r1,r2.0193899999999998204e-06,r0]'
-                // need to handle that somehow
-                Logger.DebugLog("login server returned (some) invalid data: " + e.Message);
+                Logger.DebugLog("Login server returned (some) invalid data: " + e.Message);
             }
 
             // Home
@@ -209,6 +211,167 @@ namespace OpenMetaverse
             LibraryFolders = ParseInventoryFolders("inventory-skel-lib", LibraryOwner, reply);
         }
 
+        public void ToXmlRpc(XmlWriter writer)
+        {
+            writer.WriteStartElement("methodResponse");
+            {
+                writer.WriteStartElement("params");
+                writer.WriteStartElement("param");
+                writer.WriteStartElement("value");
+                writer.WriteStartElement("struct");
+                {
+                    if (Success)
+                    {
+                        // session_id
+                        WriteXmlRpcStringMember(writer, false, "session_id", SessionID.ToString());
+
+                        // ui-config
+                        WriteXmlRpcArrayStart(writer, "ui-config");
+                        WriteXmlRpcStringMember(writer, true, "allow_first_life", "Y");
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // inventory-lib-owner
+                        WriteXmlRpcArrayStart(writer, "inventory-lib-owner");
+                        WriteXmlRpcStringMember(writer, true, "agent_id", LibraryOwner.ToString());
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // start_location
+                        WriteXmlRpcStringMember(writer, false, "start_location", StartLocation);
+
+                        // seconds_since_epoch
+                        WriteXmlRpcIntMember(writer, false, "seconds_since_epoch", Utils.DateTimeToUnixTime(SecondsSinceEpoch));
+
+                        // event_categories
+                        WriteXmlRpcArrayStart(writer, "event_categories");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // classified_categories
+                        WriteXmlRpcArrayStart(writer, "classified_categories");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // inventory-root
+                        WriteXmlRpcArrayStart(writer, "inventory-root");
+                        WriteXmlRpcStringMember(writer, true, "folder_id", InventoryRoot.ToString());
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // sim_port
+                        WriteXmlRpcIntMember(writer, false, "sim_port", SimPort);
+
+                        // agent_id
+                        WriteXmlRpcStringMember(writer, false, "agent_id", AgentID.ToString());
+
+                        // agent_access
+                        WriteXmlRpcStringMember(writer, false, "agent_access", AgentAccess);
+
+                        // inventory-skeleton
+                        WriteXmlRpcArrayStart(writer, "inventory-skeleton");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // buddy-list
+                        WriteXmlRpcArrayStart(writer, "buddy-list");
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // first_name
+                        WriteXmlRpcStringMember(writer, false, "first_name", FirstName);
+
+                        // global-textures
+                        WriteXmlRpcArrayStart(writer, "global-textures");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // inventory-skel-lib
+                        WriteXmlRpcArrayStart(writer, "inventory-skel-lib");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // seed_capability
+                        WriteXmlRpcStringMember(writer, false, "seed_capability", SeedCapability);
+
+                        // gestures
+                        WriteXmlRpcArrayStart(writer, "gestures");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // sim_ip
+                        WriteXmlRpcStringMember(writer, false, "sim_ip", SimIP.ToString());
+
+                        // inventory-lib-root
+                        WriteXmlRpcArrayStart(writer, "inventory-lib-root");
+                        WriteXmlRpcStringMember(writer, true, "folder_id", LibraryRoot.ToString());
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // login-flags
+                        WriteXmlRpcArrayStart(writer, "login-flags");
+                        writer.WriteStartElement("struct"); writer.WriteEndElement();
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // inventory_host
+                        WriteXmlRpcStringMember(writer, false, "inventory_host", String.Empty);
+
+                        // home
+                        LLSDMap home = new LLSDMap(3);
+
+                        LLSDArray homeRegionHandle = new LLSDArray(2);
+                        uint homeRegionX, homeRegionY;
+                        Helpers.LongToUInts(HomeRegion, out homeRegionX, out homeRegionY);
+                        homeRegionHandle.Add(LLSD.FromReal((double)homeRegionX));
+                        homeRegionHandle.Add(LLSD.FromReal((double)homeRegionY));
+
+                        home["region_handle"] = homeRegionHandle;
+                        home["position"] = LLSD.FromVector3(HomePosition);
+                        home["look_at"] = LLSD.FromVector3(HomeLookAt);
+
+                        WriteXmlRpcStringMember(writer, false, "home", LLSDParser.SerializeNotation(home));
+
+                        // message
+                        WriteXmlRpcStringMember(writer, false, "message", Message);
+
+                        // look_at
+                        WriteXmlRpcStringMember(writer, false, "look_at", LLSDParser.SerializeNotation(LLSD.FromVector3(LookAt)));
+
+                        // login
+                        WriteXmlRpcStringMember(writer, false, "login", "true");
+
+                        // event_notifications
+                        WriteXmlRpcArrayStart(writer, "event_notifications");
+                        WriteXmlRpcArrayEnd(writer);
+
+                        // secure_session_id
+                        WriteXmlRpcStringMember(writer, false, "secure_session_id", SecureSessionID.ToString());
+
+                        // region_x
+                        WriteXmlRpcIntMember(writer, false, "region_x", RegionX);
+
+                        // last_name
+                        WriteXmlRpcStringMember(writer, false, "last_name", LastName);
+
+                        // region_y
+                        WriteXmlRpcIntMember(writer, false, "region_y", RegionY);
+
+                        // circuit_code
+                        WriteXmlRpcIntMember(writer, false, "circuit_code", CircuitCode);
+
+                        // initial-outfit
+                        WriteXmlRpcArrayStart(writer, "initial-outfit");
+                        WriteXmlRpcArrayEnd(writer);
+                    }
+                    else
+                    {
+                        // Login failure
+                    }
+                }
+                writer.WriteEndElement();
+                writer.WriteEndElement();
+                writer.WriteEndElement();
+                writer.WriteEndElement();
+            }
+            writer.WriteEndElement();
+            writer.Close();
+        }
+
         #region Parsing Helpers
 
         public static uint ParseUInt(string key, LLSDMap reply)
@@ -305,6 +468,75 @@ namespace OpenMetaverse
         }
 
         #endregion Parsing Helpers
+
+        #region XmlRpc Serializing Helpers
+
+        public static void WriteXmlRpcStringMember(XmlWriter writer, bool wrapWithValueStruct, string name, string value)
+        {
+            if (wrapWithValueStruct)
+            {
+                writer.WriteStartElement("value");
+                writer.WriteStartElement("struct");
+            }
+            writer.WriteStartElement("member");
+            {
+                writer.WriteElementString("name", name);
+                writer.WriteStartElement("value");
+                {
+                    writer.WriteElementString("string", value);
+                }
+                writer.WriteEndElement();
+            }
+            writer.WriteEndElement();
+            if (wrapWithValueStruct)
+            {
+                writer.WriteEndElement();
+                writer.WriteEndElement();
+            }
+        }
+
+        public static void WriteXmlRpcIntMember(XmlWriter writer, bool wrapWithValueStruct, string name, uint value)
+        {
+            if (wrapWithValueStruct)
+            {
+                writer.WriteStartElement("value");
+                writer.WriteStartElement("struct");
+            }
+            writer.WriteStartElement("member");
+            {
+                writer.WriteElementString("name", name);
+                writer.WriteStartElement("value");
+                {
+                    writer.WriteElementString("i4", value.ToString());
+                }
+                writer.WriteEndElement();
+            }
+            writer.WriteEndElement();
+            if (wrapWithValueStruct)
+            {
+                writer.WriteEndElement();
+                writer.WriteEndElement();
+            }
+        }
+
+        public static void WriteXmlRpcArrayStart(XmlWriter writer, string name)
+        {
+            writer.WriteStartElement("member");
+                writer.WriteElementString("name", name);
+                writer.WriteStartElement("value");
+                    writer.WriteStartElement("array");
+                        writer.WriteStartElement("data");
+        }
+
+        public static void WriteXmlRpcArrayEnd(XmlWriter writer)
+        {
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+        }
+
+        #endregion XmlRpc Serializing Helpers
     }
 
     #endregion Structs
@@ -656,6 +888,8 @@ namespace OpenMetaverse
                         bool loginSuccess = llsd.AsBoolean();
                         bool redirect = (llsd.AsString() == "indeterminate");
                         LoginResponseData data = new LoginResponseData();
+                        data.Reason = reason;
+                        data.Message = message;
 
                         if (redirect)
                         {

OpenMetaverse/NetworkManager.cs

@@ -776,20 +776,14 @@ namespace OpenMetaverse
                             #endregion ACK handling
                         }
 
-                        #region FireCallbacks
+                        #region Fire callbacks
 
                         if (Client.Settings.SYNC_PACKETCALLBACKS)
-                        {
-                            PacketEvents.RaiseEvent(PacketType.Default, packet, simulator);
                             PacketEvents.RaiseEvent(packet.Type, packet, simulator);
-                        }
                         else
-                        {
-                            PacketEvents.BeginRaiseEvent(PacketType.Default, packet, simulator);
                             PacketEvents.BeginRaiseEvent(packet.Type, packet, simulator);
-                        }
 
-                        #endregion FireCallbacks
+                        #endregion Fire callbacks
                     }
                 }
             }

OpenMetaverse/Simulator.cs

@@ -855,7 +855,7 @@ namespace OpenMetaverse
             }
 
             Stats.RecvBytes += (ulong)buffer.DataLength;
-            Stats.RecvPackets++;
+            ++Stats.RecvPackets;
 
             #endregion Packet Decoding