Initial update to OpenSim 0.8.2.1 source code.

2 files changed, 467 insertions, 87 deletions

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