Merge remote-tracking branch 'os/master'

2 files changed, 2227 insertions, 0 deletions

diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
new file mode 100644
index 0000000..45af212
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
@@ -0,0 +1,899 @@
+/*
+ * 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.
+ */
+
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Security;
+using System.Web;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using Mono.Addins;
+
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using System.Text.RegularExpressions;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.OptionalModules.Avatar.Voice.FreeSwitchVoice
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "FreeSwitchVoiceModule")]
+    public class FreeSwitchVoiceModule : ISharedRegionModule, IVoiceModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // Capability string prefixes
+        private static readonly string m_parcelVoiceInfoRequestPath = "0207/";
+        private static readonly string m_provisionVoiceAccountRequestPath = "0208/";
+        //private static readonly string m_chatSessionRequestPath = "0209/";
+
+        // Control info
+        private static bool   m_Enabled  = false;
+
+        // FreeSwitch server is going to contact us and ask us all
+        // sorts of things.
+
+        // SLVoice client will do a GET on this prefix
+        private static string m_freeSwitchAPIPrefix;
+
+        // We need to return some information to SLVoice
+        // figured those out via curl
+        // http://vd1.vivox.com/api2/viv_get_prelogin.php
+        //
+        // need to figure out whether we do need to return ALL of
+        // these...
+        private static string m_freeSwitchRealm;
+        private static string m_freeSwitchSIPProxy;
+        private static bool m_freeSwitchAttemptUseSTUN;
+        private static string m_freeSwitchEchoServer;
+        private static int m_freeSwitchEchoPort;
+        private static string m_freeSwitchDefaultWellKnownIP;
+        private static int m_freeSwitchDefaultTimeout;
+        private static string m_freeSwitchUrlResetPassword;
+        private uint m_freeSwitchServicePort;
+        private string m_openSimWellKnownHTTPAddress;
+//        private string m_freeSwitchContext;
+
+        private readonly Dictionary<string, string> m_UUIDName = new Dictionary<string, string>();
+        private Dictionary<string, string> m_ParcelAddress = new Dictionary<string, string>();
+
+        private IConfig m_Config;
+
+        private IFreeswitchService m_FreeswitchService;
+
+        public void Initialise(IConfigSource config)
+        {
+            m_Config = config.Configs["FreeSwitchVoice"];
+
+            if (m_Config == null)
+                return;
+
+            if (!m_Config.GetBoolean("Enabled", false))
+                return;
+
+            try
+            {
+                string serviceDll = m_Config.GetString("LocalServiceModule",
+                        String.Empty);
+
+                if (serviceDll == String.Empty)
+                {
+                    m_log.Error("[FreeSwitchVoice]: No LocalServiceModule named in section FreeSwitchVoice.  Not starting.");
+                    return;
+                }
+
+                Object[] args = new Object[] { config };
+                m_FreeswitchService = ServerUtils.LoadPlugin<IFreeswitchService>(serviceDll, args);
+
+                string jsonConfig = m_FreeswitchService.GetJsonConfig();
+                //m_log.Debug("[FreeSwitchVoice]: Configuration string: " + jsonConfig);
+                OSDMap map = (OSDMap)OSDParser.DeserializeJson(jsonConfig);
+
+                m_freeSwitchAPIPrefix = map["APIPrefix"].AsString();
+                m_freeSwitchRealm = map["Realm"].AsString();
+                m_freeSwitchSIPProxy = map["SIPProxy"].AsString();
+                m_freeSwitchAttemptUseSTUN = map["AttemptUseSTUN"].AsBoolean();
+                m_freeSwitchEchoServer = map["EchoServer"].AsString();
+                m_freeSwitchEchoPort = map["EchoPort"].AsInteger();
+                m_freeSwitchDefaultWellKnownIP = map["DefaultWellKnownIP"].AsString();
+                m_freeSwitchDefaultTimeout = map["DefaultTimeout"].AsInteger();
+                m_freeSwitchUrlResetPassword = String.Empty;
+//                m_freeSwitchContext = map["Context"].AsString();
+
+                if (String.IsNullOrEmpty(m_freeSwitchRealm) ||
+                    String.IsNullOrEmpty(m_freeSwitchAPIPrefix))
+                {
+                    m_log.Error("[FreeSwitchVoice]: Freeswitch service mis-configured.  Not starting.");                    
+                    return;
+                }
+
+                // set up http request handlers for
+                // - prelogin: viv_get_prelogin.php
+                // - signin: viv_signin.php
+                // - buddies: viv_buddy.php
+                // - ???: viv_watcher.php
+                // - signout: viv_signout.php
+                MainServer.Instance.AddHTTPHandler(String.Format("{0}/viv_get_prelogin.php", m_freeSwitchAPIPrefix),
+                                                     FreeSwitchSLVoiceGetPreloginHTTPHandler);
+
+                MainServer.Instance.AddHTTPHandler(String.Format("{0}/freeswitch-config", m_freeSwitchAPIPrefix), FreeSwitchConfigHTTPHandler);
+
+                // RestStreamHandler h = new
+                // RestStreamHandler("GET",
+                // String.Format("{0}/viv_get_prelogin.php", m_freeSwitchAPIPrefix), FreeSwitchSLVoiceGetPreloginHTTPHandler);
+                //  MainServer.Instance.AddStreamHandler(h);
+
+                MainServer.Instance.AddHTTPHandler(String.Format("{0}/viv_signin.php", m_freeSwitchAPIPrefix),
+                                 FreeSwitchSLVoiceSigninHTTPHandler);
+
+                MainServer.Instance.AddHTTPHandler(String.Format("{0}/viv_buddy.php", m_freeSwitchAPIPrefix),
+                                 FreeSwitchSLVoiceBuddyHTTPHandler);
+                
+                MainServer.Instance.AddHTTPHandler(String.Format("{0}/viv_watcher.php", m_freeSwitchAPIPrefix),
+                                 FreeSwitchSLVoiceWatcherHTTPHandler);                
+
+                m_log.InfoFormat("[FreeSwitchVoice]: using FreeSwitch server {0}", m_freeSwitchRealm);
+
+                m_Enabled = true;
+
+                m_log.Info("[FreeSwitchVoice]: plugin enabled");
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[FreeSwitchVoice]: plugin initialization failed: {0} {1}", e.Message, e.StackTrace);
+                return;
+            }
+
+            // This here is a region module trying to make a global setting.
+            // Not really a good idea but it's Windows only, so I can't test.
+            try
+            {
+                ServicePointManager.ServerCertificateValidationCallback += CustomCertificateValidation;
+            }
+            catch (NotImplementedException)
+            {
+                try
+                {
+#pragma warning disable 0612, 0618
+                    // Mono does not implement the ServicePointManager.ServerCertificateValidationCallback yet!  Don't remove this!
+                    ServicePointManager.CertificatePolicy = new MonoCert();
+#pragma warning restore 0612, 0618
+                }
+                catch (Exception)
+                {
+                    // COmmented multiline spam log message
+                    //m_log.Error("[FreeSwitchVoice]: Certificate validation handler change not supported.  You may get ssl certificate validation errors teleporting from your region to some SSL regions.");
+                }
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            // We generate these like this: The region's external host name
+            // as defined in Regions.ini is a good address to use. It's a
+            // dotted quad (or should be!) and it can reach this host from
+            // a client. The port is grabbed from the region's HTTP server.
+            m_openSimWellKnownHTTPAddress = scene.RegionInfo.ExternalHostName;
+            m_freeSwitchServicePort = MainServer.Instance.Port;
+
+            if (m_Enabled)
+            {
+                // we need to capture scene in an anonymous method
+                // here as we need it later in the callbacks
+                scene.EventManager.OnRegisterCaps += delegate(UUID agentID, Caps caps)
+                    {
+                        OnRegisterCaps(scene, agentID, caps);
+                    };
+            }
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (m_Enabled)
+            {
+                m_log.Info("[FreeSwitchVoice]: registering IVoiceModule with the scene");
+
+                // register the voice interface for this module, so the script engine can call us
+                scene.RegisterModuleInterface<IVoiceModule>(this);
+            }
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "FreeSwitchVoiceModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        // <summary>
+        // implementation of IVoiceModule, called by osSetParcelSIPAddress script function
+        // </summary>
+        public void setLandSIPAddress(string SIPAddress,UUID GlobalID)
+        {
+            m_log.DebugFormat("[FreeSwitchVoice]: setLandSIPAddress parcel id {0}: setting sip address {1}",
+                                  GlobalID, SIPAddress);
+
+            lock (m_ParcelAddress)
+            {
+                if (m_ParcelAddress.ContainsKey(GlobalID.ToString()))
+                {
+                    m_ParcelAddress[GlobalID.ToString()] = SIPAddress;
+                }
+                else
+                {
+                    m_ParcelAddress.Add(GlobalID.ToString(), SIPAddress);
+                }
+            }
+        }
+
+        // <summary>
+        // OnRegisterCaps is invoked via the scene.EventManager
+        // everytime OpenSim hands out capabilities to a client
+        // (login, region crossing). We contribute two capabilities to
+        // the set of capabilities handed back to the client:
+        // ProvisionVoiceAccountRequest and ParcelVoiceInfoRequest.
+        //
+        // ProvisionVoiceAccountRequest allows the client to obtain
+        // the voice account credentials for the avatar it is
+        // controlling (e.g., user name, password, etc).
+        //
+        // ParcelVoiceInfoRequest is invoked whenever the client
+        // changes from one region or parcel to another.
+        //
+        // Note that OnRegisterCaps is called here via a closure
+        // delegate containing the scene of the respective region (see
+        // Initialise()).
+        // </summary>
+        public void OnRegisterCaps(Scene scene, UUID agentID, Caps caps)
+        {
+            m_log.DebugFormat(
+                "[FreeSwitchVoice]: OnRegisterCaps() called with agentID {0} caps {1} in scene {2}", 
+                agentID, caps, scene.RegionInfo.RegionName);
+
+            string capsBase = "/CAPS/" + caps.CapsObjectPath;
+            caps.RegisterHandler(
+                "ProvisionVoiceAccountRequest",
+                new RestStreamHandler(
+                    "POST",
+                    capsBase + m_provisionVoiceAccountRequestPath,
+                    (request, path, param, httpRequest, httpResponse)
+                        => ProvisionVoiceAccountRequest(scene, request, path, param, agentID, caps),
+                    "ProvisionVoiceAccountRequest",
+                    agentID.ToString()));
+
+            caps.RegisterHandler(
+                "ParcelVoiceInfoRequest",
+                new RestStreamHandler(
+                    "POST",
+                    capsBase + m_parcelVoiceInfoRequestPath,
+                        (request, path, param, httpRequest, httpResponse)
+                            => ParcelVoiceInfoRequest(scene, request, path, param, agentID, caps),
+                    "ParcelVoiceInfoRequest",
+                    agentID.ToString()));
+
+            //caps.RegisterHandler(
+            //    "ChatSessionRequest",
+            //    new RestStreamHandler(
+            //        "POST",
+            //        capsBase + m_chatSessionRequestPath,
+            //                (request, path, param, httpRequest, httpResponse)
+            //                    => ChatSessionRequest(scene, request, path, param, agentID, caps),
+            //        "ChatSessionRequest",
+            //        agentID.ToString()));
+        }
+
+        /// <summary>
+        /// Callback for a client request for Voice Account Details
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ProvisionVoiceAccountRequest(Scene scene, string request, string path, string param,
+                                                   UUID agentID, Caps caps)
+        {
+            m_log.DebugFormat(
+                "[FreeSwitchVoice][PROVISIONVOICE]: ProvisionVoiceAccountRequest() request: {0}, path: {1}, param: {2}", request, path, param);
+            
+            ScenePresence avatar = scene.GetScenePresence(agentID);
+            if (avatar == null)
+            {
+                System.Threading.Thread.Sleep(2000);
+                avatar = scene.GetScenePresence(agentID);
+
+                if (avatar == null)
+                    return "<llsd>undef</llsd>";
+            }
+            string avatarName = avatar.Name;
+
+            try
+            {
+                //XmlElement    resp;
+                string agentname = "x" + Convert.ToBase64String(agentID.GetBytes());
+                string password  = "1234";//temp hack//new UUID(Guid.NewGuid()).ToString().Replace('-','Z').Substring(0,16);
+
+                // XXX: we need to cache the voice credentials, as
+                // FreeSwitch is later going to come and ask us for
+                // those
+                agentname = agentname.Replace('+', '-').Replace('/', '_');
+
+                lock (m_UUIDName)
+                {
+                    if (m_UUIDName.ContainsKey(agentname))
+                    {
+                        m_UUIDName[agentname] = avatarName;
+                    }
+                    else
+                    {
+                        m_UUIDName.Add(agentname, avatarName);
+                    }
+                }
+
+                // LLSDVoiceAccountResponse voiceAccountResponse =
+               //     new LLSDVoiceAccountResponse(agentname, password, m_freeSwitchRealm, "http://etsvc02.hursley.ibm.com/api");
+               LLSDVoiceAccountResponse voiceAccountResponse =
+                   new LLSDVoiceAccountResponse(agentname, password, m_freeSwitchRealm,
+                                                String.Format("http://{0}:{1}{2}/", m_openSimWellKnownHTTPAddress,
+                                                              m_freeSwitchServicePort, m_freeSwitchAPIPrefix));
+
+                string r = LLSDHelpers.SerialiseLLSDReply(voiceAccountResponse);
+
+//                m_log.DebugFormat("[FreeSwitchVoice][PROVISIONVOICE]: avatar \"{0}\": {1}", avatarName, r);
+
+                return r;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[FreeSwitchVoice][PROVISIONVOICE]: avatar \"{0}\": {1}, retry later", avatarName, e.Message);
+                m_log.DebugFormat("[FreeSwitchVoice][PROVISIONVOICE]: avatar \"{0}\": {1} failed", avatarName, e.ToString());
+
+                return "<llsd>undef</llsd>";
+            }
+        }
+
+        /// <summary>
+        /// Callback for a client request for ParcelVoiceInfo
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ParcelVoiceInfoRequest(Scene scene, string request, string path, string param,
+                                             UUID agentID, Caps caps)
+        {
+            m_log.DebugFormat(
+                "[FreeSwitchVoice][PARCELVOICE]: ParcelVoiceInfoRequest() on {0} for {1}", 
+                scene.RegionInfo.RegionName, agentID);
+            
+            ScenePresence avatar = scene.GetScenePresence(agentID);
+            string avatarName = avatar.Name;
+
+            // - check whether we have a region channel in our cache
+            // - if not:
+            //       create it and cache it
+            // - send it to the client
+            // - send channel_uri: as "sip:regionID@m_sipDomain"
+            try
+            {
+                LLSDParcelVoiceInfoResponse parcelVoiceInfo;
+                string channelUri;
+
+                if (null == scene.LandChannel)
+                    throw new Exception(String.Format("region \"{0}\": avatar \"{1}\": land data not yet available",
+                                                      scene.RegionInfo.RegionName, avatarName));
+
+                // get channel_uri: check first whether estate
+                // settings allow voice, then whether parcel allows
+                // voice, if all do retrieve or obtain the parcel
+                // voice channel
+                LandData land = scene.GetLandData(avatar.AbsolutePosition);
+
+                //m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": request: {4}, path: {5}, param: {6}",
+                //                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, request, path, param);
+
+                // TODO: EstateSettings don't seem to get propagated...
+                // if (!scene.RegionInfo.EstateSettings.AllowVoice)
+                // {
+                //     m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": voice not enabled in estate settings",
+                //                       scene.RegionInfo.RegionName);
+                //     channel_uri = String.Empty;
+                // }
+                // else
+
+                if ((land.Flags & (uint)ParcelFlags.AllowVoiceChat) == 0)
+                {
+//                    m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": voice not enabled for parcel",
+//                                      scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName);
+                    channelUri = String.Empty;
+                }
+                else
+                {
+                    channelUri = ChannelUri(scene, land);
+                }
+
+                // fill in our response to the client
+                Hashtable creds = new Hashtable();
+                creds["channel_uri"] = channelUri;
+
+                parcelVoiceInfo = new LLSDParcelVoiceInfoResponse(scene.RegionInfo.RegionName, land.LocalID, creds);
+                string r = LLSDHelpers.SerialiseLLSDReply(parcelVoiceInfo);
+
+//                m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": {4}",
+//                                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, r);
+                return r;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2}, retry later",
+                                  scene.RegionInfo.RegionName, avatarName, e.Message);
+                m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2} failed",
+                                  scene.RegionInfo.RegionName, avatarName, e.ToString());
+
+                return "<llsd>undef</llsd>";
+            }
+        }
+
+        /// <summary>
+        /// Callback for a client request for ChatSessionRequest
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ChatSessionRequest(Scene scene, string request, string path, string param,
+                                         UUID agentID, Caps caps)
+        {
+            ScenePresence avatar = scene.GetScenePresence(agentID);
+            string        avatarName = avatar.Name;
+
+            m_log.DebugFormat("[FreeSwitchVoice][CHATSESSION]: avatar \"{0}\": request: {1}, path: {2}, param: {3}",
+                              avatarName, request, path, param);
+            
+            return "<llsd>true</llsd>";
+        }
+
+        public Hashtable ForwardProxyRequest(Hashtable request)
+        {
+            m_log.Debug("[PROXYING]: -------------------------------proxying request");
+            Hashtable response = new Hashtable();
+            response["content_type"] = "text/xml";
+            response["str_response_string"] = "";
+            response["int_response_code"] = 200;
+
+            string forwardaddress = "https://www.bhr.vivox.com/api2/";
+            string body = (string)request["body"];
+            string method = (string) request["http-method"];
+            string contenttype = (string) request["content-type"];
+            string uri = (string) request["uri"];
+            uri = uri.Replace("/api/", "");
+            forwardaddress += uri;
+
+
+            string fwdresponsestr = "";
+            int fwdresponsecode = 200;
+            string fwdresponsecontenttype = "text/xml";
+
+            HttpWebRequest forwardreq = (HttpWebRequest)WebRequest.Create(forwardaddress);
+            forwardreq.Method = method;
+            forwardreq.ContentType = contenttype;
+            forwardreq.KeepAlive = false;
+
+            if (method == "POST")
+            {
+                byte[] contentreq = Util.UTF8.GetBytes(body);
+                forwardreq.ContentLength = contentreq.Length;
+                Stream reqStream = forwardreq.GetRequestStream();
+                reqStream.Write(contentreq, 0, contentreq.Length);
+                reqStream.Close();
+            }
+
+            using (HttpWebResponse fwdrsp = (HttpWebResponse)forwardreq.GetResponse())
+            {
+                Encoding encoding = Util.UTF8;
+
+                using (Stream s = fwdrsp.GetResponseStream())
+                {
+                    using (StreamReader fwdresponsestream = new StreamReader(s))
+                    {
+                        fwdresponsestr = fwdresponsestream.ReadToEnd();
+                        fwdresponsecontenttype = fwdrsp.ContentType;
+                        fwdresponsecode = (int)fwdrsp.StatusCode;
+                    }
+                }
+            }
+
+            response["content_type"] = fwdresponsecontenttype;
+            response["str_response_string"] = fwdresponsestr;
+            response["int_response_code"] = fwdresponsecode;
+
+            return response;
+        }
+
+        public Hashtable FreeSwitchSLVoiceGetPreloginHTTPHandler(Hashtable request)
+        {
+            m_log.Debug("[FreeSwitchVoice]: FreeSwitchSLVoiceGetPreloginHTTPHandler called");
+
+            Hashtable response = new Hashtable();
+            response["content_type"] = "text/xml";
+            response["keepalive"] = false;
+
+            response["str_response_string"] = String.Format(
+                "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
+                "<VCConfiguration>\r\n"+
+                    "<DefaultRealm>{0}</DefaultRealm>\r\n" +
+                    "<DefaultSIPProxy>{1}</DefaultSIPProxy>\r\n"+
+                    "<DefaultAttemptUseSTUN>{2}</DefaultAttemptUseSTUN>\r\n"+
+                    "<DefaultEchoServer>{3}</DefaultEchoServer>\r\n"+
+                    "<DefaultEchoPort>{4}</DefaultEchoPort>\r\n"+
+                    "<DefaultWellKnownIP>{5}</DefaultWellKnownIP>\r\n"+
+                    "<DefaultTimeout>{6}</DefaultTimeout>\r\n"+
+                    "<UrlResetPassword>{7}</UrlResetPassword>\r\n"+
+                    "<UrlPrivacyNotice>{8}</UrlPrivacyNotice>\r\n"+
+                    "<UrlEulaNotice/>\r\n"+
+                    "<App.NoBottomLogo>false</App.NoBottomLogo>\r\n"+
+                "</VCConfiguration>",
+                m_freeSwitchRealm, m_freeSwitchSIPProxy, m_freeSwitchAttemptUseSTUN,
+                m_freeSwitchEchoServer, m_freeSwitchEchoPort,
+                m_freeSwitchDefaultWellKnownIP, m_freeSwitchDefaultTimeout,
+                m_freeSwitchUrlResetPassword, "");
+
+            response["int_response_code"] = 200;
+
+            //m_log.DebugFormat("[FreeSwitchVoice] FreeSwitchSLVoiceGetPreloginHTTPHandler return {0}",response["str_response_string"]);
+            return response;
+        }
+
+        public Hashtable FreeSwitchSLVoiceBuddyHTTPHandler(Hashtable request)
+        {
+            m_log.Debug("[FreeSwitchVoice]: FreeSwitchSLVoiceBuddyHTTPHandler called");
+            
+            Hashtable response = new Hashtable();
+            response["int_response_code"] = 200;
+            response["str_response_string"] = string.Empty;
+            response["content-type"] = "text/xml";
+
+            Hashtable requestBody = ParseRequestBody((string)request["body"]);
+
+            if (!requestBody.ContainsKey("auth_token"))
+                return response;
+
+            string auth_token = (string)requestBody["auth_token"];
+            //string[] auth_tokenvals = auth_token.Split(':');
+            //string username = auth_tokenvals[0];
+            int strcount = 0;
+
+            string[] ids = new string[strcount];
+
+            int iter = -1;
+            lock (m_UUIDName)
+            {
+                strcount = m_UUIDName.Count;
+                ids = new string[strcount];
+                foreach (string s in m_UUIDName.Keys)
+                {
+                    iter++;
+                    ids[iter] = s;
+                }
+            }
+            StringBuilder resp = new StringBuilder();
+            resp.Append("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?><response xmlns=\"http://www.vivox.com\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation= \"/xsd/buddy_list.xsd\">");
+
+            resp.Append(string.Format(@"<level0>
+                        <status>OK</status>
+                        <cookie_name>lib_session</cookie_name>
+                        <cookie>{0}</cookie>
+                        <auth_token>{0}</auth_token>
+                        <body>
+                            <buddies>",auth_token));
+            /*
+                        <cookie_name>lib_session</cookie_name>
+                        <cookie>{0}:{1}:9303959503950::</cookie>
+                        <auth_token>{0}:{1}:9303959503950::</auth_token>
+            */
+            for (int i=0;i<ids.Length;i++)
+            {
+                DateTime currenttime = DateTime.Now;
+                string dt = currenttime.ToString("yyyy-MM-dd HH:mm:ss.0zz");
+                resp.Append(
+                    string.Format(@"<level3>
+                                    <bdy_id>{1}</bdy_id>
+                                    <bdy_data></bdy_data>
+                                    <bdy_uri>sip:{0}@{2}</bdy_uri>
+                                    <bdy_nickname>{0}</bdy_nickname>
+                                    <bdy_username>{0}</bdy_username>
+                                    <bdy_domain>{2}</bdy_domain>
+                                    <bdy_status>A</bdy_status>
+                                    <modified_ts>{3}</modified_ts>
+                                    <b2g_group_id></b2g_group_id>
+                                </level3>", ids[i], i ,m_freeSwitchRealm, dt));
+            }
+
+            resp.Append("</buddies><groups></groups></body></level0></response>");
+
+            response["str_response_string"] = resp.ToString();
+//            Regex normalizeEndLines = new Regex(@"(\r\n|\n)", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.Multiline);
+//
+//            m_log.DebugFormat(
+//                "[FREESWITCH]: FreeSwitchSLVoiceBuddyHTTPHandler() response {0}", 
+//                normalizeEndLines.Replace((string)response["str_response_string"],""));
+            
+            return response;
+        }
+
+        public Hashtable FreeSwitchSLVoiceWatcherHTTPHandler(Hashtable request)
+        {
+            m_log.Debug("[FreeSwitchVoice]: FreeSwitchSLVoiceWatcherHTTPHandler called");
+            
+            Hashtable response = new Hashtable();
+            response["int_response_code"] = 200;
+            response["content-type"] = "text/xml";
+
+            Hashtable requestBody = ParseRequestBody((string)request["body"]);
+
+            string auth_token = (string)requestBody["auth_token"];
+            //string[] auth_tokenvals = auth_token.Split(':');
+            //string username = auth_tokenvals[0];
+
+            StringBuilder resp = new StringBuilder();
+            resp.Append("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?><response xmlns=\"http://www.vivox.com\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation= \"/xsd/buddy_list.xsd\">");
+            
+            // FIXME: This is enough of a response to stop viewer 2 complaining about a login failure and get voice to work.  If we don't 
+            // give an OK response, then viewer 2 engages in an continuous viv_signin.php, viv_buddy.php, viv_watcher.php loop
+            // Viewer 1 appeared happy to ignore the lack of reply and still works with this reply.
+            //
+            // However, really we need to fill in whatever watcher data should be here (whatever that is).
+            resp.Append(string.Format(@"<level0>
+                        <status>OK</status>
+                        <cookie_name>lib_session</cookie_name>
+                        <cookie>{0}</cookie>
+                        <auth_token>{0}</auth_token>
+                        <body/></level0></response>", auth_token));            
+            
+            response["str_response_string"] = resp.ToString();
+            
+//            Regex normalizeEndLines = new Regex(@"(\r\n|\n)", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.Multiline);
+//
+//            m_log.DebugFormat(
+//                "[FREESWITCH]: FreeSwitchSLVoiceWatcherHTTPHandler() response {0}", 
+//                normalizeEndLines.Replace((string)response["str_response_string"],""));
+            
+            return response;
+        }
+        
+        public Hashtable FreeSwitchSLVoiceSigninHTTPHandler(Hashtable request)
+        {
+            m_log.Debug("[FreeSwitchVoice]: FreeSwitchSLVoiceSigninHTTPHandler called");
+//            string requestbody = (string)request["body"];
+//            string uri = (string)request["uri"];
+//            string contenttype = (string)request["content-type"];
+
+            Hashtable requestBody = ParseRequestBody((string)request["body"]);
+
+            //string pwd = (string) requestBody["pwd"];
+            string userid = (string) requestBody["userid"];
+
+            string avatarName = string.Empty;
+            int pos = -1;
+            lock (m_UUIDName)
+            {
+                if (m_UUIDName.ContainsKey(userid))
+                {
+                    avatarName = m_UUIDName[userid];
+                    foreach (string s in m_UUIDName.Keys)
+                    {
+                        pos++;
+                        if (s == userid)
+                            break;
+                    }
+                }
+            }
+
+            //m_log.DebugFormat("[FreeSwitchVoice]: AUTH, URI: {0}, Content-Type:{1}, Body{2}", uri, contenttype,
+            //                  requestbody);
+            Hashtable response = new Hashtable();
+            response["str_response_string"] = string.Format(@"<response xsi:schemaLocation=""/xsd/signin.xsd"">
+                    <level0>
+                        <status>OK</status>
+                        <body>
+                        <code>200</code>
+                        <cookie_name>lib_session</cookie_name>
+                        <cookie>{0}:{1}:9303959503950::</cookie>
+                        <auth_token>{0}:{1}:9303959503950::</auth_token>
+                        <primary>1</primary>
+                        <account_id>{1}</account_id>
+                        <displayname>{2}</displayname>
+                        <msg>auth successful</msg>
+                        </body>
+                    </level0>
+                </response>", userid, pos, avatarName);
+
+            response["int_response_code"] = 200;            
+            
+//            m_log.DebugFormat("[FreeSwitchVoice]: Sending FreeSwitchSLVoiceSigninHTTPHandler response");
+            
+            return response;
+        }
+
+        public Hashtable ParseRequestBody(string body)
+        {
+            Hashtable bodyParams = new Hashtable();
+            // split string
+            string [] nvps = body.Split(new Char [] {'&'});
+
+            foreach (string s in nvps)
+            {
+                if (s.Trim() != "")
+                {
+                    string [] nvp = s.Split(new Char [] {'='});
+                    bodyParams.Add(HttpUtility.UrlDecode(nvp[0]), HttpUtility.UrlDecode(nvp[1]));
+                }
+            }
+
+            return bodyParams;
+        }
+
+        private string ChannelUri(Scene scene, LandData land)
+        {
+            string channelUri = null;
+
+            string landUUID;
+            string landName;
+
+            // Create parcel voice channel. If no parcel exists, then the voice channel ID is the same
+            // as the directory ID. Otherwise, it reflects the parcel's ID.
+
+            lock (m_ParcelAddress)
+            {
+                if (m_ParcelAddress.ContainsKey(land.GlobalID.ToString()))
+                {
+                    m_log.DebugFormat("[FreeSwitchVoice]: parcel id {0}: using sip address {1}",
+                                      land.GlobalID, m_ParcelAddress[land.GlobalID.ToString()]);
+                    return m_ParcelAddress[land.GlobalID.ToString()];
+                }
+            }
+
+            if (land.LocalID != 1 && (land.Flags & (uint)ParcelFlags.UseEstateVoiceChan) == 0)
+            {
+                landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, land.Name);
+                landUUID = land.GlobalID.ToString();
+                m_log.DebugFormat("[FreeSwitchVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}",
+                                  landName, land.LocalID, landUUID);
+            }
+            else
+            {
+                landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, scene.RegionInfo.RegionName);
+                landUUID = scene.RegionInfo.RegionID.ToString();
+                m_log.DebugFormat("[FreeSwitchVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}",
+                                  landName, land.LocalID, landUUID);
+            }
+
+            // slvoice handles the sip address differently if it begins with confctl, hiding it from the user in the friends list. however it also disables
+            // the personal speech indicators as well unless some siren14-3d codec magic happens. we dont have siren143d so we'll settle for the personal speech indicator.
+            channelUri = String.Format("sip:conf-{0}@{1}", "x" + Convert.ToBase64String(Encoding.ASCII.GetBytes(landUUID)), m_freeSwitchRealm);
+
+            lock (m_ParcelAddress)
+            {
+                if (!m_ParcelAddress.ContainsKey(land.GlobalID.ToString()))
+                {
+                    m_ParcelAddress.Add(land.GlobalID.ToString(),channelUri);
+                }
+            }
+
+            return channelUri;
+        }
+
+        private static bool CustomCertificateValidation(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors error)
+        {
+            return true;
+        }
+
+        public Hashtable FreeSwitchConfigHTTPHandler(Hashtable request)
+        {
+            Hashtable response = new Hashtable();
+            response["str_response_string"] = string.Empty;
+            response["content_type"] = "text/plain";
+            response["keepalive"] = false;
+            response["int_response_code"] = 500;
+
+            Hashtable requestBody = ParseRequestBody((string)request["body"]);                                   
+
+            string section = (string) requestBody["section"];                       
+
+            if (section == "directory")
+            {
+                string eventCallingFunction = (string)requestBody["Event-Calling-Function"];
+                m_log.DebugFormat(
+                    "[FreeSwitchVoice]: Received request for config section directory, event calling function '{0}'", 
+                    eventCallingFunction);                            
+                
+                response = m_FreeswitchService.HandleDirectoryRequest(requestBody);
+            }
+            else if (section == "dialplan")
+            {     
+                m_log.DebugFormat("[FreeSwitchVoice]: Received request for config section dialplan");
+                
+                response = m_FreeswitchService.HandleDialplanRequest(requestBody);
+            }
+            else
+                m_log.WarnFormat("[FreeSwitchVoice]: Unknown section {0} was requested from config.", section);
+
+            return response;
+        }
+    }
+
+    public class MonoCert : ICertificatePolicy
+    {
+        #region ICertificatePolicy Members
+
+        public bool CheckValidationResult(ServicePoint srvPoint, X509Certificate certificate, WebRequest request, int certificateProblem)
+        {
+            return true;
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
new file mode 100644
index 0000000..dd44564
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
@@ -0,0 +1,1328 @@
+/*
+ * 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 OpenSim 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.
+ */
+
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "VivoxVoiceModule")]
+    public class VivoxVoiceModule : ISharedRegionModule
+    {
+
+        // channel distance model values
+        public const int CHAN_DIST_NONE     = 0; // no attenuation
+        public const int CHAN_DIST_INVERSE  = 1; // inverse distance attenuation
+        public const int CHAN_DIST_LINEAR   = 2; // linear attenuation
+        public const int CHAN_DIST_EXPONENT = 3; // exponential attenuation
+        public const int CHAN_DIST_DEFAULT  = CHAN_DIST_LINEAR;
+
+        // channel type values
+        public static readonly string CHAN_TYPE_POSITIONAL   = "positional";
+        public static readonly string CHAN_TYPE_CHANNEL      = "channel";
+        public static readonly string CHAN_TYPE_DEFAULT      = CHAN_TYPE_POSITIONAL;
+
+        // channel mode values
+        public static readonly string CHAN_MODE_OPEN         = "open";
+        public static readonly string CHAN_MODE_LECTURE      = "lecture";
+        public static readonly string CHAN_MODE_PRESENTATION = "presentation";
+        public static readonly string CHAN_MODE_AUDITORIUM   = "auditorium";
+        public static readonly string CHAN_MODE_DEFAULT      = CHAN_MODE_OPEN;
+
+        // unconstrained default values
+        public const double CHAN_ROLL_OFF_DEFAULT            = 2.0;  // rate of attenuation
+        public const double CHAN_ROLL_OFF_MIN                = 1.0;
+        public const double CHAN_ROLL_OFF_MAX                = 4.0;
+        public const int    CHAN_MAX_RANGE_DEFAULT           = 80;   // distance at which channel is silent
+        public const int    CHAN_MAX_RANGE_MIN               = 0;
+        public const int    CHAN_MAX_RANGE_MAX               = 160;
+        public const int    CHAN_CLAMPING_DISTANCE_DEFAULT   = 10;   // distance before attenuation applies
+        public const int    CHAN_CLAMPING_DISTANCE_MIN       = 0;
+        public const int    CHAN_CLAMPING_DISTANCE_MAX       = 160;
+
+        // Infrastructure
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly Object vlock  = new Object();
+
+        // Capability strings
+        private static readonly string m_parcelVoiceInfoRequestPath = "0107/";
+        private static readonly string m_provisionVoiceAccountRequestPath = "0108/";
+        //private static readonly string m_chatSessionRequestPath = "0109/";
+
+        // Control info, e.g. vivox server, admin user, admin password
+        private static bool   m_pluginEnabled  = false;
+        private static bool   m_adminConnected = false;
+
+        private static string m_vivoxServer;
+        private static string m_vivoxSipUri;
+        private static string m_vivoxVoiceAccountApi;
+        private static string m_vivoxAdminUser;
+        private static string m_vivoxAdminPassword;
+        private static string m_authToken = String.Empty;
+
+        private static int    m_vivoxChannelDistanceModel;
+        private static double m_vivoxChannelRollOff;
+        private static int    m_vivoxChannelMaximumRange;
+        private static string m_vivoxChannelMode;
+        private static string m_vivoxChannelType;
+        private static int    m_vivoxChannelClampingDistance;
+
+        private static Dictionary<string,string> m_parents = new Dictionary<string,string>();
+        private static bool m_dumpXml;
+        
+        private IConfig m_config;
+
+        private object m_Lock;
+
+        public void Initialise(IConfigSource config)
+        {
+
+            m_config = config.Configs["VivoxVoice"];
+
+            if (null == m_config)
+                return;
+
+            if (!m_config.GetBoolean("enabled", false))
+                return;
+
+            m_Lock = new object();
+
+            try
+            {
+                // retrieve configuration variables
+                m_vivoxServer = m_config.GetString("vivox_server", String.Empty);
+                m_vivoxSipUri = m_config.GetString("vivox_sip_uri", String.Empty);
+                m_vivoxAdminUser = m_config.GetString("vivox_admin_user", String.Empty);
+                m_vivoxAdminPassword = m_config.GetString("vivox_admin_password", String.Empty);
+
+                m_vivoxChannelDistanceModel = m_config.GetInt("vivox_channel_distance_model", CHAN_DIST_DEFAULT);
+                m_vivoxChannelRollOff = m_config.GetDouble("vivox_channel_roll_off", CHAN_ROLL_OFF_DEFAULT);
+                m_vivoxChannelMaximumRange = m_config.GetInt("vivox_channel_max_range", CHAN_MAX_RANGE_DEFAULT);
+                m_vivoxChannelMode = m_config.GetString("vivox_channel_mode", CHAN_MODE_DEFAULT).ToLower();
+                m_vivoxChannelType = m_config.GetString("vivox_channel_type", CHAN_TYPE_DEFAULT).ToLower();
+                m_vivoxChannelClampingDistance = m_config.GetInt("vivox_channel_clamping_distance",
+                                                                              CHAN_CLAMPING_DISTANCE_DEFAULT);
+                m_dumpXml = m_config.GetBoolean("dump_xml", false);
+
+                // Validate against constraints and default if necessary
+                if (m_vivoxChannelRollOff < CHAN_ROLL_OFF_MIN || m_vivoxChannelRollOff > CHAN_ROLL_OFF_MAX)
+                {
+                    m_log.WarnFormat("[VivoxVoice] Invalid value for roll off ({0}), reset to {1}.", 
+                                              m_vivoxChannelRollOff, CHAN_ROLL_OFF_DEFAULT);
+                    m_vivoxChannelRollOff = CHAN_ROLL_OFF_DEFAULT;
+                }
+
+                if (m_vivoxChannelMaximumRange < CHAN_MAX_RANGE_MIN || m_vivoxChannelMaximumRange > CHAN_MAX_RANGE_MAX)
+                {
+                    m_log.WarnFormat("[VivoxVoice] Invalid value for maximum range ({0}), reset to {1}.", 
+                                              m_vivoxChannelMaximumRange, CHAN_MAX_RANGE_DEFAULT);
+                    m_vivoxChannelMaximumRange = CHAN_MAX_RANGE_DEFAULT;
+                }
+
+                if (m_vivoxChannelClampingDistance < CHAN_CLAMPING_DISTANCE_MIN || 
+                                            m_vivoxChannelClampingDistance > CHAN_CLAMPING_DISTANCE_MAX)
+                {
+                    m_log.WarnFormat("[VivoxVoice] Invalid value for clamping distance ({0}), reset to {1}.", 
+                                              m_vivoxChannelClampingDistance, CHAN_CLAMPING_DISTANCE_DEFAULT);
+                    m_vivoxChannelClampingDistance = CHAN_CLAMPING_DISTANCE_DEFAULT;
+                }
+
+                switch (m_vivoxChannelMode)
+                {
+                    case "open" : break;
+                    case "lecture" : break;
+                    case "presentation" : break;
+                    case "auditorium" : break;
+                    default :
+                        m_log.WarnFormat("[VivoxVoice] Invalid value for channel mode ({0}), reset to {1}.", 
+                                                  m_vivoxChannelMode, CHAN_MODE_DEFAULT);
+                        m_vivoxChannelMode = CHAN_MODE_DEFAULT;
+                        break;
+                }
+
+                switch (m_vivoxChannelType)
+                {
+                    case "positional" : break;
+                    case "channel" : break;
+                    default :
+                        m_log.WarnFormat("[VivoxVoice] Invalid value for channel type ({0}), reset to {1}.", 
+                                                  m_vivoxChannelType, CHAN_TYPE_DEFAULT);
+                        m_vivoxChannelType = CHAN_TYPE_DEFAULT;
+                        break;
+                }
+
+                m_vivoxVoiceAccountApi = String.Format("http://{0}/api2", m_vivoxServer);
+
+                // Admin interface required values
+                if (String.IsNullOrEmpty(m_vivoxServer) ||
+                    String.IsNullOrEmpty(m_vivoxSipUri) ||
+                    String.IsNullOrEmpty(m_vivoxAdminUser) ||
+                    String.IsNullOrEmpty(m_vivoxAdminPassword))
+                {
+                    m_log.Error("[VivoxVoice] plugin mis-configured");
+                    m_log.Info("[VivoxVoice] plugin disabled: incomplete configuration");
+                    return;
+                }
+
+                m_log.InfoFormat("[VivoxVoice] using vivox server {0}", m_vivoxServer);
+
+                // Get admin rights and cleanup any residual channel definition
+
+                DoAdminLogin();
+
+                m_pluginEnabled = true;
+
+                m_log.Info("[VivoxVoice] plugin enabled");
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[VivoxVoice] plugin initialization failed: {0}", e.Message);
+                m_log.DebugFormat("[VivoxVoice] plugin initialization failed: {0}", e.ToString());
+                return;
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (m_pluginEnabled) 
+            {
+                lock (vlock)
+                {
+                    string channelId;
+
+                    string sceneUUID  = scene.RegionInfo.RegionID.ToString();
+                    string sceneName  = scene.RegionInfo.RegionName;
+                    
+                    // Make sure that all local channels are deleted.
+                    // So we have to search for the children, and then do an
+                    // iteration over the set of chidren identified.
+                    // This assumes that there is just one directory per
+                    // region.
+                    
+                    if (VivoxTryGetDirectory(sceneUUID + "D", out channelId))
+                    {
+                        m_log.DebugFormat("[VivoxVoice]: region {0}: uuid {1}: located directory id {2}",
+                                          sceneName, sceneUUID, channelId);
+
+                        XmlElement children = VivoxListChildren(channelId);
+                        string count;
+
+                        if (XmlFind(children, "response.level0.channel-search.count", out count))
+                        {
+                            int cnum = Convert.ToInt32(count);
+                            for (int i = 0; i < cnum; i++)
+                            {
+                                string id;
+                                if (XmlFind(children, "response.level0.channel-search.channels.channels.level4.id", i, out id))
+                                {
+                                    if (!IsOK(VivoxDeleteChannel(channelId, id)))
+                                        m_log.WarnFormat("[VivoxVoice] Channel delete failed {0}:{1}:{2}", i, channelId, id);
+                                } 
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (!VivoxTryCreateDirectory(sceneUUID + "D", sceneName, out channelId))
+                        {
+                            m_log.WarnFormat("[VivoxVoice] Create failed <{0}:{1}:{2}>",
+                                             "*", sceneUUID, sceneName);
+                            channelId = String.Empty;
+                        }
+                    }
+
+                    // Create a dictionary entry unconditionally. This eliminates the
+                    // need to check for a parent in the core code. The end result is
+                    // the same, if the parent table entry is an empty string, then
+                    // region channels will be created as first-level channels.
+                    lock (m_parents)
+                    {
+                        if (m_parents.ContainsKey(sceneUUID))
+                        {
+                            RemoveRegion(scene);
+                            m_parents.Add(sceneUUID, channelId);
+                        }
+                        else
+                        {
+                            m_parents.Add(sceneUUID, channelId);
+                        }
+                    }
+                }
+
+                // we need to capture scene in an anonymous method
+                // here as we need it later in the callbacks
+                scene.EventManager.OnRegisterCaps += delegate(UUID agentID, Caps caps)
+                    {
+                        OnRegisterCaps(scene, agentID, caps);
+                    };
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            // Do nothing.
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (m_pluginEnabled) 
+            {
+                lock (vlock)
+                {
+                    string channelId;
+
+                    string sceneUUID  = scene.RegionInfo.RegionID.ToString();
+                    string sceneName  = scene.RegionInfo.RegionName;
+                    
+                    // Make sure that all local channels are deleted.
+                    // So we have to search for the children, and then do an
+                    // iteration over the set of chidren identified.
+                    // This assumes that there is just one directory per
+                    // region.
+                    if (VivoxTryGetDirectory(sceneUUID + "D", out channelId))
+                    {
+                        m_log.DebugFormat("[VivoxVoice]: region {0}: uuid {1}: located directory id {2}",
+                                          sceneName, sceneUUID, channelId);
+
+                        XmlElement children = VivoxListChildren(channelId);
+                        string count;
+
+                        if (XmlFind(children, "response.level0.channel-search.count", out count))
+                        {
+                            int cnum = Convert.ToInt32(count);
+                            for (int i = 0; i < cnum; i++)
+                            {
+                                string id;
+                                if (XmlFind(children, "response.level0.channel-search.channels.channels.level4.id", i, out id))
+                                {
+                                    if (!IsOK(VivoxDeleteChannel(channelId, id)))
+                                        m_log.WarnFormat("[VivoxVoice] Channel delete failed {0}:{1}:{2}", i, channelId, id);
+                                } 
+                            }
+                        }
+                    }
+
+                    if (!IsOK(VivoxDeleteChannel(null, channelId)))
+                        m_log.WarnFormat("[VivoxVoice] Parent channel delete failed {0}:{1}:{2}", sceneName, sceneUUID, channelId);
+
+                    // Remove the channel umbrella entry
+
+                    lock (m_parents) 
+                    {
+                        if (m_parents.ContainsKey(sceneUUID))
+                        {
+                            m_parents.Remove(sceneUUID);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void PostInitialise()
+        {
+            // Do nothing.
+        }
+
+        public void Close()
+        {
+            if (m_pluginEnabled)
+                VivoxLogout();
+        }
+
+        public Type ReplaceableInterface 
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "VivoxVoiceModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        // <summary>
+        // OnRegisterCaps is invoked via the scene.EventManager
+        // everytime OpenSim hands out capabilities to a client
+        // (login, region crossing). We contribute two capabilities to
+        // the set of capabilities handed back to the client:
+        // ProvisionVoiceAccountRequest and ParcelVoiceInfoRequest.
+        // 
+        // ProvisionVoiceAccountRequest allows the client to obtain
+        // the voice account credentials for the avatar it is
+        // controlling (e.g., user name, password, etc).
+        // 
+        // ParcelVoiceInfoRequest is invoked whenever the client
+        // changes from one region or parcel to another.
+        //
+        // Note that OnRegisterCaps is called here via a closure
+        // delegate containing the scene of the respective region (see
+        // Initialise()).
+        // </summary>
+        public void OnRegisterCaps(Scene scene, UUID agentID, Caps caps)
+        {
+            m_log.DebugFormat("[VivoxVoice] OnRegisterCaps: agentID {0} caps {1}", agentID, caps);
+
+            string capsBase = "/CAPS/" + caps.CapsObjectPath;
+
+            caps.RegisterHandler(
+                "ProvisionVoiceAccountRequest",
+                 new RestStreamHandler(
+                    "POST",
+                    capsBase + m_provisionVoiceAccountRequestPath,
+                    (request, path, param, httpRequest, httpResponse)
+                        => ProvisionVoiceAccountRequest(scene, request, path, param, agentID, caps),
+                    "ProvisionVoiceAccountRequest",
+                    agentID.ToString()));
+
+            caps.RegisterHandler(
+                "ParcelVoiceInfoRequest",
+                 new RestStreamHandler(
+                    "POST",
+                    capsBase + m_parcelVoiceInfoRequestPath,
+                    (request, path, param, httpRequest, httpResponse)
+                        => ParcelVoiceInfoRequest(scene, request, path, param, agentID, caps),
+                    "ParcelVoiceInfoRequest",
+                    agentID.ToString()));
+
+            //caps.RegisterHandler(
+            //    "ChatSessionRequest",
+            //     new RestStreamHandler(
+            //        "POST",
+            //        capsBase + m_chatSessionRequestPath,
+            //        (request, path, param, httpRequest, httpResponse)
+            //            => ChatSessionRequest(scene, request, path, param, agentID, caps),
+            //        "ChatSessionRequest",
+            //        agentID.ToString()));
+        }
+
+        /// <summary>
+        /// Callback for a client request for Voice Account Details
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ProvisionVoiceAccountRequest(Scene scene, string request, string path, string param,
+                                                   UUID agentID, Caps caps)
+        {
+            try
+            {
+                ScenePresence avatar = null;
+                string        avatarName = null;
+
+                if (scene == null)
+                    throw new Exception("[VivoxVoice][PROVISIONVOICE]: Invalid scene");
+
+                avatar = scene.GetScenePresence(agentID);
+                while (avatar == null)
+                {
+                    Thread.Sleep(100);
+                    avatar = scene.GetScenePresence(agentID);
+                }
+
+                avatarName = avatar.Name;
+
+                m_log.DebugFormat("[VivoxVoice][PROVISIONVOICE]: scene = {0}, agentID = {1}", scene, agentID);
+                m_log.DebugFormat("[VivoxVoice][PROVISIONVOICE]: request: {0}, path: {1}, param: {2}",
+                                  request, path, param);
+
+                XmlElement    resp;
+                bool          retry = false;
+                string        agentname = "x" + Convert.ToBase64String(agentID.GetBytes());
+                string        password  = new UUID(Guid.NewGuid()).ToString().Replace('-','Z').Substring(0,16);
+                string        code = String.Empty;
+
+                agentname = agentname.Replace('+', '-').Replace('/', '_');
+
+                do
+                {
+                    resp = VivoxGetAccountInfo(agentname);
+
+                    if (XmlFind(resp, "response.level0.status", out code))
+                    {
+                        if (code != "OK") 
+                        {
+                            if (XmlFind(resp, "response.level0.body.code", out code)) 
+                            {
+                                // If the request was recognized, then this should be set to something
+                                switch (code)
+                                {
+                                    case "201" : // Account expired
+                                        m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Get account information failed : expired credentials",
+                                                          avatarName);
+                                        m_adminConnected = false;
+                                        retry = DoAdminLogin();
+                                        break;
+
+                                    case "202" : // Missing credentials
+                                        m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Get account information failed : missing credentials",
+                                                          avatarName);
+                                        break;
+
+                                    case "212" : // Not authorized
+                                        m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Get account information failed : not authorized",
+                                                          avatarName);
+                                        break;
+
+                                    case "300" : // Required parameter missing
+                                        m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Get account information failed : parameter missing",
+                                                          avatarName);
+                                        break;
+
+                                    case "403" : // Account does not exist
+                                        resp = VivoxCreateAccount(agentname,password);
+                                        // Note: This REALLY MUST BE status. Create Account does not return code.
+                                        if (XmlFind(resp, "response.level0.status", out code))
+                                        {
+                                            switch (code)
+                                            {
+                                                case "201" : // Account expired
+                                                    m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Create account information failed : expired credentials", 
+                                                                      avatarName);
+                                                    m_adminConnected = false;
+                                                    retry = DoAdminLogin();
+                                                    break;
+                                                    
+                                                case "202" : // Missing credentials
+                                                    m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Create account information failed : missing credentials", 
+                                                                      avatarName);
+                                                    break;
+                                                    
+                                                case "212" : // Not authorized
+                                                    m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Create account information failed : not authorized",
+                                                                      avatarName);
+                                                    break;
+                                                    
+                                                case "300" : // Required parameter missing
+                                                    m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Create account information failed : parameter missing", 
+                                                                      avatarName);
+                                                    break;
+                                                    
+                                                case "400" : // Create failed
+                                                    m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Create account information failed : create failed",
+                                                                      avatarName);
+                                                    break;
+                                            }
+                                        }
+                                        break;
+                                        
+                                    case "404" : // Failed to retrieve account
+                                        m_log.ErrorFormat("[VivoxVoice]: avatar \"{0}\": Get account information failed : retrieve failed");
+                                        // [AMW] Sleep and retry for a fixed period? Or just abandon?
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                }
+                while (retry);
+
+                if (code != "OK")
+                {
+                    m_log.DebugFormat("[VivoxVoice][PROVISIONVOICE]: Get Account Request failed for \"{0}\"", avatarName);
+                    throw new Exception("Unable to execute request");
+                }
+          
+                // Unconditionally change the password on each request
+                VivoxPassword(agentname, password);
+
+                LLSDVoiceAccountResponse voiceAccountResponse =
+                    new LLSDVoiceAccountResponse(agentname, password, m_vivoxSipUri, m_vivoxVoiceAccountApi);
+
+                string r = LLSDHelpers.SerialiseLLSDReply(voiceAccountResponse);
+
+                m_log.DebugFormat("[VivoxVoice][PROVISIONVOICE]: avatar \"{0}\": {1}", avatarName, r);
+
+                return r;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[VivoxVoice][PROVISIONVOICE]: : {0}, retry later", e.Message);
+                m_log.DebugFormat("[VivoxVoice][PROVISIONVOICE]: : {0} failed", e.ToString());
+                return "<llsd><undef /></llsd>";
+            }
+        }
+
+        /// <summary>
+        /// Callback for a client request for ParcelVoiceInfo
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ParcelVoiceInfoRequest(Scene scene, string request, string path, string param,
+                                             UUID agentID, Caps caps)
+        {
+            ScenePresence avatar = scene.GetScenePresence(agentID);
+            string        avatarName = avatar.Name;
+
+            // - check whether we have a region channel in our cache
+            // - if not: 
+            //       create it and cache it
+            // - send it to the client
+            // - send channel_uri: as "sip:regionID@m_sipDomain"
+            try
+            {
+                LLSDParcelVoiceInfoResponse parcelVoiceInfo;
+                string channel_uri;
+
+                if (null == scene.LandChannel) 
+                    throw new Exception(String.Format("region \"{0}\": avatar \"{1}\": land data not yet available",
+                                                      scene.RegionInfo.RegionName, avatarName));
+
+                // get channel_uri: check first whether estate
+                // settings allow voice, then whether parcel allows
+                // voice, if all do retrieve or obtain the parcel
+                // voice channel
+                LandData land = scene.GetLandData(avatar.AbsolutePosition);
+
+                m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": request: {4}, path: {5}, param: {6}",
+                                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, request, path, param);
+                // m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: avatar \"{0}\": location: {1} {2} {3}",
+                //                   avatarName, avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y, avatar.AbsolutePosition.Z);
+
+                // TODO: EstateSettings don't seem to get propagated...
+                if (!scene.RegionInfo.EstateSettings.AllowVoice)
+                {
+                    m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": voice not enabled in estate settings",
+                                      scene.RegionInfo.RegionName);
+                    channel_uri = String.Empty;
+                }
+
+                if ((land.Flags & (uint)ParcelFlags.AllowVoiceChat) == 0)
+                {
+                    m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": voice not enabled for parcel",
+                                      scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName);
+                    channel_uri = String.Empty;
+                }
+                else
+                {
+                    channel_uri = RegionGetOrCreateChannel(scene, land);
+                }
+
+                // fill in our response to the client
+                Hashtable creds = new Hashtable();
+                creds["channel_uri"] = channel_uri;
+
+                parcelVoiceInfo = new LLSDParcelVoiceInfoResponse(scene.RegionInfo.RegionName, land.LocalID, creds);
+                string r = LLSDHelpers.SerialiseLLSDReply(parcelVoiceInfo);
+
+                m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": {4}", 
+                                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, r);
+                return r;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2}, retry later", 
+                                  scene.RegionInfo.RegionName, avatarName, e.Message);
+                m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2} failed", 
+                                  scene.RegionInfo.RegionName, avatarName, e.ToString());
+
+                return "<llsd><undef /></llsd>";
+            }
+        }
+
+        /// <summary>
+        /// Callback for a client request for a private chat channel
+        /// </summary>
+        /// <param name="scene">current scene object of the client</param>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        public string ChatSessionRequest(Scene scene, string request, string path, string param,
+                                         UUID agentID, Caps caps)
+        {
+            ScenePresence avatar = scene.GetScenePresence(agentID);
+            string        avatarName = avatar.Name;
+
+            m_log.DebugFormat("[VivoxVoice][CHATSESSION]: avatar \"{0}\": request: {1}, path: {2}, param: {3}",
+                              avatarName, request, path, param);
+            return "<llsd>true</llsd>";
+        }
+
+        private string RegionGetOrCreateChannel(Scene scene, LandData land)
+        {
+            string channelUri = null;
+            string channelId = null;
+
+            string landUUID;
+            string landName;
+            string parentId;
+
+            lock (m_parents)
+                parentId = m_parents[scene.RegionInfo.RegionID.ToString()];
+
+            // Create parcel voice channel. If no parcel exists, then the voice channel ID is the same
+            // as the directory ID. Otherwise, it reflects the parcel's ID.
+            if (land.LocalID != 1 && (land.Flags & (uint)ParcelFlags.UseEstateVoiceChan) == 0)
+            {
+                landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, land.Name);
+                landUUID = land.GlobalID.ToString();
+                m_log.DebugFormat("[VivoxVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}", 
+                                  landName, land.LocalID, landUUID);
+            }
+            else
+            {
+                landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, scene.RegionInfo.RegionName);
+                landUUID = scene.RegionInfo.RegionID.ToString();
+                m_log.DebugFormat("[VivoxVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}", 
+                                  landName, land.LocalID, landUUID);
+            }
+                    
+            lock (vlock)
+            {
+                // Added by Adam to help debug channel not availible errors.
+                if (VivoxTryGetChannel(parentId, landUUID, out channelId, out channelUri))
+                    m_log.DebugFormat("[VivoxVoice] Found existing channel at " + channelUri);
+                else if (VivoxTryCreateChannel(parentId, landUUID, landName, out channelUri))
+                    m_log.DebugFormat("[VivoxVoice] Created new channel at " + channelUri);
+                else
+                    throw new Exception("vivox channel uri not available");
+
+                m_log.DebugFormat("[VivoxVoice]: Region:Parcel \"{0}\": parent channel id {1}: retrieved parcel channel_uri {2} ", 
+                                  landName, parentId, channelUri);
+            }
+
+            return channelUri;
+        }
+
+        private static readonly string m_vivoxLoginPath = "http://{0}/api2/viv_signin.php?userid={1}&pwd={2}";
+
+        /// <summary>
+        /// Perform administrative login for Vivox.
+        /// Returns a hash table containing values returned from the request.
+        /// </summary>
+        private XmlElement VivoxLogin(string name, string password)
+        {
+            string requrl = String.Format(m_vivoxLoginPath, m_vivoxServer, name, password);
+            return VivoxCall(requrl, false);
+        }
+
+        private static readonly string m_vivoxLogoutPath = "http://{0}/api2/viv_signout.php?auth_token={1}";
+
+        /// <summary>
+        /// Perform administrative logout for Vivox.
+        /// </summary>
+        private XmlElement VivoxLogout()
+        {
+            string requrl = String.Format(m_vivoxLogoutPath, m_vivoxServer, m_authToken);
+            return VivoxCall(requrl, false);
+        }
+
+        private static readonly string m_vivoxGetAccountPath = "http://{0}/api2/viv_get_acct.php?auth_token={1}&user_name={2}";
+
+        /// <summary>
+        /// Retrieve account information for the specified user.
+        /// Returns a hash table containing values returned from the request.
+        /// </summary>
+        private XmlElement VivoxGetAccountInfo(string user)
+        {
+            string requrl = String.Format(m_vivoxGetAccountPath, m_vivoxServer, m_authToken, user);
+            return VivoxCall(requrl, true);
+        }
+
+        private static readonly string m_vivoxNewAccountPath = "http://{0}/api2/viv_adm_acct_new.php?username={1}&pwd={2}&auth_token={3}";
+
+        /// <summary>
+        /// Creates a new account.
+        /// For now we supply the minimum set of values, which
+        /// is user name and password. We *can* supply a lot more
+        /// demographic data.
+        /// </summary>
+        private XmlElement VivoxCreateAccount(string user, string password)
+        {
+            string requrl = String.Format(m_vivoxNewAccountPath, m_vivoxServer, user, password, m_authToken);
+            return VivoxCall(requrl, true);
+        }
+
+        private static readonly string m_vivoxPasswordPath = "http://{0}/api2/viv_adm_password.php?user_name={1}&new_pwd={2}&auth_token={3}";
+
+        /// <summary>
+        /// Change the user's password.
+        /// </summary>
+        private XmlElement VivoxPassword(string user, string password)
+        {
+            string requrl = String.Format(m_vivoxPasswordPath, m_vivoxServer, user, password, m_authToken);
+            return VivoxCall(requrl, true);
+        }
+
+        private static readonly string m_vivoxChannelPath = "http://{0}/api2/viv_chan_mod.php?mode={1}&chan_name={2}&auth_token={3}";
+
+        /// <summary>
+        /// Create a channel.
+        /// Once again, there a multitude of options possible. In the simplest case 
+        /// we specify only the name and get a non-persistent cannel in return. Non
+        /// persistent means that the channel gets deleted if no-one uses it for
+        /// 5 hours. To accomodate future requirements, it may be a good idea to
+        /// initially create channels under the umbrella of a parent ID based upon
+        /// the region name. That way we have a context for side channels, if those
+        /// are required in a later phase.
+        /// 
+        /// In this case the call handles parent and description as optional values.
+        /// </summary>
+        private bool VivoxTryCreateChannel(string parent, string channelId, string description, out string channelUri)
+        {
+            string requrl = String.Format(m_vivoxChannelPath, m_vivoxServer, "create", channelId, m_authToken);
+
+            if (!string.IsNullOrEmpty(parent))
+            {
+                requrl = String.Format("{0}&chan_parent={1}", requrl, parent);
+            }
+            if (!string.IsNullOrEmpty(description))
+            {
+                requrl = String.Format("{0}&chan_desc={1}", requrl, description);
+            }
+
+            requrl = String.Format("{0}&chan_type={1}",              requrl, m_vivoxChannelType);
+            requrl = String.Format("{0}&chan_mode={1}",              requrl, m_vivoxChannelMode);
+            requrl = String.Format("{0}&chan_roll_off={1}",          requrl, m_vivoxChannelRollOff);
+            requrl = String.Format("{0}&chan_dist_model={1}",        requrl, m_vivoxChannelDistanceModel);
+            requrl = String.Format("{0}&chan_max_range={1}",         requrl, m_vivoxChannelMaximumRange);
+            requrl = String.Format("{0}&chan_clamping_distance={1}", requrl, m_vivoxChannelClampingDistance);
+            
+            XmlElement resp = VivoxCall(requrl, true);
+            if (XmlFind(resp, "response.level0.body.chan_uri", out channelUri))
+                return true;
+
+            channelUri = String.Empty;
+            return false;
+        }
+
+        /// <summary>
+        /// Create a directory.
+        /// Create a channel with an unconditional type of "dir" (indicating directory).
+        /// This is used to create an arbitrary name tree for partitioning of the
+        /// channel name space.
+        /// The parent and description are optional values.
+        /// </summary>
+        private bool VivoxTryCreateDirectory(string dirId, string description, out string channelId)
+        {
+            string requrl = String.Format(m_vivoxChannelPath, m_vivoxServer, "create", dirId, m_authToken);
+
+            // if (parent != null && parent != String.Empty)
+            // {
+            //     requrl = String.Format("{0}&chan_parent={1}", requrl, parent);
+            // }
+
+            if (!string.IsNullOrEmpty(description))
+            {
+                requrl = String.Format("{0}&chan_desc={1}", requrl, description);
+            }
+            requrl = String.Format("{0}&chan_type={1}", requrl, "dir");
+
+            XmlElement resp = VivoxCall(requrl, true);
+            if (IsOK(resp) && XmlFind(resp, "response.level0.body.chan_id", out channelId))
+                return true;
+
+            channelId = String.Empty;
+            return false;
+        }
+
+        private static readonly string m_vivoxChannelSearchPath = "http://{0}/api2/viv_chan_search.php?cond_channame={1}&auth_token={2}";
+
+        /// <summary>
+        /// Retrieve a channel.
+        /// Once again, there a multitude of options possible. In the simplest case 
+        /// we specify only the name and get a non-persistent cannel in return. Non
+        /// persistent means that the channel gets deleted if no-one uses it for
+        /// 5 hours. To accomodate future requirements, it may be a good idea to
+        /// initially create channels under the umbrella of a parent ID based upon
+        /// the region name. That way we have a context for side channels, if those
+        /// are required in a later phase.
+        /// In this case the call handles parent and description as optional values.
+        /// </summary>
+        private bool VivoxTryGetChannel(string channelParent, string channelName, 
+                                        out string channelId, out string channelUri)
+        {
+            string count;
+
+            string requrl = String.Format(m_vivoxChannelSearchPath, m_vivoxServer, channelName, m_authToken);
+            XmlElement resp = VivoxCall(requrl, true);
+
+            if (XmlFind(resp, "response.level0.channel-search.count", out count))
+            {
+                int channels = Convert.ToInt32(count);
+
+                // Bug in Vivox Server r2978 where count returns 0
+                // Found by Adam
+                if (channels == 0)
+                {
+                    for (int j=0;j<100;j++)
+                    {
+                        string tmpId;
+                        if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.id", j, out tmpId))
+                            break;
+
+                        channels = j + 1;
+                    }
+                }
+
+                for (int i = 0; i < channels; i++)
+                {
+                    string name;
+                    string id;
+                    string type;
+                    string uri;
+                    string parent;
+
+                    // skip if not a channel
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.type", i, out type) ||
+                        (type != "channel" && type != "positional_M"))
+                    {
+                        m_log.Debug("[VivoxVoice] Skipping Channel " + i + " as it's not a channel.");
+                        continue;
+                    }
+
+                    // skip if not the name we are looking for
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.name", i, out name) ||
+                        name != channelName)
+                    {
+                        m_log.Debug("[VivoxVoice] Skipping Channel " + i + " as it has no name.");
+                        continue;
+                    }
+
+                    // skip if parent does not match
+                    if (channelParent != null && !XmlFind(resp, "response.level0.channel-search.channels.channels.level4.parent", i, out parent))
+                    {
+                        m_log.Debug("[VivoxVoice] Skipping Channel " + i + "/" + name + " as it's parent doesnt match");
+                        continue;
+                    }
+
+                    // skip if no channel id available
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.id", i, out id))
+                    {
+                        m_log.Debug("[VivoxVoice] Skipping Channel " + i + "/" + name + " as it has no channel ID");
+                        continue;
+                    }
+
+                    // skip if no channel uri available
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.uri", i, out uri))
+                    {
+                        m_log.Debug("[VivoxVoice] Skipping Channel " + i + "/" + name + " as it has no channel URI");
+                        continue;
+                    }
+
+                    channelId = id;
+                    channelUri = uri;
+
+                    return true;
+                }
+            }
+            else
+            {
+                m_log.Debug("[VivoxVoice] No count element?");
+            }
+
+            channelId = String.Empty;
+            channelUri = String.Empty;
+
+            // Useful incase something goes wrong.
+            //m_log.Debug("[VivoxVoice] Could not find channel in XMLRESP: " + resp.InnerXml);
+
+            return false;
+        }
+
+        private bool VivoxTryGetDirectory(string directoryName, out string directoryId)
+        {
+            string count;
+
+            string requrl = String.Format(m_vivoxChannelSearchPath, m_vivoxServer, directoryName, m_authToken);
+            XmlElement resp = VivoxCall(requrl, true);
+
+            if (XmlFind(resp, "response.level0.channel-search.count", out count))
+            {
+                int channels = Convert.ToInt32(count);
+                for (int i = 0; i < channels; i++)
+                {
+                    string name;
+                    string id;
+                    string type;
+
+                    // skip if not a directory
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.type", i, out type) || 
+                        type != "dir")
+                        continue;
+
+                    // skip if not the name we are looking for
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.name", i, out name) ||
+                        name != directoryName)
+                        continue;
+
+                    // skip if no channel id available
+                    if (!XmlFind(resp, "response.level0.channel-search.channels.channels.level4.id", i, out id))
+                        continue;
+
+                    directoryId = id;
+                    return true;
+                }
+            }
+
+            directoryId = String.Empty;
+            return false;
+        }
+
+        // private static readonly string m_vivoxChannelById = "http://{0}/api2/viv_chan_mod.php?mode={1}&chan_id={2}&auth_token={3}";
+
+        // private XmlElement VivoxGetChannelById(string parent, string channelid)
+        // {
+        //     string requrl = String.Format(m_vivoxChannelById, m_vivoxServer, "get", channelid, m_authToken);
+
+        //     if (parent != null && parent != String.Empty)
+        //         return VivoxGetChild(parent, channelid);
+        //     else
+        //         return VivoxCall(requrl, true);
+        // }
+
+        private static readonly string m_vivoxChannelDel = "http://{0}/api2/viv_chan_mod.php?mode={1}&chan_id={2}&auth_token={3}";
+
+        /// <summary>
+        /// Delete a channel.
+        /// Once again, there a multitude of options possible. In the simplest case 
+        /// we specify only the name and get a non-persistent cannel in return. Non
+        /// persistent means that the channel gets deleted if no-one uses it for
+        /// 5 hours. To accomodate future requirements, it may be a good idea to
+        /// initially create channels under the umbrella of a parent ID based upon
+        /// the region name. That way we have a context for side channels, if those
+        /// are required in a later phase.
+        /// In this case the call handles parent and description as optional values.
+        /// </summary>
+        private XmlElement VivoxDeleteChannel(string parent, string channelid)
+        {
+            string requrl = String.Format(m_vivoxChannelDel, m_vivoxServer, "delete", channelid, m_authToken);
+            if (!string.IsNullOrEmpty(parent))
+            {
+                requrl = String.Format("{0}&chan_parent={1}", requrl, parent);
+            }
+            return VivoxCall(requrl, true);
+        }
+
+        private static readonly string m_vivoxChannelSearch = "http://{0}/api2/viv_chan_search.php?&cond_chanparent={1}&auth_token={2}";
+
+        /// <summary>
+        /// Return information on channels in the given directory
+        /// </summary>
+        private XmlElement VivoxListChildren(string channelid)
+        {
+            string requrl = String.Format(m_vivoxChannelSearch, m_vivoxServer, channelid, m_authToken);
+            return VivoxCall(requrl, true);
+        }
+
+        // private XmlElement VivoxGetChild(string parent, string child)
+        // {
+
+        //     XmlElement children = VivoxListChildren(parent);
+        //     string count;
+
+        //    if (XmlFind(children, "response.level0.channel-search.count", out count))
+        //     {
+        //         int cnum = Convert.ToInt32(count);
+        //         for (int i = 0; i < cnum; i++)
+        //         {
+        //             string name;
+        //             string id;
+        //             if (XmlFind(children, "response.level0.channel-search.channels.channels.level4.name", i, out name))
+        //             {
+        //                 if (name == child)
+        //                 {
+        //                    if (XmlFind(children, "response.level0.channel-search.channels.channels.level4.id", i, out id))
+        //                     {
+        //                         return VivoxGetChannelById(null, id);
+        //                     }
+        //                 }
+        //             } 
+        //         }
+        //     }
+
+        //     // One we *know* does not exist.
+        //     return VivoxGetChannel(null, Guid.NewGuid().ToString());
+
+        // }
+   
+        /// <summary>
+        /// This method handles the WEB side of making a request over the
+        /// Vivox interface. The returned values are tansferred to a has
+        /// table which is returned as the result.
+        /// The outcome of the call can be determined by examining the 
+        /// status value in the hash table.
+        /// </summary>
+        private XmlElement VivoxCall(string requrl, bool admin)
+        {
+
+            XmlDocument doc = null;
+
+            // If this is an admin call, and admin is not connected,
+            // and the admin id cannot be connected, then fail.
+            if (admin && !m_adminConnected && !DoAdminLogin())
+                return null;
+
+            doc = new XmlDocument();
+
+            // Let's serialize all calls to Vivox. Most of these are driven by
+            // the clients (CAPs), when the user arrives at the region. We don't 
+            // want to issue many simultaneous http requests to Vivox, because mono
+            // doesn't like that
+            lock (m_Lock)
+            {
+                try
+                {
+                    // Otherwise prepare the request
+                    m_log.DebugFormat("[VivoxVoice] Sending request <{0}>", requrl);
+
+                    HttpWebRequest req = (HttpWebRequest)WebRequest.Create(requrl);
+
+                    // We are sending just parameters, no content
+                    req.ContentLength = 0;
+
+                    // Send request and retrieve the response
+                    using (HttpWebResponse rsp = (HttpWebResponse)req.GetResponse())
+                    using (Stream s = rsp.GetResponseStream())
+                    using (XmlTextReader rdr = new XmlTextReader(s))
+                        doc.Load(rdr);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("[VivoxVoice] Error in admin call : {0}", e.Message);
+                }
+            }
+
+            // If we're debugging server responses, dump the whole
+            // load now
+            if (m_dumpXml) XmlScanl(doc.DocumentElement,0);
+
+            return doc.DocumentElement;
+        }
+
+        /// <summary>
+        /// Just say if it worked.
+        /// </summary>
+        private bool IsOK(XmlElement resp)
+        {
+            string status;
+            XmlFind(resp, "response.level0.status", out status);
+            return (status == "OK");
+        }
+
+        /// <summary>
+        /// Login has been factored in this way because it gets called
+        /// from several places in the module, and we want it to work 
+        /// the same way each time.
+        /// </summary>
+        private bool DoAdminLogin()
+        {
+            m_log.Debug("[VivoxVoice] Establishing admin connection");
+
+            lock (vlock)
+            {
+                if (!m_adminConnected)
+                {
+                    string status = "Unknown";
+                    XmlElement resp = null;
+
+                    resp = VivoxLogin(m_vivoxAdminUser, m_vivoxAdminPassword);
+ 
+                    if (XmlFind(resp, "response.level0.body.status", out status)) 
+                    {
+                        if (status == "Ok")
+                        {
+                            m_log.Info("[VivoxVoice] Admin connection established");
+                            if (XmlFind(resp, "response.level0.body.auth_token", out m_authToken))
+                            {
+                                if (m_dumpXml) m_log.DebugFormat("[VivoxVoice] Auth Token <{0}>", 
+                                                            m_authToken);
+                                m_adminConnected = true;
+                            }
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("[VivoxVoice] Admin connection failed, status = {0}",
+                                  status);
+                        }
+                    }
+                }
+            }
+
+            return m_adminConnected;
+        }
+
+        /// <summary>
+        /// The XmlScan routine is provided to aid in the
+        /// reverse engineering of incompletely 
+        /// documented packets returned by the Vivox
+        /// voice server. It is only called if the 
+        /// m_dumpXml switch is set.
+        /// </summary>
+        private void XmlScanl(XmlElement e, int index)
+        {
+            if (e.HasChildNodes)
+            {
+                m_log.DebugFormat("<{0}>".PadLeft(index+5), e.Name);
+                XmlNodeList children = e.ChildNodes;
+                foreach (XmlNode node in children)
+                   switch (node.NodeType)
+                   {
+                        case XmlNodeType.Element :
+                            XmlScanl((XmlElement)node, index+1);
+                            break;
+                        case XmlNodeType.Text :
+                            m_log.DebugFormat("\"{0}\"".PadLeft(index+5), node.Value);
+                            break;
+                        default :
+                            break;
+                   }
+                m_log.DebugFormat("</{0}>".PadLeft(index+6), e.Name);
+            }
+            else
+            {
+                m_log.DebugFormat("<{0}/>".PadLeft(index+6), e.Name);
+            }
+        }
+
+        private static readonly char[] C_POINT = {'.'};
+
+        /// <summary>
+        /// The Find method is passed an element whose
+        /// inner text is scanned in an attempt to match
+        /// the name hierarchy passed in the 'tag' parameter.
+        /// If the whole hierarchy is resolved, the InnerText
+        /// value at that point is returned. Note that this
+        /// may itself be a subhierarchy of the entire
+        /// document. The function returns a boolean indicator
+        /// of the search's success. The search is performed
+        /// by the recursive Search method.
+        /// </summary>
+        private bool XmlFind(XmlElement root, string tag, int nth, out string result)
+        {
+            if (root == null || tag == null || tag == String.Empty)
+            { 
+                result = String.Empty;
+                return false;
+            }
+            return XmlSearch(root,tag.Split(C_POINT),0, ref nth, out result);
+        }
+
+        private bool XmlFind(XmlElement root, string tag, out string result)
+        {
+            int nth = 0;
+            if (root == null || tag == null || tag == String.Empty)
+            { 
+                result = String.Empty;
+                return false;
+            }
+            return XmlSearch(root,tag.Split(C_POINT),0, ref nth, out result);
+        }
+
+        /// <summary>
+        /// XmlSearch is initially called by XmlFind, and then
+        /// recursively called by itself until the document
+        /// supplied to XmlFind is either exhausted or the name hierarchy
+        /// is matched. 
+        ///
+        /// If the hierarchy is matched, the value is returned in
+        /// result, and true returned as the function's
+        /// value. Otherwise the result is set to the empty string and
+        /// false is returned.
+        /// </summary>
+        private bool XmlSearch(XmlElement e, string[] tags, int index, ref int nth, out string result)
+        {
+            if (index == tags.Length || e.Name != tags[index])
+            {
+                result = String.Empty;
+                return false;
+            }
+                
+            if (tags.Length-index == 1)
+            {
+                if (nth == 0)
+                {
+                    result = e.InnerText;
+                    return true;
+                }
+                else
+                {
+                    nth--;
+                    result = String.Empty;
+                    return false;
+                }
+            }
+
+            if (e.HasChildNodes)
+            {
+                XmlNodeList children = e.ChildNodes;
+                foreach (XmlNode node in children)
+                {
+                   switch (node.NodeType)
+                   {
+                        case XmlNodeType.Element :
+                            if (XmlSearch((XmlElement)node, tags, index+1, ref nth, out result))
+                                return true;
+                            break;
+
+                        default :
+                            break;
+                    }
+                }
+            }
+
+            result = String.Empty;
+            return false;
+        }
+    }
+}