using NUnit.Framework;
using System;
using System.Collections;
+using System.Collections.Specialized;
+using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
-
+#if !TARGET_JVM
using Mono.Security.Authenticode;
using Mono.Security.Protocol.Tls;
+#endif
namespace MonoTests.System.Net
{
public class HttpWebRequestTest
{
[Test]
- [Category("InetAccess")]
+#if TARGET_JVM
+ [Ignore ("Ignore failures in Sys.Net")]
+#endif
+ public void Proxy_Null ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
+ Assert.IsNotNull (req.Proxy, "#1");
+#if NET_2_0
+ req.Proxy = null;
+ Assert.IsNull (req.Proxy, "#2");
+#else
+ try {
+ req.Proxy = null;
+ Assert.Fail ("#2");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#3");
+ Assert.IsNull (ex.InnerException, "#4");
+ Assert.IsNotNull (ex.Message, "#5");
+ Assert.IsNotNull (ex.ParamName, "#6");
+ Assert.AreEqual ("value", ex.ParamName, "#7");
+ }
+#endif
+ }
+
+ [Test]
+ [Category("InetAccess")]
+#if TARGET_JVM
+ [Ignore ("NMA - wrong cookies number returned")]
+#endif
public void Sync ()
{
HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
Assertion.AssertNotNull ("req:If Modified Since: ", req.IfModifiedSince);
req.UserAgent = "MonoClient v1.0";
- Assertion.AssertEquals ("req Header 1", "User-Agent", req.Headers.GetKey (0));
- Assertion.AssertEquals ("req Header 2", "MonoClient v1.0", req.Headers.Get (0));
+ Assert.AreEqual ("User-Agent", req.Headers.GetKey (0), "#A1");
+ Assert.AreEqual ("MonoClient v1.0", req.Headers.Get (0), "#A2");
HttpWebResponse res = (HttpWebResponse) req.GetResponse ();
- Assertion.AssertEquals ("res:HttpStatusCode: ", "OK", res.StatusCode.ToString ());
- Assertion.AssertEquals ("res:HttpStatusDescription: ", "OK", res.StatusDescription);
-
- Assertion.AssertEquals ("res Header 1", "text/html", res.Headers.Get ("Content-Type"));
- Assertion.AssertNotNull ("Last Modified: ", res.LastModified);
-
- Assertion.AssertEquals ("res:", 0, res.Cookies.Count);
-
+ Assert.AreEqual ("OK", res.StatusCode.ToString (), "#B1");
+ Assert.AreEqual ("OK", res.StatusDescription, "#B2");
+
+ Assert.AreEqual ("text/html; charset=ISO-8859-1", res.Headers.Get ("Content-Type"), "#C1");
+ Assert.IsNotNull (res.LastModified, "#C2");
+ Assert.AreEqual (0, res.Cookies.Count, "#C3");
+
res.Close ();
}
-
+
[Test]
public void AddRange ()
{
} catch (InvalidOperationException) {}
}
+ [Test] // bug #471782
+ public void CloseRequestStreamAfterReadingResponse ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+
+ byte [] data = new byte [128];
+ req.ContentLength = data.Length;
+
+ Stream rs = req.GetRequestStream ();
+ rs.Write (data, 0, data.Length);
+ rs.Flush ();
+
+ HttpWebResponse response = (HttpWebResponse) req.GetResponse ();
+ response.Close ();
+
+ rs.Close ();
+
+ responder.Stop ();
+ }
+ }
+
[Test]
- [Category("InetAccess")]
+ [Category("InetAccess")]
public void Cookies1 ()
{
// The purpose of this test is to ensure that the cookies we get from a request
}
}
+#if !TARGET_JVM //NotWorking
[Test]
public void SslClientBlock ()
{
ServicePointManager.CertificatePolicy = null;
}
}
-
+#endif
[Test]
+#if TARGET_JVM
+ [Category("NotWorking")]
+#endif
public void Missing_ContentEncoding ()
{
ServicePointManager.CertificatePolicy = new AcceptAllPolicy ();
}
[Test]
+#if TARGET_JVM
+ [Category ("NotWorking")]
+#endif
public void BadServer_ChunkedClose ()
{
// The server will send a chunked response without a 'last-chunked' mark
Assertion.AssertEquals ("1234567890123456", x);
}
+ [Test]
+ [Ignore ("This test asserts that our code violates RFC 2616")]
+ public void MethodCase ()
+ {
+ ListDictionary methods = new ListDictionary ();
+#if NET_2_0
+ methods.Add ("post", "POST");
+ methods.Add ("puT", "PUT");
+#else
+ methods.Add ("post", "post");
+ methods.Add ("puT", "puT");
+#endif
+ methods.Add ("POST", "POST");
+ methods.Add ("whatever", "whatever");
+ methods.Add ("PUT", "PUT");
+
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ foreach (DictionaryEntry de in methods) {
+ SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000),
+ new SocketRequestHandler (EchoRequestHandler));
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = (string) de.Key;
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string line = sr.ReadLine ();
+ sr.Close ();
+ Assert.AreEqual (((string) de.Value) + " /test/ HTTP/1.1",
+ line, req.Method);
+ resp.Close ();
+ }
+ responder.Stop ();
+ }
+ }
+
+ [Test]
+ public void BeginGetRequestStream_Body_NotAllowed ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest request;
+
+ request = (HttpWebRequest) WebRequest.Create (url);
+ request.Method = "GET";
+
+ try {
+ request.BeginGetRequestStream (null, null);
+ Assert.Fail ("#A1");
+ } catch (ProtocolViolationException ex) {
+ // Cannot send a content-body with this
+ // verb-type
+ Assert.IsNull (ex.InnerException, "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
+ }
+
+ request = (HttpWebRequest) WebRequest.Create (url);
+ request.Method = "HEAD";
+
+ try {
+ request.BeginGetRequestStream (null, null);
+ Assert.Fail ("#B1");
+ } catch (ProtocolViolationException ex) {
+ // Cannot send a content-body with this
+ // verb-type
+ Assert.IsNull (ex.InnerException, "#B2");
+ Assert.IsNotNull (ex.Message, "#B3");
+ }
+ }
+ }
+
+ [Test] // bug #465613
+ public void BeginGetRequestStream_NoBuffering ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8002);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8002/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req;
+ Stream rs;
+ IAsyncResult ar;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = false;
+ req.AllowWriteStreamBuffering = false;
+
+ ar = req.BeginGetRequestStream (null, null);
+ rs = req.EndGetRequestStream (ar);
+ rs.Close ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = true;
+ req.AllowWriteStreamBuffering = false;
+
+ try {
+ req.BeginGetRequestStream (null, null);
+ Assert.Fail ("#A1");
+ } catch (ProtocolViolationException ex) {
+ // When performing a write operation with
+ // AllowWriteStreamBuffering set to false,
+ // you must either set ContentLength to a
+ // non-negative number or set SendChunked
+ // to true
+ Assert.IsNull (ex.InnerException, "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
+ }
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = true;
+ req.AllowWriteStreamBuffering = false;
+ req.ContentLength = 0;
+
+ ar = req.BeginGetRequestStream (null, null);
+ rs = req.EndGetRequestStream (ar);
+ rs.Close ();
+ }
+ }
+
+ [Test] // bug #508027
+ public void BeginGetResponse ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8003);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8003/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = false;
+ req.AllowWriteStreamBuffering = false;
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = true;
+ req.KeepAlive = false;
+ req.AllowWriteStreamBuffering = false;
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.ContentLength = 5;
+ req.SendChunked = false;
+ req.KeepAlive = false;
+ req.AllowWriteStreamBuffering = false;
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = true;
+ req.AllowWriteStreamBuffering = false;
+#if NET_2_0
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+#else
+ try {
+ req.BeginGetResponse (null, null);
+ } catch (ProtocolViolationException ex) {
+ // Either ContentLength must be set to a non-negative
+ // number, or SendChunked set to true in order to perform
+ // the write operation when AllowWriteStreamBuffering
+ // is disabled
+ Assert.IsNull (ex.InnerException, "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
+ } finally {
+ req.Abort ();
+ }
+#endif
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = false;
+ req.AllowWriteStreamBuffering = false;
+ req.ContentLength = 5;
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = false;
+ req.KeepAlive = true;
+ req.AllowWriteStreamBuffering = false;
+ req.ContentLength = 5;
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.SendChunked = true;
+#if NET_2_0
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+#else
+ try {
+ req.BeginGetResponse (null, null);
+ Assert.Fail ("#B1");
+ } catch (ProtocolViolationException ex) {
+ // Content-Length cannot be set for a
+ // non-write operation
+ Assert.IsNull (ex.InnerException, "#B2");
+ Assert.IsNotNull (ex.Message, "#B3");
+ } finally {
+ req.Abort ();
+ }
+#endif
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.ContentLength = 5;
+#if NET_2_0
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+#else
+ try {
+ req.BeginGetResponse (null, null);
+ Assert.Fail ("#C1");
+ } catch (ProtocolViolationException ex) {
+ // Content-Length cannot be set for a
+ // non-write operation
+ Assert.IsNull (ex.InnerException, "#C2");
+ Assert.IsNotNull (ex.Message, "#C3");
+ } finally {
+ req.Abort ();
+ }
+#endif
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.ContentLength = 0;
+#if NET_2_0
+ req.BeginGetResponse (null, null);
+ req.Abort ();
+#else
+ try {
+ req.BeginGetResponse (null, null);
+ Assert.Fail ("#D1");
+ } catch (ProtocolViolationException ex) {
+ // Content-Length cannot be set for a
+ // non-write operation
+ Assert.IsNull (ex.InnerException, "#D2");
+ Assert.IsNotNull (ex.Message, "#D3");
+ } finally {
+ req.Abort ();
+ }
+#endif
+ }
+ }
+
+ [Test] // bug #429200
+ public void GetRequestStream ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+
+ Stream rs1 = req.GetRequestStream ();
+ Stream rs2 = req.GetRequestStream ();
+
+ Assert.IsNotNull (rs1, "#1");
+ Assert.AreSame (rs1, rs2, "#2");
+
+ rs1.Close ();
+ }
+ }
+
+ [Test] // bug #510661 and #514996
+ [Category ("NotWorking")]
+ public void GetRequestStream_Close_NotAllBytesWritten ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req;
+ Stream rs;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.ContentLength = 2;
+ rs = req.GetRequestStream ();
+ try {
+ rs.Close ();
+ Assert.Fail ("#A1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
+ Assert.IsNull (ex.Response, "#A4");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#A5");
+
+ // Cannot close stream until all bytes are written
+ Exception inner = ex.InnerException;
+ Assert.IsNotNull (inner, "#A6");
+ Assert.AreEqual (typeof (IOException), inner.GetType (), "#A7");
+ Assert.IsNull (inner.InnerException, "#A8");
+ Assert.IsNotNull (inner.Message, "#A9");
+ }
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.ContentLength = 2;
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x0d);
+ try {
+ rs.Close ();
+ Assert.Fail ("#B1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
+ Assert.IsNotNull (ex.Message, "#B3");
+ Assert.IsNull (ex.Response, "#B4");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#B5");
+
+ // Cannot close stream until all bytes are written
+ Exception inner = ex.InnerException;
+ Assert.IsNotNull (inner, "#B6");
+ Assert.AreEqual (typeof (IOException), inner.GetType (), "#B7");
+ Assert.IsNull (inner.InnerException, "#B8");
+ Assert.IsNotNull (inner.Message, "#B9");
+ }
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.ContentLength = 2;
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x0d);
+ rs.WriteByte (0x0d);
+ rs.Close ();
+ }
+ }
+
+ [Test] // bug #510642
+ [Category ("NotWorking")]
+ public void GetRequestStream_Write_Overflow ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8001);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8001/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.ProtocolVersion = HttpVersion.Version11;
+ req.Method = "POST";
+ req.Timeout = 200;
+ req.ReadWriteTimeout = 100;
+ req.ContentLength = 2;
+
+ Stream rs = req.GetRequestStream ();
+
+ byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d };
+ try {
+ rs.Write (buffer, 0, 3);
+ Assert.Fail ("#1");
+ } catch (ProtocolViolationException ex) {
+ // Bytes to be written to the stream exceed
+ // Content-Length bytes size specified
+ Assert.IsNull (ex.InnerException, "#2");
+ Assert.IsNotNull (ex.Message, "#3");
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ [Ignore ("This test asserts that our code violates RFC 2616")]
+ public void GetRequestStream_Body_NotAllowed ()
+ {
+ string [] methods = new string [] { "GET", "HEAD", "CONNECT",
+ "get", "HeAd", "ConNect" };
+
+ foreach (string method in methods) {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (
+ "http://localhost:8000");
+ req.Method = method;
+ try {
+ req.GetRequestStream ();
+ Assert.Fail ("#1:" + method);
+ } catch (ProtocolViolationException ex) {
+ Assert.AreEqual (typeof (ProtocolViolationException), ex.GetType (), "#2:" + method);
+ Assert.IsNull (ex.InnerException, "#3:" + method);
+ Assert.IsNotNull (ex.Message, "#4:" + method);
+ }
+ }
+ }
+
+ [Test]
+#if TARGET_JVM
+ [Category("NotWorking")]
+#endif
+ [Ignore ("This does not timeout any more. That's how MS works when reading small responses")]
+ public void ReadTimeout ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.AllowAutoRedirect = false;
+ req.Timeout = 200;
+ req.ReadWriteTimeout = 100;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ try {
+ Stream s = resp.GetResponseStream ();
+ s.ReadByte ();
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNull (ex.Response, "#4");
+ Assert.AreEqual (WebExceptionStatus.Timeout, ex.Status, "#5");
+ }
+ }
+ responder.Stop ();
+ }
+ }
+
+ [Test] // bug #324300
+#if TARGET_JVM
+ [Category("NotWorking")]
+#endif
+ public void AllowAutoRedirect ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ // allow autoredirect
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#A1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ localEP.ToString () + "/moved/", "#A2");
+ Assert.AreEqual ("GET", resp.Method, "#A3");
+ Assert.AreEqual ("LOOKS OK", body, "#A4");
+ }
+ responder.Stop ();
+ }
+
+ // do not allow autoredirect
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.AllowAutoRedirect = false;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 1000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.Found, "#B1");
+ Assert.AreEqual (url, resp.ResponseUri.ToString (), "#B2");
+ Assert.AreEqual ("POST", resp.Method, "#B3");
+ }
+ responder.Stop ();
+ }
+ }
+
+ [Test] // bug #324347
+ [Category ("NotWorking")]
+ public void InternalServerError ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ // POST
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (InternalErrorHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#A1");
+ } catch (WebException ex) {
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#A5");
+
+ HttpWebResponse webResponse = ex.Response as HttpWebResponse;
+ Assert.IsNotNull (webResponse, "#A6");
+ Assert.AreEqual ("POST", webResponse.Method, "#A7");
+ webResponse.Close ();
+ }
+
+ responder.Stop ();
+ }
+
+ // GET
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (InternalErrorHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#B1");
+ } catch (WebException ex) {
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#B4");
+
+ HttpWebResponse webResponse = ex.Response as HttpWebResponse;
+ Assert.IsNotNull (webResponse, "#B5");
+ Assert.AreEqual ("GET", webResponse.Method, "#B6");
+ webResponse.Close ();
+ }
+
+ responder.Stop ();
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #B3 fails; we get a SocketException: An existing connection was forcibly closed by the remote host
+ public void NoContentLength ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ // POST
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (NoContentLengthHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#A1");
+ } catch (WebException ex) {
+#if NET_2_0
+ // The underlying connection was closed:
+ // An unexpected error occurred on a
+ // receive
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
+ Assert.IsNotNull (ex.InnerException, "#A3");
+ Assert.AreEqual (WebExceptionStatus.ReceiveFailure, ex.Status, "#A4");
+ Assert.AreEqual (typeof (IOException), ex.InnerException.GetType (), "#A5");
+
+ // Unable to read data from the transport connection:
+ // A connection attempt failed because the connected party
+ // did not properly respond after a period of time, or
+ // established connection failed because connected host has
+ // failed to respond
+ IOException ioe = (IOException) ex.InnerException;
+ Assert.IsNotNull (ioe.InnerException, "#A6");
+ Assert.IsNotNull (ioe.Message, "#A7");
+ Assert.AreEqual (typeof (SocketException), ioe.InnerException.GetType (), "#A8");
+
+ // An existing connection was forcibly
+ // closed by the remote host
+ SocketException soe = (SocketException) ioe.InnerException;
+ Assert.IsNull (soe.InnerException, "#A9");
+ Assert.IsNotNull (soe.Message, "#A10");
+
+ HttpWebResponse webResponse = ex.Response as HttpWebResponse;
+ Assert.IsNull (webResponse, "#A11");
+#else
+ // The remote server returned an error:
+ // (500) Internal Server Error
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#A4");
+
+ HttpWebResponse webResponse = ex.Response as HttpWebResponse;
+ Assert.IsNotNull (webResponse, "#A5");
+ Assert.AreEqual ("POST", webResponse.Method, "#A6");
+ webResponse.Close ();
+#endif
+ }
+
+ responder.Stop ();
+ }
+
+ // GET
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (NoContentLengthHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#B1");
+ } catch (WebException ex) {
+ // The remote server returned an error:
+ // (500) Internal Server Error
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#B4");
+
+ HttpWebResponse webResponse = ex.Response as HttpWebResponse;
+ Assert.IsNotNull (webResponse, "#B5");
+ Assert.AreEqual ("GET", webResponse.Method, "#B6");
+ webResponse.Close ();
+ }
+
+ responder.Stop ();
+ }
+ }
+
+ [Test] // bug #513087
+ public void NonStandardVerb ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/moved/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (VerbEchoHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "WhatEver";
+ req.KeepAlive = false;
+ req.Timeout = 20000;
+ req.ReadWriteTimeout = 20000;
+
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ ep.ToString () + "/moved/", "#2");
+ Assert.AreEqual ("WhatEver", resp.Method, "#3");
+ Assert.AreEqual ("WhatEver", body, "#4");
+ }
+
+ responder.Stop ();
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")] // Assert #2 fails
+ public void NotModiedSince ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+ string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (NotModifiedSinceHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "GET";
+ req.KeepAlive = false;
+ req.Timeout = 20000;
+ req.ReadWriteTimeout = 20000;
+#if NET_2_0
+ req.Headers.Add (HttpRequestHeader.IfNoneMatch, "898bbr2347056cc2e096afc66e104653");
+#else
+ req.Headers.Add ("If-None-Match", "898bbr2347056cc2e096afc66e104653");
+#endif
+ req.IfModifiedSince = new DateTime (2010, 01, 04);
+
+ DateTime start = DateTime.Now;
+ HttpWebResponse response = null;
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#1");
+ } catch (WebException e) {
+ response = (HttpWebResponse) e.Response;
+ }
+
+ Assert.IsNotNull (response, "#2");
+ using (Stream stream = response.GetResponseStream ()) {
+ byte [] buffer = new byte [4096];
+ int bytesRead = stream.Read (buffer, 0, buffer.Length);
+ Assert.AreEqual (0, bytesRead, "#3");
+ }
+
+ TimeSpan elapsed = DateTime.Now - start;
+ Assert.IsTrue (elapsed.TotalMilliseconds < 2000, "#4");
+
+ responder.Stop ();
+ }
+ }
+
+#if NET_2_0
+ [Test] // bug #324182
+#if TARGET_JVM
+ [Category ("NotWorking")]
+#endif
+ public void Stream_CanTimeout ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ // allow autoredirect
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ Assert.IsTrue (rs.CanTimeout, "#1");
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ Stream os = resp.GetResponseStream ();
+ Assert.IsTrue (os.CanTimeout, "#2");
+ os.Close ();
+ }
+ responder.Stop ();
+ }
+ }
+#endif
+
+ [Test] // bug #353495
+ [Category ("NotWorking")]
+ public void LastModifiedKind ()
+ {
+ const string reqURL = "http://coffeefaq.com/site/node/25";
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (reqURL);
+ HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+ DateTime lastMod = resp.LastModified;
+ string rawLastMod = resp.Headers ["Last-Modified"];
+ resp.Close ();
+ //Assert.AreEqual ("Tue, 15 Jan 2008 08:59:59 GMT", rawLastMod, "#1");
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, lastMod.Kind, "#2");
+#endif
+ req = (HttpWebRequest) WebRequest.Create (reqURL);
+ req.IfModifiedSince = lastMod;
+ try {
+ resp = (HttpWebResponse) req.GetResponse ();
+ resp.Close ();
+ Assert.Fail ("Should result in 304");
+ } catch (WebException ex) {
+ Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#3");
+ Assert.AreEqual (((HttpWebResponse) ex.Response).StatusCode, HttpStatusCode.NotModified, "#4");
+ }
+ }
+
+ static byte [] EchoRequestHandler (Socket socket)
+ {
+ MemoryStream ms = new MemoryStream ();
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ ms.Write (buffer, 0, bytesReceived);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
+ ms.Flush ();
+ ms.Position = 0;
+ StreamReader sr = new StreamReader (ms, Encoding.UTF8);
+ string request = sr.ReadToEnd ();
+
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 200 OK");
+ sw.WriteLine ("Content-Type: text/xml");
+ sw.WriteLine ("Content-Length: " + request.Length.ToString (CultureInfo.InvariantCulture));
+ sw.WriteLine ();
+ sw.Write (request);
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] RedirectRequestHandler (Socket socket)
+ {
+ MemoryStream ms = new MemoryStream ();
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ ms.Write (buffer, 0, bytesReceived);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
+ ms.Flush ();
+ ms.Position = 0;
+ string statusLine = null;
+ using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) {
+ statusLine = sr.ReadLine ();
+ }
+
+ StringWriter sw = new StringWriter ();
+ if (statusLine.StartsWith ("POST /original/")) {
+ sw.WriteLine ("HTTP/1.0 302 Found");
+ sw.WriteLine ("Location: " + "http://" + IPAddress.Loopback.ToString () + ":8764/moved/");
+ sw.WriteLine ();
+ sw.Flush ();
+ } else if (statusLine.StartsWith ("GET /moved/")) {
+ sw.WriteLine ("HTTP/1.0 200 OK");
+ sw.WriteLine ("Content-Type: text/plain");
+ sw.WriteLine ("Content-Length: 8");
+ sw.WriteLine ();
+ sw.Write ("LOOKS OK");
+ sw.Flush ();
+ } else {
+ sw.WriteLine ("HTTP/1.0 500 Too Lazy");
+ sw.WriteLine ();
+ sw.Flush ();
+ }
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] InternalErrorHandler (Socket socket)
+ {
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 500 Too Lazy");
+ sw.WriteLine ("Content-Length: 0");
+ sw.WriteLine ();
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] NoContentLengthHandler (Socket socket)
+ {
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 500 Too Lazy");
+ sw.WriteLine ();
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] NotModifiedSinceHandler (Socket socket)
+ {
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 304 Not Modified");
+ sw.WriteLine ("Date: Fri, 06 Feb 2009 12:50:26 GMT");
+ sw.WriteLine ("Server: Apache/2.2.6 (Debian) PHP/5.2.6-2+b1 with Suhosin-Patch mod_ssl/2.2.6 OpenSSL/0.9.8g");
+ sw.WriteLine ("Not-Modified-Since: Sun, 08 Feb 2009 08:49:26 GMT");
+ sw.WriteLine ("ETag: 898bbr2347056cc2e096afc66e104653");
+ sw.WriteLine ("Connection: close");
+ sw.WriteLine ();
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] VerbEchoHandler (Socket socket)
+ {
+ MemoryStream ms = new MemoryStream ();
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ ms.Write (buffer, 0, bytesReceived);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
+ ms.Flush ();
+ ms.Position = 0;
+ string statusLine = null;
+ using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) {
+ statusLine = sr.ReadLine ();
+ }
+
+ string verb = "DEFAULT";
+ if (statusLine != null) {
+ string [] parts = statusLine.Split (' ');
+ if (parts.Length > 0)
+ verb = parts [0];
+ }
+
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 200 OK");
+ sw.WriteLine ("Content-Type: text/plain");
+ sw.WriteLine ("Content-Length: " + verb.Length);
+ sw.WriteLine ();
+ sw.Write (verb);
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ [Test]
+ public void NtlmAuthentication ()
+ {
+ NtlmServer server = new NtlmServer ();
+ server.Start ();
+
+ string url = String.Format ("http://{0}:{1}/nothing.html", server.IPAddress, server.Port);
+ HttpWebRequest request = (HttpWebRequest) WebRequest.Create (url);
+ request.Timeout = 5000;
+ request.Credentials = new NetworkCredential ("user", "password", "domain");
+ HttpWebResponse resp = (HttpWebResponse) request.GetResponse ();
+ string res = null;
+ using (StreamReader reader = new StreamReader (resp.GetResponseStream ())) {
+ res = reader.ReadToEnd ();
+ }
+ resp.Close ();
+ server.Stop ();
+ Assert.AreEqual ("OK", res);
+ }
+
+ class NtlmServer : HttpServer {
+ public string Where = "";
+ protected override void Run ()
+ {
+ Where = "before accept";
+ Socket client = sock.Accept ();
+ NetworkStream ns = new NetworkStream (client, false);
+ StreamReader reader = new StreamReader (ns, Encoding.ASCII);
+ string line;
+ Where = "first read";
+ while ((line = reader.ReadLine ()) != null) {
+ if (line.Trim () == String.Empty) {
+ break;
+ }
+ }
+ Where = "first write";
+ StreamWriter writer = new StreamWriter (ns, Encoding.ASCII);
+ writer.Write ( "HTTP/1.1 401 Unauthorized\r\n" +
+ "WWW-Authenticate: NTLM\r\n" +
+ "Content-Length: 5\r\n\r\nWRONG");
+
+ writer.Flush ();
+ Where = "second read";
+ while ((line = reader.ReadLine ()) != null) {
+ if (line.Trim () == String.Empty) {
+ break;
+ }
+ }
+ Where = "second write";
+ writer.Write ( "HTTP/1.1 401 Unauthorized\r\n" +
+ "WWW-Authenticate: NTLM TlRMTVNTUAACAAAAAAAAADgAAAABggAC8GDhqIONH3sAAAAAAAAAAAAAAAA4AAAABQLODgAAAA8=\r\n" +
+ "Content-Length: 5\r\n\r\nWRONG");
+ writer.Flush ();
+
+ Where = "third read";
+ while ((line = reader.ReadLine ()) != null) {
+ if (line.Trim () == String.Empty) {
+ break;
+ }
+ }
+ Where = "third write";
+ writer.Write ( "HTTP/1.1 200 OK\r\n" +
+ "Keep-Alive: true\r\n" +
+ "Content-Length: 2\r\n\r\nOK");
+ writer.Flush ();
+ Thread.Sleep (1000);
+ writer.Close ();
+ reader.Close ();
+ client.Close ();
+ }
+ }
+
class BadChunkedServer : HttpServer {
protected override void Run ()
{
protected abstract void Run ();
}
+#if !TARGET_JVM
class SslHttpServer : HttpServer {
X509Certificate _certificate;
238, 60, 227, 77, 217, 93, 117, 122, 111, 46, 173, 113,
};
}
+#endif
}
}
-
projects / mono.git / blobdiff