mcs/class/System/Test/System.Net/HttpWebRequestTest.cs

   1 //
   2 // HttpWebRequestTest.cs - NUnit Test Cases for System.Net.HttpWebRequest
   3 //
   4 // Authors:
   5 //   Lawrence Pit (loz@cable.a2000.nl)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8 //
   9 // (C) 2003 Martin Willemoes Hansen
  10 // Copyright (c) 2005 Novell, Inc. (http://www.novell.com
  11 //
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.Collections;
  16 using System.IO;
  17 using System.Net;
  18 using System.Net.Sockets;
  19 using System.Security.Cryptography;
  20 using System.Security.Cryptography.X509Certificates;
  21 using System.Text;
  22 using System.Threading;
  23
  24 using Mono.Security.Authenticode;
  25 using Mono.Security.Protocol.Tls;
  26
  27 namespace MonoTests.System.Net
  28 {
  29         [TestFixture]
  30         public class HttpWebRequestTest
  31         {
  32                 [Test]
  33                 [Category("InetAccess")]
  34                 public void Sync ()
  35                 {
  36                         HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
  37                         Assertion.AssertNotNull ("req:If Modified Since: ", req.IfModifiedSince);
  38
  39                         req.UserAgent = "MonoClient v1.0";
  40                         Assertion.AssertEquals ("req Header 1", "User-Agent", req.Headers.GetKey (0));
  41                         Assertion.AssertEquals ("req Header 2", "MonoClient v1.0", req.Headers.Get (0));
  42
  43                         HttpWebResponse res = (HttpWebResponse) req.GetResponse ();
  44                         Assertion.AssertEquals ("res:HttpStatusCode: ", "OK", res.StatusCode.ToString ());
  45                         Assertion.AssertEquals ("res:HttpStatusDescription: ", "OK", res.StatusDescription);
  46
  47                         Assertion.AssertEquals ("res Header 1", "text/html", res.Headers.Get ("Content-Type"));
  48                         Assertion.AssertNotNull ("Last Modified: ", res.LastModified);
  49
  50                         Assertion.AssertEquals ("res:", 0, res.Cookies.Count);
  51
  52                         res.Close ();
  53                 }
  54
  55                 [Test]
  56                 public void AddRange ()
  57                 {
  58                         HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
  59                         req.AddRange (10);
  60                         req.AddRange (50, 90);
  61                         req.AddRange ("bytes", 100);
  62                         req.AddRange ("bytes", 100, 120);
  63                         Assertion.AssertEquals ("#1", "bytes=10-,50-90,100-,100-120", req.Headers ["Range"]);
  64                         try {
  65                                 req.AddRange ("bits", 2000);
  66                                 Assertion.Fail ("#2");
  67                         } catch (InvalidOperationException) {}
  68                 }
  69
  70                 [Test]
  71                 [Category("InetAccess")]
  72                 public void Cookies1 ()
  73                 {
  74                         // The purpose of this test is to ensure that the cookies we get from a request
  75                         // are stored in both, the CookieCollection in HttpWebResponse and the CookieContainer
  76                         // in HttpWebRequest.
  77                         // If this URL stops sending *one* and only one cookie, replace it.
  78                         string url = "http://www.elmundo.es";
  79                         CookieContainer cookies = new CookieContainer ();
  80                         HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  81                         req.KeepAlive = false;
  82                         req.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv; 1.7.6) Gecko/20050317 Firefox/1.0.2";
  83                         req.CookieContainer = cookies;
  84                         Assertion.AssertEquals ("#01", 0, cookies.Count);
  85                         using (HttpWebResponse res = (HttpWebResponse) req.GetResponse()) {
  86                                 CookieCollection coll = req.CookieContainer.GetCookies (new Uri (url));
  87                                 Assertion.AssertEquals ("#02", 1, coll.Count);
  88                                 Assertion.AssertEquals ("#03", 1, res.Cookies.Count);
  89                                 Cookie one = coll [0];
  90                                 Cookie two = res.Cookies [0];
  91                                 Assertion.AssertEquals ("#04", true, object.ReferenceEquals (one, two));
  92                         }
  93                 }
  94
  95                 [Test]
  96                 public void SslClientBlock ()
  97                 {
  98                         // This tests that the write request/initread/write body sequence does not hang
  99                         // when using SSL.
 100                         // If there's a regression for this, the test will hang.
 101                         ServicePointManager.CertificatePolicy = new AcceptAllPolicy ();
 102                         try {
 103                                 SslHttpServer server = new SslHttpServer ();
 104                                 server.Start ();
 105
 106                                 string url = String.Format ("https://{0}:{1}/nothing.html", server.IPAddress, server.Port);
 107                                 HttpWebRequest request = (HttpWebRequest) WebRequest.Create (url);
 108                                 request.Method = "POST";
 109                                 Stream stream = request.GetRequestStream ();
 110                                 byte [] bytes = new byte [100];
 111                                 stream.Write (bytes, 0, bytes.Length);
 112                                 stream.Close ();
 113                                 HttpWebResponse resp = (HttpWebResponse) request.GetResponse ();
 114                                 Assertion.AssertEquals ("StatusCode", 200, (int) resp.StatusCode);
 115                                 StreamReader sr = new StreamReader (resp.GetResponseStream (), Encoding.UTF8);
 116                                 string x = sr.ReadToEnd ();
 117                                 sr.Close ();
 118                                 resp.Close ();
 119                                 server.Stop ();
 120                                 if (server.Error != null)
 121                                         throw server.Error;
 122                         } finally {
 123                                 ServicePointManager.CertificatePolicy = null;
 124                         }
 125                 }
 126
 127                 [Test]
 128                 public void BadServer_ChunkedClose ()
 129                 {
 130                         // The server will send a chunked response without a 'last-chunked' mark
 131                         // and then shutdown the socket for sending.
 132                         BadChunkedServer server = new BadChunkedServer ();
 133                         server.Start ();
 134                         string url = String.Format ("http://{0}:{1}/nothing.html", server.IPAddress, server.Port);
 135                         HttpWebRequest request = (HttpWebRequest) WebRequest.Create (url);
 136                         HttpWebResponse resp = (HttpWebResponse) request.GetResponse ();
 137                         string x = null;
 138                         try {
 139                                 byte [] bytes = new byte [32];
 140                                 // Using StreamReader+UTF8Encoding here fails on MS runtime
 141                                 Stream stream = resp.GetResponseStream ();
 142                                 int nread = stream.Read (bytes, 0, 32);
 143                                 Assertion.AssertEquals ("#01", 16, nread);
 144                                 x = Encoding.ASCII.GetString (bytes, 0, 16);
 145                         } finally {
 146                                 resp.Close ();
 147                                 server.Stop ();
 148                         }
 149
 150                         if (server.Error != null)
 151                                 throw server.Error;
 152
 153                         Assertion.AssertEquals ("1234567890123456", x);
 154                 }
 155
 156                 class BadChunkedServer : HttpServer {
 157                         protected override void Run ()
 158                         {
 159                                 Socket client = sock.Accept ();
 160                                 NetworkStream ns = new NetworkStream (client, true);
 161                                 StreamWriter writer = new StreamWriter (ns, Encoding.ASCII);
 162                                 writer.Write (  "HTTP/1.1 200 OK\r\n" +
 163                                                 "Transfer-Encoding: chunked\r\n" +
 164                                                 "Connection: close\r\n" +
 165                                                 "Content-Type: text/plain; charset=UTF-8\r\n\r\n");
 166
 167                                 // This body lacks a 'last-chunk' (see RFC 2616)
 168                                 writer.Write ("10\r\n1234567890123456\r\n");
 169                                 writer.Flush ();
 170                                 client.Shutdown (SocketShutdown.Send);
 171                                 Thread.Sleep (1000);
 172                                 writer.Close ();
 173                         }
 174                 }
 175
 176                 class AcceptAllPolicy : ICertificatePolicy {
 177                         public bool CheckValidationResult (ServicePoint sp, X509Certificate certificate, WebRequest request, int error)
 178                         {
 179                                 return true;
 180                         }
 181                 }
 182
 183                 abstract class HttpServer
 184                 {
 185                         protected Socket sock;
 186                         protected Exception error;
 187                         protected ManualResetEvent evt;
 188
 189                         public HttpServer ()
 190                         {
 191                                 sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 192                                 sock.Bind (new IPEndPoint (IPAddress.Loopback, 0));
 193                                 sock.Listen (1);
 194                         }
 195
 196                         public void Start ()
 197                         {
 198                                 evt = new ManualResetEvent (false);
 199                                 Thread th = new Thread (new ThreadStart (Run));
 200                                 th.Start ();
 201                         }
 202
 203                         public void Stop ()
 204                         {
 205                                 evt.Set ();
 206                                 sock.Close ();
 207                         }
 208
 209                         public IPAddress IPAddress {
 210                                 get { return ((IPEndPoint) sock.LocalEndPoint).Address; }
 211                         }
 212
 213                         public int Port {
 214                                 get { return ((IPEndPoint) sock.LocalEndPoint).Port; }
 215                         }
 216
 217                         public Exception Error {
 218                                 get { return error; }
 219                         }
 220
 221                         protected abstract void Run ();
 222                 }
 223
 224                 class SslHttpServer : HttpServer {
 225                         X509Certificate _certificate;
 226
 227                         protected override void Run ()
 228                         {
 229                                 try {
 230                                         Socket client = sock.Accept ();
 231                                         NetworkStream ns = new NetworkStream (client, true);
 232                                         SslServerStream s = new SslServerStream (ns, Certificate, false, false);
 233                                         s.PrivateKeyCertSelectionDelegate += new PrivateKeySelectionCallback (GetPrivateKey);
 234
 235                                         StreamReader reader = new StreamReader (s);
 236                                         StreamWriter writer = new StreamWriter (s, Encoding.ASCII);
 237
 238                                         string line;
 239                                         string hello = "<html><body><h1>Hello World!</h1></body></html>";
 240                                         string answer = "HTTP/1.0 200\r\n" +
 241                                                         "Connection: close\r\n" +
 242                                                         "Content-Type: text/html\r\n" +
 243                                                         "Content-Encoding: " + Encoding.ASCII.WebName + "\r\n" +
 244                                                         "Content-Length: " + hello.Length + "\r\n" +
 245                                                         "\r\n" + hello;
 246
 247                                         // Read the headers
 248                                         do {
 249                                                 line = reader.ReadLine ();
 250                                         } while (line != "" && line != null && line.Length > 0);
 251
 252                                         // Now the content. We know it's 100 bytes.
 253                                         // This makes BeginRead in sslclientstream block.
 254                                         char [] cs = new char [100];
 255                                         reader.Read (cs, 0, 100);
 256
 257                                         writer.Write (answer);
 258                                         writer.Flush ();
 259                                         evt.WaitOne (50000, false);
 260                                 } catch (Exception e) {
 261                                         error = e;
 262                                 }
 263                         }
 264
 265                         X509Certificate Certificate {
 266                                 get {
 267                                         if (_certificate == null)
 268                                                 _certificate = new X509Certificate (CertData.Certificate);
 269
 270                                         return _certificate;
 271                                 }
 272                         }
 273
 274                         AsymmetricAlgorithm GetPrivateKey (X509Certificate certificate, string targetHost)
 275                         {
 276                                 PrivateKey key = new PrivateKey (CertData.PrivateKey, null);
 277                                 return key.RSA;
 278                         }
 279                 }
 280
 281                 class CertData {
 282                         public readonly static byte [] Certificate = {
 283                                 48, 130, 1, 191, 48, 130, 1, 40, 160, 3, 2, 1, 2, 2, 16, 36,
 284                                 14, 97, 190, 146, 132, 208, 71, 175, 6, 87, 168, 185, 175, 55, 43, 48,
 285                                 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 4, 5, 0, 48, 18,
 286                                 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103, 111, 110, 122, 97,
 287                                 108, 111, 48, 30, 23, 13, 48, 53, 48, 54, 50, 50, 49, 57, 51, 48,
 288                                 52, 54, 90, 23, 13, 51, 57, 49, 50, 51, 49, 50, 51, 53, 57, 53,
 289                                 57, 90, 48, 18, 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103,
 290                                 111, 110, 122, 97, 108, 111, 48, 129, 158, 48, 13, 6, 9, 42, 134, 72,
 291                                 134, 247, 13, 1, 1, 1, 5, 0, 3, 129, 140, 0, 48, 129, 136, 2,
 292                                 129, 129, 0, 138, 9, 38, 25, 166, 252, 59, 26, 39, 184, 128, 216, 38,
 293                                 73, 41, 86, 30, 228, 160, 205, 41, 135, 115, 223, 44, 62, 42, 198, 178,
 294                                 190, 81, 11, 25, 21, 216, 49, 179, 130, 246, 52, 97, 175, 212, 94, 157,
 295                                 231, 162, 66, 161, 103, 63, 204, 83, 141, 172, 119, 97, 225, 206, 98, 101,
 296                                 210, 106, 2, 206, 81, 90, 173, 47, 41, 199, 209, 241, 177, 177, 96, 207,
 297                                 254, 220, 190, 66, 180, 153, 0, 209, 14, 178, 69, 194, 3, 37, 116, 239,
 298                                 49, 23, 185, 245, 255, 126, 35, 85, 246, 56, 244, 107, 117, 24, 14, 57,
 299                                 9, 111, 147, 189, 220, 142, 57, 104, 153, 193, 205, 19, 14, 22, 157, 16,
 300                                 24, 80, 201, 2, 2, 0, 17, 163, 23, 48, 21, 48, 19, 6, 3, 85,
 301                                 29, 37, 4, 12, 48, 10, 6, 8, 43, 6, 1, 5, 5, 7, 3, 1,
 302                                 48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 4, 5, 0, 3,
 303                                 129, 129, 0, 64, 49, 57, 253, 218, 198, 229, 51, 189, 12, 154, 225, 183,
 304                                 160, 147, 90, 113, 172, 69, 122, 28, 77, 97, 215, 231, 194, 150, 29, 196,
 305                                 65, 95, 218, 99, 142, 111, 79, 205, 109, 76, 32, 92, 220, 76, 88, 53,
 306                                 237, 80, 11, 85, 44, 91, 21, 210, 12, 34, 223, 234, 18, 187, 136, 62,
 307                                 26, 240, 103, 180, 12, 226, 221, 250, 247, 129, 51, 23, 129, 165, 56, 67,
 308                                 43, 83, 244, 110, 207, 24, 253, 195, 16, 46, 80, 113, 80, 18, 2, 254,
 309                                 120, 147, 151, 164, 23, 210, 230, 100, 19, 197, 179, 28, 194, 48, 106, 159,
 310                                 155, 144, 37, 82, 44, 160, 40, 52, 146, 174, 77, 188, 160, 230, 75, 172,
 311                                 123, 3, 254,
 312                         };
 313
 314                         public readonly static byte [] PrivateKey = {
 315                                 30, 241, 181, 176, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
 316                                 0, 0, 0, 0, 84, 2, 0, 0, 7, 2, 0, 0, 0, 36, 0, 0,
 317                                 82, 83, 65, 50, 0, 4, 0, 0, 17, 0, 0, 0, 201, 80, 24, 16,
 318                                 157, 22, 14, 19, 205, 193, 153, 104, 57, 142, 220, 189, 147, 111, 9, 57,
 319                                 14, 24, 117, 107, 244, 56, 246, 85, 35, 126, 255, 245, 185, 23, 49, 239,
 320                                 116, 37, 3, 194, 69, 178, 14, 209, 0, 153, 180, 66, 190, 220, 254, 207,
 321                                 96, 177, 177, 241, 209, 199, 41, 47, 173, 90, 81, 206, 2, 106, 210, 101,
 322                                 98, 206, 225, 97, 119, 172, 141, 83, 204, 63, 103, 161, 66, 162, 231, 157,
 323                                 94, 212, 175, 97, 52, 246, 130, 179, 49, 216, 21, 25, 11, 81, 190, 178,
 324                                 198, 42, 62, 44, 223, 115, 135, 41, 205, 160, 228, 30, 86, 41, 73, 38,
 325                                 216, 128, 184, 39, 26, 59, 252, 166, 25, 38, 9, 138, 175, 88, 190, 223,
 326                                 27, 24, 224, 123, 190, 69, 164, 234, 129, 59, 108, 229, 248, 62, 187, 15,
 327                                 235, 147, 162, 83, 47, 123, 170, 190, 224, 31, 215, 110, 143, 31, 227, 216,
 328                                 85, 88, 154, 83, 207, 229, 41, 28, 237, 116, 181, 17, 37, 141, 224, 185,
 329                                 164, 144, 141, 233, 164, 138, 177, 241, 115, 181, 230, 150, 7, 92, 139, 141,
 330                                 113, 95, 57, 191, 211, 165, 217, 250, 197, 68, 164, 184, 168, 43, 48, 65,
 331                                 177, 237, 173, 144, 148, 221, 62, 189, 147, 63, 216, 188, 206, 103, 226, 171,
 332                                 32, 20, 230, 116, 144, 192, 1, 39, 202, 87, 74, 250, 6, 142, 188, 23,
 333                                 45, 4, 112, 191, 253, 67, 69, 70, 128, 143, 44, 234, 41, 96, 195, 82,
 334                                 202, 35, 158, 149, 240, 151, 23, 25, 166, 179, 85, 144, 58, 120, 149, 229,
 335                                 205, 34, 8, 110, 86, 119, 130, 210, 37, 173, 65, 71, 169, 67, 8, 51,
 336                                 20, 96, 51, 155, 3, 39, 85, 187, 40, 193, 57, 19, 99, 78, 173, 28,
 337                                 129, 154, 108, 175, 8, 138, 237, 71, 27, 148, 129, 35, 47, 57, 101, 237,
 338                                 168, 178, 227, 221, 212, 63, 124, 254, 253, 215, 183, 159, 49, 103, 74, 49,
 339                                 67, 160, 171, 72, 194, 215, 108, 251, 178, 18, 184, 100, 211, 105, 21, 186,
 340                                 39, 66, 218, 154, 72, 222, 90, 237, 179, 251, 51, 224, 212, 56, 251, 6,
 341                                 209, 151, 198, 176, 89, 110, 35, 141, 248, 237, 223, 68, 135, 206, 207, 169,
 342                                 254, 219, 243, 130, 71, 11, 94, 113, 233, 92, 63, 156, 169, 72, 215, 110,
 343                                 95, 94, 191, 50, 59, 89, 187, 59, 183, 99, 161, 146, 233, 245, 219, 80,
 344                                 87, 113, 251, 50, 144, 195, 158, 46, 189, 232, 119, 91, 75, 22, 6, 176,
 345                                 39, 206, 25, 196, 213, 195, 219, 24, 28, 103, 104, 36, 137, 128, 4, 119,
 346                                 163, 40, 126, 87, 18, 86, 128, 243, 213, 101, 2, 237, 78, 64, 160, 55,
 347                                 199, 93, 90, 126, 175, 199, 55, 89, 234, 190, 5, 16, 196, 88, 28, 208,
 348                                 28, 92, 32, 115, 204, 9, 202, 101, 15, 123, 43, 75, 90, 144, 95, 179,
 349                                 102, 249, 57, 150, 204, 99, 147, 203, 16, 63, 81, 244, 226, 237, 82, 204,
 350                                 20, 200, 140, 65, 83, 217, 161, 23, 123, 37, 115, 12, 100, 73, 70, 190,
 351                                 32, 235, 174, 140, 148, 157, 47, 238, 40, 208, 228, 80, 54, 187, 156, 252,
 352                                 253, 230, 231, 156, 138, 125, 96, 79, 3, 27, 143, 55, 146, 169, 165, 61,
 353                                 238, 60, 227, 77, 217, 93, 117, 122, 111, 46, 173, 113,
 354                         };
 355                 }
 356         }
 357 }
 358