3 files changed, 202 insertions, 2 deletions

diff --git a/OpenSim/Server/Base/HttpServerBase.cs b/OpenSim/Server/Base/HttpServerBase.cs
index 791e1ef..ed0210f 100644
--- a/OpenSim/Server/Base/HttpServerBase.cs
+++ b/OpenSim/Server/Base/HttpServerBase.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Reflection;
 using OpenSim.Framework;
@@ -40,17 +41,40 @@ namespace OpenSim.Server.Base
     {
         // Logger
         //
-        // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); 
+        private static readonly ILog m_Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); 
 
         // The http server instance
         //
         protected BaseHttpServer m_HttpServer = null;
+        protected uint m_Port = 0;
+        protected Dictionary<uint, BaseHttpServer> m_Servers =
+            new Dictionary<uint, BaseHttpServer>();
 
         public IHttpServer HttpServer
         {
             get { return m_HttpServer; }
         }
 
+        public uint DefaultPort
+        {
+            get { return m_Port; }
+        }
+
+        public IHttpServer GetHttpServer(uint port)
+        {
+            m_Log.InfoFormat("[SERVER]: Requested port {0}", port);
+            if (port == m_Port)
+                return HttpServer;
+
+            if (m_Servers.ContainsKey(port))
+                return m_Servers[port];
+
+            m_Servers[port] = new BaseHttpServer(port);
+            m_Servers[port].Start();
+
+            return m_Servers[port];
+        }
+
         // Handle all the automagical stuff
         //
         public HttpServerBase(string prompt, string[] args) : base(prompt, args)
@@ -74,6 +98,8 @@ namespace OpenSim.Server.Base
                 Thread.CurrentThread.Abort();
             }
 
+            m_Port = port;
+
             m_HttpServer = new BaseHttpServer(port);
 
             MainServer.Instance = m_HttpServer;
diff --git a/OpenSim/Server/Base/ProtocolVersions.cs b/OpenSim/Server/Base/ProtocolVersions.cs
new file mode 100644
index 0000000..8db5bb6
--- /dev/null
+++ b/OpenSim/Server/Base/ProtocolVersions.cs
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * 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.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project 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 DEVELOPERS ``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 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.
+ */
+
+namespace OpenSim.Server.Base
+{
+    public class ProtocolVersions
+    {
+        /// <value>
+        /// This is the external protocol versions.  It is separate from the OpenSimulator project version.
+        /// 
+        /// These version numbers should be increased by 1 every time a code
+        /// change in the Service.Connectors and Server.Handlers, espectively, 
+        /// makes the previous OpenSimulator revision incompatible
+        /// with the new revision. 
+        /// 
+        /// Changes which are compatible with an older revision (e.g. older revisions experience degraded functionality
+        /// but not outright failure) do not need a version number increment.
+        /// 
+        /// Having this version number allows the grid service to reject connections from regions running a version
+        /// of the code that is too old. 
+        ///
+        /// </value>
+        
+        // The range of acceptable servers for client-side connectors
+        public readonly static int ClientProtocolVersionMin = 0;
+        public readonly static int ClientProtocolVersionMax = 0;
+
+        // The range of acceptable clients in server-side handlers
+        public readonly static int ServerProtocolVersionMin = 0;
+        public readonly static int ServerProtocolVersionMax = 0;
+    }
+}
diff --git a/OpenSim/Server/Base/ServerUtils.cs b/OpenSim/Server/Base/ServerUtils.cs
index 0a36bbe..9beadd8 100644
--- a/OpenSim/Server/Base/ServerUtils.cs
+++ b/OpenSim/Server/Base/ServerUtils.cs
@@ -141,7 +141,9 @@ namespace OpenSim.Server.Base
                             }
                             catch (Exception e)
                             {
-                                m_log.ErrorFormat("Error loading plugin from {0}, exception {1}", dllName, e.InnerException);
+                                if (!(e is System.MissingMethodException))
+                                    m_log.ErrorFormat("Error loading plugin from {0}, exception {1}", dllName, e.InnerException);
+                                return null;
                             }
 
                             return plug;
@@ -183,5 +185,121 @@ namespace OpenSim.Server.Base
 
             return result;
         }
+
+        public static string BuildQueryString(Dictionary<string, string> data)
+        {
+            string qstring = String.Empty;
+
+            foreach (KeyValuePair<string, string> kvp in data)
+            {
+                string part;
+                if (kvp.Value != String.Empty)
+                {
+                    part = System.Web.HttpUtility.UrlEncode(kvp.Key) +
+                            "=" + System.Web.HttpUtility.UrlEncode(kvp.Value);
+                }
+                else
+                {
+                    part = System.Web.HttpUtility.UrlEncode(kvp.Key);
+                }
+
+                if (qstring != String.Empty)
+                    qstring += "&";
+
+                qstring += part;
+            }
+
+            return qstring;
+        }
+
+        public static string BuildXmlResponse(Dictionary<string, object> data)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            BuildXmlData(rootElement, data);
+
+            return doc.InnerXml;
+        }
+
+        private static void BuildXmlData(XmlElement parent, Dictionary<string, object> data)
+        {
+            foreach (KeyValuePair<string, object> kvp in data)
+            {
+                XmlElement elem = parent.OwnerDocument.CreateElement("",
+                        kvp.Key, "");
+
+                if (kvp.Value is Dictionary<string, object>)
+                {
+                    XmlAttribute type = parent.OwnerDocument.CreateAttribute("",
+                        "type", "");
+                    type.Value = "List";
+
+                    elem.Attributes.Append(type);
+
+                    BuildXmlData(elem, (Dictionary<string, object>)kvp.Value);
+                }
+                else
+                {
+                    elem.AppendChild(parent.OwnerDocument.CreateTextNode(
+                            kvp.Value.ToString()));
+                }
+
+                parent.AppendChild(elem);
+            }
+        }
+
+        public static Dictionary<string, object> ParseXmlResponse(string data)
+        {
+            //m_log.DebugFormat("[XXX]: received xml string: {0}", data);
+
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            XmlDocument doc = new XmlDocument();
+
+            doc.LoadXml(data);
+            
+            XmlNodeList rootL = doc.GetElementsByTagName("ServerResponse");
+
+            if (rootL.Count != 1)
+                return ret;
+
+            XmlNode rootNode = rootL[0];
+
+            ret = ParseElement(rootNode);
+
+            return ret;
+        }
+
+        private static Dictionary<string, object> ParseElement(XmlNode element)
+        {
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            XmlNodeList partL = element.ChildNodes;
+
+            foreach (XmlNode part in partL)
+            {
+                XmlNode type = part.Attributes.GetNamedItem("type");
+                if (type == null || type.Value != "List")
+                {
+                    ret[part.Name] = part.InnerText;
+                }
+                else
+                {
+                    ret[part.Name] = ParseElement(part);
+                }
+            }
+
+            return ret;
+        }
     }
 }