Initial update to OpenSim 0.8.2.1 source code.

11 files changed, 628 insertions, 179 deletions

diff --git a/OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs b/OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs
index 9d77b19..a686a4d 100644
--- a/OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs
@@ -514,9 +514,11 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                         scene.RegionInfo.RegionID.ToString());
                 asset.Data = assetData;
                 asset.Description = String.Format("URL image : {0}", Url);
-                asset.Local = false;
+                if (asset.Description.Length > 128)
+                    asset.Description = asset.Description.Substring(0, 128);
+                asset.Local = true;     // dynamic images aren't saved in the assets server
                 asset.Temporary = ((Disp & DISP_TEMP) != 0);
-                scene.AssetService.Store(asset);
+                scene.AssetService.Store(asset);    // this will only save the asset in the local asset cache
 
                 IJ2KDecoder cacheLayerDecode = scene.RequestModuleInterface<IJ2KDecoder>();
                 if (cacheLayerDecode != null)
diff --git a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
index d943b20..4e7ad75 100644
--- a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
@@ -213,8 +213,8 @@ namespace OpenSim.Region.CoreModules.Scripting.EmailModules
                     if (part != null)
                     {
                         ObjectRegionName = s.RegionInfo.RegionName;
-                        uint localX = (s.RegionInfo.RegionLocX * (int)Constants.RegionSize);
-                        uint localY = (s.RegionInfo.RegionLocY * (int)Constants.RegionSize);
+                        uint localX = s.RegionInfo.WorldLocX;
+                        uint localY = s.RegionInfo.WorldLocY;
                         ObjectRegionName = ObjectRegionName + " (" + localX + ", " + localY + ")";
                         return part;
                     }
diff --git a/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs b/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
index a676971..9dfeb96 100644
--- a/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
+++ b/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
@@ -28,12 +28,15 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Net.Mail;
 using System.Net.Security;
+using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Security.Cryptography.X509Certificates;
+using log4net;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
@@ -91,10 +94,13 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "HttpRequestModule")]
     public class HttpRequestModule : ISharedRegionModule, IHttpRequestModule
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         private object HttpListLock = new object();
         private int httpTimeout = 30000;
         private string m_name = "HttpScriptRequests";
 
+        private OutboundUrlFilter m_outboundUrlFilter;
         private string m_proxyurl = "";
         private string m_proxyexcepts = "";
 
@@ -132,10 +138,12 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
                     return false;
 
                 // Check for policy and execute it if defined
+#pragma warning disable 0618
                 if (ServicePointManager.CertificatePolicy != null)
                 {
                     return ServicePointManager.CertificatePolicy.CheckValidationResult (sp, certificate, Request, 0);
                 }
+#pragma warning restore 0618
 
                 return true;
             }
@@ -153,7 +161,9 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
             return UUID.Zero;
         }
 
-        public UUID StartHttpRequest(uint localID, UUID itemID, string url, List<string> parameters, Dictionary<string, string> headers, string body)
+        public UUID StartHttpRequest(
+            uint localID, UUID itemID, string url, List<string> parameters, Dictionary<string, string> headers, string body,
+            out HttpInitialRequestStatus status)
         {
             UUID reqID = UUID.Random();
             HttpRequestClass htc = new HttpRequestClass();
@@ -187,10 +197,50 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
                         case (int)HttpRequestConstants.HTTP_VERIFY_CERT:
                             htc.HttpVerifyCert = (int.Parse(parms[i + 1]) != 0);
                             break;
+
+                        case (int)HttpRequestConstants.HTTP_VERBOSE_THROTTLE:
+
+                            // TODO implement me
+                            break;
+
+                        case (int)HttpRequestConstants.HTTP_CUSTOM_HEADER:
+                            //Parameters are in pairs and custom header takes
+                            //arguments in pairs so adjust for header marker.
+                            ++i;
+
+                            //Maximum of 8 headers are allowed based on the
+                            //Second Life documentation for llHTTPRequest.
+                            for (int count = 1; count <= 8; ++count)
+                            {
+                                //Not enough parameters remaining for a header?
+                                if (parms.Length - i < 2)
+                                    break;
+
+                                //Have we reached the end of the list of headers?
+                                //End is marked by a string with a single digit.
+                                //We already know we have at least one parameter
+                                //so it is safe to do this check at top of loop.
+                                if (Char.IsDigit(parms[i][0]))
+                                    break;
+
+                                if (htc.HttpCustomHeaders == null)
+                                    htc.HttpCustomHeaders = new List<string>();
+
+                                htc.HttpCustomHeaders.Add(parms[i]);
+                                htc.HttpCustomHeaders.Add(parms[i+1]);
+
+                                i += 2;
+                            }
+                            break;
+
+                        case (int)HttpRequestConstants.HTTP_PRAGMA_NO_CACHE:
+                            htc.HttpPragmaNoCache = (int.Parse(parms[i + 1]) != 0);
+                            break;
                     }
                 }
             }
-
+                        
+            htc.RequestModule = this;
             htc.LocalID = localID;
             htc.ItemID = itemID;
             htc.Url = url;
@@ -201,28 +251,68 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
             htc.proxyurl = m_proxyurl;
             htc.proxyexcepts = m_proxyexcepts;
 
+            // Same number as default HttpWebRequest.MaximumAutomaticRedirections
+            htc.MaxRedirects = 50;
+
+            if (StartHttpRequest(htc))
+            {
+                status = HttpInitialRequestStatus.OK;
+                return htc.ReqID;
+            }
+            else
+            {
+                status = HttpInitialRequestStatus.DISALLOWED_BY_FILTER;
+                return UUID.Zero;
+            }
+        }
+
+        /// <summary>
+        /// Would a caller to this module be allowed to make a request to the given URL?
+        /// </summary>
+        /// <returns></returns>
+        public bool CheckAllowed(Uri url)
+        {
+            return m_outboundUrlFilter.CheckAllowed(url);
+        }
+
+        public bool StartHttpRequest(HttpRequestClass req)
+        {          
+            if (!CheckAllowed(new Uri(req.Url)))
+                return false;
+
             lock (HttpListLock)
             {
-                m_pendingRequests.Add(reqID, htc);
+                m_pendingRequests.Add(req.ReqID, req);
             }
 
-            htc.Process();
+            req.Process();
 
-            return reqID;
+            return true;
         }
 
-        public void StopHttpRequest(uint m_localID, UUID m_itemID)
+        public void StopHttpRequestsForScript(UUID id)
         {
             if (m_pendingRequests != null)
             {
+                List<UUID> keysToRemove = null;
+
                 lock (HttpListLock)
                 {
-                    HttpRequestClass tmpReq;
-                    if (m_pendingRequests.TryGetValue(m_itemID, out tmpReq))
+                    foreach (HttpRequestClass req in m_pendingRequests.Values)
                     {
-                        tmpReq.Stop();
-                        m_pendingRequests.Remove(m_itemID);
+                        if (req.ItemID == id)
+                        {
+                            req.Stop();
+
+                            if (keysToRemove == null)
+                                keysToRemove = new List<UUID>();
+
+                            keysToRemove.Add(req.ReqID);
+                        }
                     }
+
+                    if (keysToRemove != null)
+                        keysToRemove.ForEach(keyToRemove => m_pendingRequests.Remove(keyToRemove));
                 }
             }
         }
@@ -240,19 +330,13 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         {
             lock (HttpListLock)
             {
-                foreach (UUID luid in m_pendingRequests.Keys)
+                foreach (HttpRequestClass req in m_pendingRequests.Values)
                 {
-                    HttpRequestClass tmpReq;
-
-                    if (m_pendingRequests.TryGetValue(luid, out tmpReq))
-                    {
-                        if (tmpReq.Finished)
-                        {
-                            return tmpReq;
-                        }
-                    }
+                    if (req.Finished)
+                        return req;
                 }
             }
+
             return null;
         }
 
@@ -279,6 +363,8 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
             m_proxyurl = config.Configs["Startup"].GetString("HttpProxy");
             m_proxyexcepts = config.Configs["Startup"].GetString("HttpProxyExceptions");
 
+            m_outboundUrlFilter = new OutboundUrlFilter("Script HTTP request module", config);
+
             m_pendingRequests = new Dictionary<UUID, HttpRequestClass>();
         }
 
@@ -321,16 +407,27 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         #endregion
     }
 
-    public class HttpRequestClass: IServiceRequest
+    public class HttpRequestClass : IServiceRequest
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         // Constants for parameters
         // public const int HTTP_BODY_MAXLENGTH = 2;
         // public const int HTTP_METHOD = 0;
         // public const int HTTP_MIMETYPE = 1;
         // public const int HTTP_VERIFY_CERT = 3;
+        // public const int HTTP_VERBOSE_THROTTLE = 4;
+        // public const int HTTP_CUSTOM_HEADER = 5;
+        // public const int HTTP_PRAGMA_NO_CACHE = 6;
+
+        /// <summary>
+        /// Module that made this request.
+        /// </summary>
+        public HttpRequestModule RequestModule { get; set; }
+
         private bool _finished;
         public bool Finished
-        { 
+        {
             get { return _finished; }
         }
         // public int HttpBodyMaxLen = 2048; // not implemented
@@ -340,11 +437,13 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         public string HttpMIMEType = "text/plain;charset=utf-8";
         public int HttpTimeout;
         public bool HttpVerifyCert = true;
-        private Thread httpThread;
+        //public bool HttpVerboseThrottle = true; // not implemented
+        public List<string> HttpCustomHeaders = null;
+        public bool HttpPragmaNoCache = true;
 
         // Request info
         private UUID _itemID;
-        public UUID ItemID 
+        public UUID ItemID
         {
             get { return _itemID; }
             set { _itemID = value; }
@@ -358,9 +457,20 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         public DateTime Next;
         public string proxyurl;
         public string proxyexcepts;
+
+        /// <summary>
+        /// Number of HTTP redirects that this request has been through.
+        /// </summary>
+        public int Redirects { get; private set; }
+
+        /// <summary>
+        /// Maximum number of HTTP redirects allowed for this request.
+        /// </summary>
+        public int MaxRedirects { get; set; }
+
         public string OutboundBody;
         private UUID _reqID;
-        public UUID ReqID 
+        public UUID ReqID
         {
             get { return _reqID; }
             set { _reqID = value; }
@@ -374,34 +484,19 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
 
         public void Process()
         {
-            httpThread = new Thread(SendRequest);
-            httpThread.Name = "HttpRequestThread";
-            httpThread.Priority = ThreadPriority.BelowNormal;
-            httpThread.IsBackground = true;
-            _finished = false;
-            httpThread.Start();
+            SendRequest();
         }
 
-        /*
-         * TODO: More work on the response codes.  Right now
-         * returning 200 for success or 499 for exception
-         */
-
         public void SendRequest()
         {
-            HttpWebResponse response = null;
-            StringBuilder sb = new StringBuilder();
-            byte[] buf = new byte[8192];
-            string tempString = null;
-            int count = 0;
-
             try
             {
-                Request = (HttpWebRequest) WebRequest.Create(Url);
+                Request = (HttpWebRequest)WebRequest.Create(Url);
+                Request.AllowAutoRedirect = false;               
                 Request.Method = HttpMethod;
                 Request.ContentType = HttpMIMEType;
 
-                if(!HttpVerifyCert)
+                if (!HttpVerifyCert)
                 {
                     // We could hijack Connection Group Name to identify
                     // a desired security exception.  But at the moment we'll use a dummy header instead.
@@ -412,41 +507,57 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
 //                {
 //                    Request.ConnectionGroupName="Verify";
 //                }
-                if (proxyurl != null && proxyurl.Length > 0) 
+
+                if (!HttpPragmaNoCache)
+                {
+                    Request.Headers.Add("Pragma", "no-cache");
+                }
+
+                if (HttpCustomHeaders != null)
+                {
+                    for (int i = 0; i < HttpCustomHeaders.Count; i += 2)
+                        Request.Headers.Add(HttpCustomHeaders[i],
+                                            HttpCustomHeaders[i+1]);
+                }
+
+                if (!string.IsNullOrEmpty(proxyurl))
                 {
-                    if (proxyexcepts != null && proxyexcepts.Length > 0) 
+                    if (!string.IsNullOrEmpty(proxyexcepts))
                     {
                         string[] elist = proxyexcepts.Split(';');
                         Request.Proxy = new WebProxy(proxyurl, true, elist);
-                    } 
-                    else 
+                    }
+                    else
                     {
                         Request.Proxy = new WebProxy(proxyurl, true);
                     }
                 }
 
-                foreach (KeyValuePair<string, string> entry in ResponseHeaders)
-                    if (entry.Key.ToLower().Equals("user-agent"))
-                        Request.UserAgent = entry.Value;
-                    else
-                        Request.Headers[entry.Key] = entry.Value;
+                if (ResponseHeaders != null)
+                {
+                    foreach (KeyValuePair<string, string> entry in ResponseHeaders)
+                        if (entry.Key.ToLower().Equals("user-agent") && Request is HttpWebRequest)
+                            ((HttpWebRequest)Request).UserAgent = entry.Value;
+                        else
+                            Request.Headers[entry.Key] = entry.Value;
+                }
 
                 // Encode outbound data
-                if (OutboundBody.Length > 0) 
+                if (!string.IsNullOrEmpty(OutboundBody))
                 {
                     byte[] data = Util.UTF8.GetBytes(OutboundBody);
 
                     Request.ContentLength = data.Length;
-                    Stream bstream = Request.GetRequestStream();
-                    bstream.Write(data, 0, data.Length);
-                    bstream.Close();
+                    using (Stream bstream = Request.GetRequestStream())
+                        bstream.Write(data, 0, data.Length);
                 }
 
-                Request.Timeout = HttpTimeout;
                 try
                 {
-                    // execute the request
-                    response = (HttpWebResponse) Request.GetResponse();
+                    IAsyncResult result = (IAsyncResult)Request.BeginGetResponse(ResponseCallback, null);
+
+                    ThreadPool.RegisterWaitForSingleObject(
+                        result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), null, HttpTimeout, true);
                 }
                 catch (WebException e)
                 {
@@ -454,57 +565,127 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
                     {
                         throw;
                     }
-                    response = (HttpWebResponse)e.Response;
+
+                    HttpWebResponse response = (HttpWebResponse)e.Response;
+
+                    Status = (int)response.StatusCode;
+                    ResponseBody = response.StatusDescription;
+                    _finished = true;
                 }
+            }
+            catch (Exception e)
+            {
+//                m_log.Debug(
+//                    string.Format("[SCRIPTS HTTP REQUESTS]: Exception on request to {0} for {1}  ", Url, ItemID), e);
 
-                Status = (int)response.StatusCode;
+                Status = (int)OSHttpStatusCode.ClientErrorJoker;
+                ResponseBody = e.Message;
+                _finished = true;
+            }
+        }
 
-                Stream resStream = response.GetResponseStream();
+        private void ResponseCallback(IAsyncResult ar)
+        {
+            HttpWebResponse response = null;
 
-                do
+            try
+            {
+                try
                 {
-                    // fill the buffer with data
-                    count = resStream.Read(buf, 0, buf.Length);
-
-                    // make sure we read some data
-                    if (count != 0)
+                    response = (HttpWebResponse)Request.EndGetResponse(ar);
+                }
+                catch (WebException e)
+                {
+                    if (e.Status != WebExceptionStatus.ProtocolError)
                     {
-                        // translate from bytes to ASCII text
-                        tempString = Util.UTF8.GetString(buf, 0, count);
-
-                        // continue building the string
-                        sb.Append(tempString);
+                        throw;
                     }
-                } while (count > 0); // any more data to read?
 
-                ResponseBody = sb.ToString();
+                    response = (HttpWebResponse)e.Response;
+                }
+
+                Status = (int)response.StatusCode;
+
+                using (Stream stream = response.GetResponseStream())
+                {
+                    StreamReader reader = new StreamReader(stream, Encoding.UTF8);
+                    ResponseBody = reader.ReadToEnd();
+                } 
             }
             catch (Exception e)
             {
                 Status = (int)OSHttpStatusCode.ClientErrorJoker;
                 ResponseBody = e.Message;
 
-                _finished = true;
-                return;
+//                m_log.Debug(
+//                    string.Format("[SCRIPTS HTTP REQUESTS]: Exception on response to {0} for {1}  ", Url, ItemID), e);
             }
             finally
             {
                 if (response != null)
                     response.Close();
+
+                // We need to resubmit 
+                if (
+                    (Status == (int)HttpStatusCode.MovedPermanently
+                        || Status == (int)HttpStatusCode.Found
+                        || Status == (int)HttpStatusCode.SeeOther
+                        || Status == (int)HttpStatusCode.TemporaryRedirect))
+                {
+                    if (Redirects >= MaxRedirects)
+                    {
+                        Status = (int)OSHttpStatusCode.ClientErrorJoker;
+                        ResponseBody = "Number of redirects exceeded max redirects";
+                        _finished = true;
+                    }
+                    else
+                    {
+                        string location = response.Headers["Location"];
+
+                        if (location == null)
+                        {
+                            Status = (int)OSHttpStatusCode.ClientErrorJoker;
+                            ResponseBody = "HTTP redirect code but no location header";
+                            _finished = true;
+                        }
+                        else if (!RequestModule.CheckAllowed(new Uri(location)))
+                        {
+                            Status = (int)OSHttpStatusCode.ClientErrorJoker;
+                            ResponseBody = "URL from HTTP redirect blocked: " + location;
+                            _finished = true;
+                        }
+                        else
+                        {
+                            Status = 0;
+                            Url = response.Headers["Location"];
+                            Redirects++;
+                            ResponseBody = null;
+
+//                            m_log.DebugFormat("Redirecting to [{0}]", Url);
+
+                            Process();
+                        }
+                    }
+                }
+                else
+                {
+                    _finished = true;
+                }
             }
+        }
 
-            _finished = true;
+        private void TimeoutCallback(object state, bool timedOut)
+        {
+            if (timedOut)
+                Request.Abort();
         }
 
         public void Stop()
         {
-            try
-            {
-                httpThread.Abort();
-            }
-            catch (Exception)
-            {
-            }
+//            m_log.DebugFormat("[SCRIPTS HTTP REQUESTS]: Stopping request to {0} for {1}  ", Url, ItemID);
+
+            if (Request != null)
+                Request.Abort();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Scripting/HttpRequest/Tests/ScriptsHttpRequestsTests.cs b/OpenSim/Region/CoreModules/Scripting/HttpRequest/Tests/ScriptsHttpRequestsTests.cs
new file mode 100644
index 0000000..d22487e
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Scripting/HttpRequest/Tests/ScriptsHttpRequestsTests.cs
@@ -0,0 +1,199 @@
+/*
+ * 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.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Scripting.HttpRequest;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.CoreModules.Scripting.HttpRequest.Tests
+{
+    class TestWebRequestCreate : IWebRequestCreate
+    {       
+        public TestWebRequest NextRequest { get; set; }
+
+        public WebRequest Create(Uri uri)
+        {
+//            NextRequest.RequestUri = uri;
+
+            return NextRequest;
+
+//            return new TestWebRequest(new SerializationInfo(typeof(TestWebRequest), new FormatterConverter()), new StreamingContext());
+        }
+    }
+
+    class TestWebRequest : WebRequest
+    {
+        public override string ContentType { get; set; }
+        public override string Method { get; set; }
+
+        public Func<IAsyncResult, WebResponse> OnEndGetResponse { get; set; }
+
+        public TestWebRequest() : base() 
+        {
+//            Console.WriteLine("created");
+        }
+
+//        public TestWebRequest(SerializationInfo serializationInfo, StreamingContext streamingContext) 
+//            : base(serializationInfo, streamingContext) 
+//        {
+//            Console.WriteLine("created");
+//        }
+
+        public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
+        {
+//            Console.WriteLine("bish");
+            TestAsyncResult tasr = new TestAsyncResult();
+            callback(tasr);
+
+            return tasr;
+        }
+
+        public override WebResponse EndGetResponse(IAsyncResult asyncResult)
+        {
+//            Console.WriteLine("bosh");
+            return OnEndGetResponse(asyncResult);
+        }
+    }
+
+    class TestHttpWebResponse : HttpWebResponse
+    {
+        public string Response { get; set; }
+
+#pragma warning disable 0618
+        public TestHttpWebResponse(SerializationInfo serializationInfo, StreamingContext streamingContext) 
+            : base(serializationInfo, streamingContext) {}
+#pragma warning restore 0618
+
+        public override Stream GetResponseStream()
+        {
+            return new MemoryStream(Encoding.UTF8.GetBytes(Response));
+        }
+    }
+
+    class TestAsyncResult : IAsyncResult
+    {
+        WaitHandle m_wh = new ManualResetEvent(true);
+
+        object IAsyncResult.AsyncState 
+        {
+            get {
+                throw new System.NotImplementedException ();
+            }
+        }
+
+        WaitHandle IAsyncResult.AsyncWaitHandle 
+        {
+            get { return m_wh; }
+        }
+
+        bool IAsyncResult.CompletedSynchronously 
+        {
+            get { return false; }
+        }
+
+        bool IAsyncResult.IsCompleted 
+        {
+            get { return true; }
+        }
+    }
+
+    /// <summary>
+    /// Test script http request code.
+    /// </summary>
+    /// <remarks>
+    /// This class uses some very hacky workarounds in order to mock HttpWebResponse which are Mono dependent (though
+    /// alternative code can be written to make this work for Windows).  However, the value of being able to
+    /// regression test this kind of code is very high.
+    /// </remarks>
+    [TestFixture]
+    public class ScriptsHttpRequestsTests : OpenSimTestCase
+    {
+        /// <summary>
+        /// Test what happens when we get a 404 response from a call.
+        /// </summary>
+//        [Test]
+        public void Test404Response()
+        {
+            TestHelpers.InMethod();
+            TestHelpers.EnableLogging();
+
+            if (!Util.IsPlatformMono)
+                Assert.Ignore("Ignoring test since can only currently run on Mono");           
+
+            string rawResponse = "boom";
+
+            TestWebRequestCreate twrc = new TestWebRequestCreate();
+
+            TestWebRequest twr = new TestWebRequest();
+            //twr.OnEndGetResponse += ar => new TestHttpWebResponse(null, new StreamingContext());
+            twr.OnEndGetResponse += ar => 
+            {
+                SerializationInfo si = new SerializationInfo(typeof(HttpWebResponse), new FormatterConverter());
+                StreamingContext sc = new StreamingContext();
+//                WebHeaderCollection headers = new WebHeaderCollection();
+//                si.AddValue("m_HttpResponseHeaders", headers);
+                si.AddValue("uri", new Uri("test://arrg"));
+//                si.AddValue("m_Certificate", null);
+                si.AddValue("version", HttpVersion.Version11);
+                si.AddValue("statusCode", HttpStatusCode.NotFound);
+                si.AddValue("contentLength", 0);
+                si.AddValue("method", "GET");
+                si.AddValue("statusDescription", "Not Found");
+                si.AddValue("contentType", null);
+                si.AddValue("cookieCollection", new CookieCollection());
+
+                TestHttpWebResponse thwr = new TestHttpWebResponse(si, sc);
+                thwr.Response = rawResponse;
+
+                throw new WebException("no message", null, WebExceptionStatus.ProtocolError, thwr);
+            };
+
+            twrc.NextRequest = twr;
+
+            WebRequest.RegisterPrefix("test", twrc);
+            HttpRequestClass hr = new HttpRequestClass();
+            hr.Url = "test://something";
+            hr.SendRequest();
+
+            Assert.That(hr.Status, Is.EqualTo((int)HttpStatusCode.NotFound));
+            Assert.That(hr.ResponseBody, Is.EqualTo(rawResponse));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs b/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
index a654477..99a3122 100644
--- a/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
@@ -117,20 +117,21 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
         /// </summary>
         private Dictionary<string, UrlData> m_UrlMap = new Dictionary<string, UrlData>();
 
-        /// <summary>
-        /// Maximum number of external urls that can be set up by this module.
-        /// </summary>
-        private int m_TotalUrls = 100;
-
-        private uint https_port = 0;
+        private uint m_HttpsPort = 0;
         private IHttpServer m_HttpServer = null;
         private IHttpServer m_HttpsServer = null;
 
-        private string m_ExternalHostNameForLSL = "";
-        public string ExternalHostNameForLSL
-        {
-            get { return m_ExternalHostNameForLSL; } 
-        }
+        public string ExternalHostNameForLSL { get; private set; }
+
+        /// <summary>
+        /// The default maximum number of urls
+        /// </summary>
+        public const int DefaultTotalUrls = 100;
+
+        /// <summary>
+        /// Maximum number of external urls that can be set up by this module.
+        /// </summary>
+        public int TotalUrls { get; set; }
 
         public Type ReplaceableInterface 
         {
@@ -144,16 +145,27 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
 
         public void Initialise(IConfigSource config)
         {
-            m_ExternalHostNameForLSL = config.Configs["Network"].GetString("ExternalHostNameForLSL", System.Environment.MachineName);
-            bool ssl_enabled = config.Configs["Network"].GetBoolean("https_listener",false);
+            IConfig networkConfig = config.Configs["Network"];
+
+            if (networkConfig != null)
+            {
+                ExternalHostNameForLSL = config.Configs["Network"].GetString("ExternalHostNameForLSL", null);
+
+                bool ssl_enabled = config.Configs["Network"].GetBoolean("https_listener", false);
+
+                if (ssl_enabled)
+                    m_HttpsPort = (uint)config.Configs["Network"].GetInt("https_port", (int)m_HttpsPort);
+            }
 
-            if (ssl_enabled)
-                https_port = (uint) config.Configs["Network"].GetInt("https_port",0);
+            if (ExternalHostNameForLSL == null)
+                ExternalHostNameForLSL = System.Environment.MachineName;
 
             IConfig llFunctionsConfig = config.Configs["LL-Functions"];
 
             if (llFunctionsConfig != null)
-                m_TotalUrls = llFunctionsConfig.GetInt("max_external_urls_per_simulator", m_TotalUrls);
+                TotalUrls = llFunctionsConfig.GetInt("max_external_urls_per_simulator", DefaultTotalUrls);
+            else
+                TotalUrls = DefaultTotalUrls;
         }
 
         public void PostInitialise()
@@ -169,9 +181,9 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                 m_HttpServer = MainServer.Instance;
                 //
                 // We can use the https if it is enabled
-                if (https_port > 0)
+                if (m_HttpsPort > 0)
                 {
-                    m_HttpsServer = MainServer.GetHttpServer(https_port);
+                    m_HttpsServer = MainServer.GetHttpServer(m_HttpsPort);
                 }
             }
 
@@ -204,12 +216,12 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
 
             lock (m_UrlMap)
             {
-                if (m_UrlMap.Count >= m_TotalUrls)
+                if (m_UrlMap.Count >= TotalUrls)
                 {
                     engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                     return urlcode;
                 }
-                string url = "http://" + m_ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + "/lslhttp/" + urlcode.ToString() + "/";
+                string url = "http://" + ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + "/lslhttp/" + urlcode.ToString() + "/";
 
                 UrlData urlData = new UrlData();
                 urlData.hostID = host.UUID;
@@ -223,9 +235,10 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                 
                 string uri = "/lslhttp/" + urlcode.ToString() + "/";
                
-                m_HttpServer.AddPollServiceHTTPHandler(
-                    uri,
-                    new PollServiceEventArgs(HttpRequestHandler, HasEvents, GetEvents, NoEvents, urlcode));
+                PollServiceEventArgs args 
+                    = new PollServiceEventArgs(HttpRequestHandler, uri, HasEvents, GetEvents, NoEvents, urlcode, 25000);
+                args.Type = PollServiceEventArgs.EventType.LslHttp;
+                m_HttpServer.AddPollServiceHTTPHandler(uri, args);
 
                 m_log.DebugFormat(
                     "[URL MODULE]: Set up incoming request url {0} for {1} in {2} {3}",
@@ -249,12 +262,12 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
 
             lock (m_UrlMap)
             {
-                if (m_UrlMap.Count >= m_TotalUrls)
+                if (m_UrlMap.Count >= TotalUrls)
                 {
                     engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                     return urlcode;
                 }
-                string url = "https://" + m_ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + "/lslhttps/" + urlcode.ToString() + "/";
+                string url = "https://" + ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + "/lslhttps/" + urlcode.ToString() + "/";
 
                 UrlData urlData = new UrlData();
                 urlData.hostID = host.UUID;
@@ -268,9 +281,10 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                 
                 string uri = "/lslhttps/" + urlcode.ToString() + "/";
                
-                m_HttpsServer.AddPollServiceHTTPHandler(
-                    uri,
-                    new PollServiceEventArgs(HttpRequestHandler, HasEvents, GetEvents, NoEvents, urlcode));
+                PollServiceEventArgs args 
+                    = new PollServiceEventArgs(HttpRequestHandler, uri, HasEvents, GetEvents, NoEvents, urlcode, 25000);
+                args.Type = PollServiceEventArgs.EventType.LslHttp;
+                m_HttpsServer.AddPollServiceHTTPHandler(uri, args);
 
                 m_log.DebugFormat(
                     "[URL MODULE]: Set up incoming secure request url {0} for {1} in {2} {3}",
@@ -328,8 +342,22 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                 if (m_RequestMap.ContainsKey(request))
                 {
                     UrlData urlData = m_RequestMap[request];
+                    string responseBody = body;
+                    if (urlData.requests[request].responseType.Equals("text/plain"))
+                    {
+                        string value;
+                        if (urlData.requests[request].headers.TryGetValue("user-agent", out value))
+                        {
+                            if (value != null && value.IndexOf("MSIE") >= 0)
+                            {
+                                // wrap the html escaped response if the target client is IE
+                                // It ignores "text/plain" if the body is html
+                                responseBody = "<html>" + System.Web.HttpUtility.HtmlEncode(body) + "</html>";
+                            }
+                        }
+                    }
                     urlData.requests[request].responseCode = status;
-                    urlData.requests[request].responseBody = body;
+                    urlData.requests[request].responseBody = responseBody;
                     //urlData.requests[request].ev.Set();
                     urlData.requests[request].requestDone =true;
                 }
@@ -363,7 +391,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
         public int GetFreeUrls()
         {
             lock (m_UrlMap)
-                return m_TotalUrls - m_UrlMap.Count;
+                return TotalUrls - m_UrlMap.Count;
         }
 
         public void ScriptRemoved(UUID itemID)
@@ -490,7 +518,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
             }
         }
 
-        private Hashtable GetEvents(UUID requestID, UUID sessionID, string request)
+        private Hashtable GetEvents(UUID requestID, UUID sessionID)
         {
             Hashtable response;
 
@@ -565,9 +593,9 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                     string url;
 
                     if (is_ssl)
-                        url = "https://" + m_ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + uri_tmp;
+                        url = "https://" + ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + uri_tmp;
                     else
-                        url = "http://" + m_ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + uri_tmp;
+                        url = "http://" + ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + uri_tmp;
 
                     // Avoid a race - the request URL may have been released via llRequestUrl() whilst this
                     // request was being processed.
@@ -642,4 +670,4 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
             ScriptRemoved(itemID);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Scripting/LoadImageURL/LoadImageURLModule.cs b/OpenSim/Region/CoreModules/Scripting/LoadImageURL/LoadImageURLModule.cs
index 65737fa..d45962f 100644
--- a/OpenSim/Region/CoreModules/Scripting/LoadImageURL/LoadImageURLModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/LoadImageURL/LoadImageURLModule.cs
@@ -32,6 +32,7 @@ using System.Net;
 using Nini.Config;
 using OpenMetaverse;
 using OpenMetaverse.Imaging;
+using OpenSim.Framework;
 using OpenSim.Region.CoreModules.Scripting.DynamicTexture;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -50,6 +51,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
         private Scene m_scene;
         private IDynamicTextureManager m_textureManager;
 
+        private OutboundUrlFilter m_outboundUrlFilter;
         private string m_proxyurl = "";
         private string m_proxyexcepts = "";
 
@@ -88,8 +90,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
 
         public bool AsyncConvertUrl(UUID id, string url, string extraParams)
         {
-            MakeHttpRequest(url, id);
-            return true;
+            return MakeHttpRequest(url, id);
         }
 
         public bool AsyncConvertData(UUID id, string bodyData, string extraParams)
@@ -110,6 +111,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
 
         public void Initialise(IConfigSource config)
         {
+            m_outboundUrlFilter = new OutboundUrlFilter("Script dynamic texture image module", config);
             m_proxyurl = config.Configs["Startup"].GetString("HttpProxy");
             m_proxyexcepts = config.Configs["Startup"].GetString("HttpProxyExceptions");
         }
@@ -157,13 +159,17 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
 
         #endregion
 
-        private void MakeHttpRequest(string url, UUID requestID)
+        private bool MakeHttpRequest(string url, UUID requestID)
         {
-            WebRequest request = HttpWebRequest.Create(url);
+            if (!m_outboundUrlFilter.CheckAllowed(new Uri(url)))
+                return false;
+
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+            request.AllowAutoRedirect = false;
             
-            if (m_proxyurl != null && m_proxyurl.Length > 0) 
+            if (!string.IsNullOrEmpty(m_proxyurl)) 
             {
-                if (m_proxyexcepts != null && m_proxyexcepts.Length > 0) 
+                if (!string.IsNullOrEmpty(m_proxyexcepts)) 
                 {
                     string[] elist = m_proxyexcepts.Split(';');
                     request.Proxy = new WebProxy(m_proxyurl, true, elist);
@@ -174,12 +180,14 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
                 }
             }
 
-            RequestState state = new RequestState((HttpWebRequest) request, requestID);
+            RequestState state = new RequestState(request, requestID);
             // IAsyncResult result = request.BeginGetResponse(new AsyncCallback(HttpRequestReturn), state);
             request.BeginGetResponse(new AsyncCallback(HttpRequestReturn), state);
 
             TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1));
             state.TimeOfRequest = (int) t.TotalSeconds;
+
+            return true;
         }
 
         private void HttpRequestReturn(IAsyncResult result)
@@ -195,10 +203,11 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
             Stream stream = null;
             byte[] imageJ2000 = new byte[0];
             Size newSize = new Size(0, 0);
+            HttpWebResponse response = null;
 
             try
             {
-                HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result);
+                response = (HttpWebResponse)request.EndGetResponse(result);
                 if (response != null && response.StatusCode == HttpStatusCode.OK)
                 {
                     stream = response.GetResponseStream();
@@ -262,18 +271,32 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
             finally
             {
                 if (stream != null)
-                {
                     stream.Close();
-                }
-            }
 
-            m_log.DebugFormat("[LOADIMAGEURLMODULE]: Returning {0} bytes of image data for request {1}",
-                                       imageJ2000.Length, state.RequestID);
+                if (response != null)
+                    response.Close();
 
-            m_textureManager.ReturnData(
-                state.RequestID,
-                new OpenSim.Region.CoreModules.Scripting.DynamicTexture.DynamicTexture(
-                    request.RequestUri, null, imageJ2000, newSize, false));
+                if (
+                    response.StatusCode == HttpStatusCode.MovedPermanently
+                        || response.StatusCode == HttpStatusCode.Found
+                        || response.StatusCode == HttpStatusCode.SeeOther
+                        || response.StatusCode == HttpStatusCode.TemporaryRedirect)
+                {
+                    string redirectedUrl = response.Headers["Location"];
+
+                    MakeHttpRequest(redirectedUrl, state.RequestID);
+                }
+                else
+                {
+                    m_log.DebugFormat("[LOADIMAGEURLMODULE]: Returning {0} bytes of image data for request {1}",
+                                      imageJ2000.Length, state.RequestID);
+
+                    m_textureManager.ReturnData(
+                        state.RequestID,
+                        new OpenSim.Region.CoreModules.Scripting.DynamicTexture.DynamicTexture(
+                        request.RequestUri, null, imageJ2000, newSize, false));
+                }
+            }
         }
 
         #region Nested type: RequestState
diff --git a/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs b/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
index f6e1d39..6da2222 100644
--- a/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs
@@ -41,10 +41,11 @@ using System.Linq.Expressions;
 namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ScriptModuleCommsModule")]
-    class ScriptModuleCommsModule : INonSharedRegionModule, IScriptModuleComms
+    public class ScriptModuleCommsModule : INonSharedRegionModule, IScriptModuleComms
     {
         private static readonly ILog m_log =
             LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[MODULE COMMS]";
 
         private Dictionary<string,object> m_constants = new Dictionary<string,object>();
 
@@ -148,7 +149,7 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
             MethodInfo mi = GetMethodInfoFromType(target.GetType(), meth, true);
             if (mi == null)
             {
-                m_log.WarnFormat("[MODULE COMMANDS] Failed to register method {0}", meth);
+                m_log.WarnFormat("{0} Failed to register method {1}", LogHeader, meth);
                 return;
             }
 
@@ -163,9 +164,9 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
 
         public void RegisterScriptInvocation(object target, MethodInfo mi)
         {
-            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, (target is Type) ? ((Type)target).Name : target.GetType().Name);
+//            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, (target is Type) ? ((Type)target).Name : target.GetType().Name);
 
-            Type delegateType;
+            Type delegateType = typeof(void);
             List<Type> typeArgs = mi.GetParameters()
                     .Select(p => p.ParameterType)
                     .ToList();
@@ -176,8 +177,16 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
             }
             else
             {
-                typeArgs.Add(mi.ReturnType);
-                delegateType = Expression.GetFuncType(typeArgs.ToArray());
+                try
+                {
+                    typeArgs.Add(mi.ReturnType);
+                    delegateType = Expression.GetFuncType(typeArgs.ToArray());
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("{0} Failed to create function signature. Most likely more than 5 parameters. Method={1}. Error={2}",
+                        LogHeader, mi.Name, e);
+                }
             }
 
             Delegate fcall;
@@ -323,7 +332,7 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
         /// </summary>
         public void RegisterConstant(string cname, object value)
         {
-            m_log.DebugFormat("[MODULE COMMANDS] register constant <{0}> with value {1}",cname,value.ToString());
+//            m_log.DebugFormat("[MODULE COMMANDS] register constant <{0}> with value {1}",cname,value.ToString());
             lock (m_constants)
             {
                 m_constants.Add(cname,value);
diff --git a/OpenSim/Region/CoreModules/Scripting/VectorRender/Tests/VectorRenderModuleTests.cs b/OpenSim/Region/CoreModules/Scripting/VectorRender/Tests/VectorRenderModuleTests.cs
index 41baccc..ed255bf 100644
--- a/OpenSim/Region/CoreModules/Scripting/VectorRender/Tests/VectorRenderModuleTests.cs
+++ b/OpenSim/Region/CoreModules/Scripting/VectorRender/Tests/VectorRenderModuleTests.cs
@@ -40,7 +40,6 @@ using OpenSim.Region.CoreModules.Scripting.VectorRender;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Scripting.VectorRender.Tests
 {
@@ -152,7 +151,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender.Tests
             TestHelpers.InMethod();
 
             string dtText
-                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://localhost/shouldnotexist.png";
+                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://0.0.0.0/shouldnotexist.png";
 
             SetupScene(false);
             SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
@@ -307,7 +306,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender.Tests
             TestHelpers.InMethod();
 
             string dtText
-                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://localhost/shouldnotexist.png";
+                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://0.0.0.0/shouldnotexist.png";
 
             SetupScene(true);
             SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
diff --git a/OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs b/OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs
index 689e8a7..4cecd85 100644
--- a/OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs
@@ -516,6 +516,9 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                 foreach (string line in GetLines(data, dataDelim))
                 {
                     string nextLine = line.Trim();
+
+//                    m_log.DebugFormat("[VECTOR RENDER MODULE]: Processing line '{0}'", nextLine);
+
                     //replace with switch, or even better, do some proper parsing
                     if (nextLine.StartsWith("MoveTo"))
                     {
@@ -829,6 +832,8 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                     float y = Convert.ToSingle(yVal, CultureInfo.InvariantCulture);
                     PointF point = new PointF(x, y);
                     points[i / 2] = point;
+
+//                    m_log.DebugFormat("[VECTOR RENDER MODULE]: Got point {0}", points[i / 2]);
                 }
             }
         }
@@ -838,13 +843,17 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
             try
             {
                 WebRequest request = HttpWebRequest.Create(url);
-//Ckrinke: Comment out for now as 'str' is unused. Bring it back into play later when it is used.
-//Ckrinke            Stream str = null;
-                HttpWebResponse response = (HttpWebResponse)(request).GetResponse();
-                if (response.StatusCode == HttpStatusCode.OK)
+
+                using (HttpWebResponse response = (HttpWebResponse)(request).GetResponse())
                 {
-                    Bitmap image = new Bitmap(response.GetResponseStream());
-                    return image;
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        using (Stream s = response.GetResponseStream())
+                        {
+                            Bitmap image = new Bitmap(s);
+                            return image;
+                        }
+                    }
                 }
             }
             catch { }
diff --git a/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs b/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
index 2c2c99c..3484387 100644
--- a/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
@@ -379,15 +379,9 @@ namespace OpenSim.Region.CoreModules.Scripting.WorldComm
                 if (sp.IsChildAgent)
                     return;
 
-                // Send message to the avatar.
                 // Channel zero only goes to the avatar
-                // non zero channel messages only go to the attachments
-                if (channel == 0)
-                {
-                    m_scene.SimChatToAgent(target, Utils.StringToBytes(msg),
-                            pos, name, id, false);
-                }
-                else
+                // non zero channel messages only go to the attachments of the avatar.
+                if (channel != 0)
                 {
                     List<SceneObjectGroup> attachments = sp.GetAttachments();
                     if (attachments.Count == 0)
diff --git a/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs b/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
index 385f5ad..87f4277 100644
--- a/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
@@ -36,6 +36,7 @@ using Nini.Config;
 using Nwc.XmlRpc;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Interfaces;
@@ -111,13 +112,15 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             m_rpcPending = new Dictionary<UUID, RPCRequestInfo>();
             m_rpcPendingResponses = new Dictionary<UUID, RPCRequestInfo>();
             m_pendingSRDResponses = new Dictionary<UUID, SendRemoteDataRequest>();
-
-            try
-            {
-                m_remoteDataPort = config.Configs["XMLRPC"].GetInt("XmlRpcPort", m_remoteDataPort);
-            }
-            catch (Exception)
+            if (config.Configs["XMLRPC"] != null)
             {
+                try
+                {
+                    m_remoteDataPort = config.Configs["XMLRPC"].GetInt("XmlRpcPort", m_remoteDataPort);
+                }
+                catch (Exception)
+                {
+                }
             }
         }
 
@@ -654,12 +657,8 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
 
         public void Process()
         {
-            httpThread = new Thread(SendRequest);
-            httpThread.Name = "HttpRequestThread";
-            httpThread.Priority = ThreadPriority.BelowNormal;
-            httpThread.IsBackground = true;
             _finished = false;
-            httpThread.Start();
+            httpThread = WorkManager.StartThread(SendRequest, "HttpRequestThread", ThreadPriority.BelowNormal, true, false);
         }
 
         /*
@@ -675,7 +674,7 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             // if not, use as method name
             UUID parseUID;
             string mName = "llRemoteData";
-            if ((Channel != null) && (Channel != ""))
+            if (!string.IsNullOrEmpty(Channel))
                 if (!UUID.TryParse(Channel, out parseUID))
                     mName = Channel;
                 else
@@ -731,13 +730,19 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             }
 
             _finished = true;
+
+            Watchdog.RemoveThread();
         }
 
         public void Stop()
         {
             try
             {
-                httpThread.Abort();
+                if (httpThread != null)
+                {
+                    Watchdog.AbortThread(httpThread.ManagedThreadId);
+                    httpThread = null;
+                }
             }
             catch (Exception)
             {