mcs/class/System/System.Net/HttpListenerResponse.cs

   1 //
   2 // System.Net.HttpListenerResponse
   3 //
   4 // Author:
   5 //      Gonzalo Paniagua Javier (gonzalo@novell.com)
   6 //
   7 // Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 #if SECURITY_DEP
  30
  31 using System.Globalization;
  32 using System.IO;
  33 using System.Text;
  34 namespace System.Net {
  35         public sealed class HttpListenerResponse : IDisposable
  36         {
  37                 bool disposed;
  38                 Encoding content_encoding;
  39                 long content_length;
  40                 bool cl_set;
  41                 string content_type;
  42                 CookieCollection cookies;
  43                 WebHeaderCollection headers = new WebHeaderCollection ();
  44                 bool keep_alive = true;
  45                 ResponseStream output_stream;
  46                 Version version = HttpVersion.Version11;
  47                 string location;
  48                 int status_code = 200;
  49                 string status_description = "OK";
  50                 bool chunked;
  51                 HttpListenerContext context;
  52
  53                 internal bool HeadersSent;
  54                 internal object headers_lock = new object ();
  55
  56                 bool force_close_chunked;
  57
  58                 internal HttpListenerResponse (HttpListenerContext context)
  59                 {
  60                         this.context = context;
  61                 }
  62
  63                 internal bool ForceCloseChunked {
  64                         get { return force_close_chunked; }
  65                 }
  66
  67                 public Encoding ContentEncoding {
  68                         get {
  69                                 if (content_encoding == null)
  70                                         content_encoding = Encoding.Default;
  71                                 return content_encoding;
  72                         }
  73                         set {
  74                                 if (disposed)
  75                                         throw new ObjectDisposedException (GetType ().ToString ());
  76
  77                                 //TODO: is null ok?
  78                                 if (HeadersSent)
  79                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
  80
  81                                 content_encoding = value;
  82                         }
  83                 }
  84
  85                 public long ContentLength64 {
  86                         get { return content_length; }
  87                         set {
  88                                 if (disposed)
  89                                         throw new ObjectDisposedException (GetType ().ToString ());
  90
  91                                 if (HeadersSent)
  92                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
  93
  94                                 if (value < 0)
  95                                         throw new ArgumentOutOfRangeException ("Must be >= 0", "value");
  96
  97                                 cl_set = true;
  98                                 content_length = value;
  99                         }
 100                 }
 101
 102                 public string ContentType {
 103                         get { return content_type; }
 104                         set {
 105                                 // TODO: is null ok?
 106                                 if (disposed)
 107                                         throw new ObjectDisposedException (GetType ().ToString ());
 108
 109                                 if (HeadersSent)
 110                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 111
 112                                 content_type = value;
 113                         }
 114                 }
 115
 116                 // RFC 2109, 2965 + the netscape specification at http://wp.netscape.com/newsref/std/cookie_spec.html
 117                 public CookieCollection Cookies {
 118                         get {
 119                                 if (cookies == null)
 120                                         cookies = new CookieCollection ();
 121                                 return cookies;
 122                         }
 123                         set { cookies = value; } // null allowed?
 124                 }
 125
 126                 public WebHeaderCollection Headers {
 127                         get { return headers; }
 128                         set {
 129                 /**
 130                  *      "If you attempt to set a Content-Length, Keep-Alive, Transfer-Encoding, or
 131                  *      WWW-Authenticate header using the Headers property, an exception will be
 132                  *      thrown. Use the KeepAlive or ContentLength64 properties to set these headers.
 133                  *      You cannot set the Transfer-Encoding or WWW-Authenticate headers manually."
 134                 */
 135                 // TODO: check if this is marked readonly after headers are sent.
 136                                 headers = value;
 137                         }
 138                 }
 139
 140                 public bool KeepAlive {
 141                         get { return keep_alive; }
 142                         set {
 143                                 if (disposed)
 144                                         throw new ObjectDisposedException (GetType ().ToString ());
 145
 146                                 if (HeadersSent)
 147                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 148
 149                                 keep_alive = value;
 150                         }
 151                 }
 152
 153                 public Stream OutputStream {
 154                         get {
 155                                 if (output_stream == null)
 156                                         output_stream = context.Connection.GetResponseStream ();
 157                                 return output_stream;
 158                         }
 159                 }
 160
 161                 public Version ProtocolVersion {
 162                         get { return version; }
 163                         set {
 164                                 if (disposed)
 165                                         throw new ObjectDisposedException (GetType ().ToString ());
 166
 167                                 if (HeadersSent)
 168                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 169
 170                                 if (value == null)
 171                                         throw new ArgumentNullException ("value");
 172
 173                                 if (value.Major != 1 || (value.Minor != 0 && value.Minor != 1))
 174                                         throw new ArgumentException ("Must be 1.0 or 1.1", "value");
 175
 176                                 if (disposed)
 177                                         throw new ObjectDisposedException (GetType ().ToString ());
 178
 179                                 version = value;
 180                         }
 181                 }
 182
 183                 public string RedirectLocation {
 184                         get { return location; }
 185                         set {
 186                                 if (disposed)
 187                                         throw new ObjectDisposedException (GetType ().ToString ());
 188
 189                                 if (HeadersSent)
 190                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 191
 192                                 location = value;
 193                         }
 194                 }
 195
 196                 public bool SendChunked {
 197                         get { return chunked; }
 198                         set {
 199                                 if (disposed)
 200                                         throw new ObjectDisposedException (GetType ().ToString ());
 201
 202                                 if (HeadersSent)
 203                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 204
 205                                 chunked = value;
 206                         }
 207                 }
 208
 209                 public int StatusCode {
 210                         get { return status_code; }
 211                         set {
 212                                 if (disposed)
 213                                         throw new ObjectDisposedException (GetType ().ToString ());
 214
 215                                 if (HeadersSent)
 216                                         throw new InvalidOperationException ("Cannot be changed after headers are sent.");
 217
 218                                 if (value < 100 || value > 999)
 219                                         throw new ProtocolViolationException ("StatusCode must be between 100 and 999.");
 220                                 status_code = value;
 221                                 status_description = GetStatusDescription (value);
 222                         }
 223                 }
 224
 225                 internal static string GetStatusDescription (int code)
 226                 {
 227                         switch (code){
 228                         case 100: return "Continue";
 229                         case 101: return "Switching Protocols";
 230                         case 102: return "Processing";
 231                         case 200: return "OK";
 232                         case 201: return "Created";
 233                         case 202: return "Accepted";
 234                         case 203: return "Non-Authoritative Information";
 235                         case 204: return "No Content";
 236                         case 205: return "Reset Content";
 237                         case 206: return "Partial Content";
 238                         case 207: return "Multi-Status";
 239                         case 300: return "Multiple Choices";
 240                         case 301: return "Moved Permanently";
 241                         case 302: return "Found";
 242                         case 303: return "See Other";
 243                         case 304: return "Not Modified";
 244                         case 305: return "Use Proxy";
 245                         case 307: return "Temporary Redirect";
 246                         case 400: return "Bad Request";
 247                         case 401: return "Unauthorized";
 248                         case 402: return "Payment Required";
 249                         case 403: return "Forbidden";
 250                         case 404: return "Not Found";
 251                         case 405: return "Method Not Allowed";
 252                         case 406: return "Not Acceptable";
 253                         case 407: return "Proxy Authentication Required";
 254                         case 408: return "Request Timeout";
 255                         case 409: return "Conflict";
 256                         case 410: return "Gone";
 257                         case 411: return "Length Required";
 258                         case 412: return "Precondition Failed";
 259                         case 413: return "Request Entity Too Large";
 260                         case 414: return "Request-Uri Too Long";
 261                         case 415: return "Unsupported Media Type";
 262                         case 416: return "Requested Range Not Satisfiable";
 263                         case 417: return "Expectation Failed";
 264                         case 422: return "Unprocessable Entity";
 265                         case 423: return "Locked";
 266                         case 424: return "Failed Dependency";
 267                         case 500: return "Internal Server Error";
 268                         case 501: return "Not Implemented";
 269                         case 502: return "Bad Gateway";
 270                         case 503: return "Service Unavailable";
 271                         case 504: return "Gateway Timeout";
 272                         case 505: return "Http Version Not Supported";
 273                         case 507: return "Insufficient Storage";
 274                         }
 275                         return "";
 276                 }
 277
 278                 public string StatusDescription {
 279                         get { return status_description; }
 280                         set {
 281                                 status_description = value;
 282                         }
 283                 }
 284
 285                 void IDisposable.Dispose ()
 286                 {
 287                         Close (true); //TODO: Abort or Close?
 288                 }
 289
 290                 public void Abort ()
 291                 {
 292                         if (disposed)
 293                                 return;
 294
 295                         Close (true);
 296                 }
 297
 298                 public void AddHeader (string name, string value)
 299                 {
 300                         if (name == null)
 301                                 throw new ArgumentNullException ("name");
 302
 303                         if (name == "")
 304                                 throw new ArgumentException ("'name' cannot be empty", "name");
 305
 306                         //TODO: check for forbidden headers and invalid characters
 307                         if (value.Length > 65535)
 308                                 throw new ArgumentOutOfRangeException ("value");
 309
 310                         headers.Set (name, value);
 311                 }
 312
 313                 public void AppendCookie (Cookie cookie)
 314                 {
 315                         if (cookie == null)
 316                                 throw new ArgumentNullException ("cookie");
 317
 318                         Cookies.Add (cookie);
 319                 }
 320
 321                 public void AppendHeader (string name, string value)
 322                 {
 323                         if (name == null)
 324                                 throw new ArgumentNullException ("name");
 325
 326                         if (name == "")
 327                                 throw new ArgumentException ("'name' cannot be empty", "name");
 328
 329                         if (value.Length > 65535)
 330                                 throw new ArgumentOutOfRangeException ("value");
 331
 332                         headers.Add (name, value);
 333                 }
 334
 335                 void Close (bool force)
 336                 {
 337                         disposed = true;
 338                         context.Connection.Close (force);
 339                 }
 340
 341                 public void Close ()
 342                 {
 343                         if (disposed)
 344                                 return;
 345
 346                         Close (false);
 347                 }
 348
 349                 public void Close (byte [] responseEntity, bool willBlock)
 350                 {
 351                         if (disposed)
 352                                 return;
 353
 354                         if (responseEntity == null)
 355                                 throw new ArgumentNullException ("responseEntity");
 356
 357                         //TODO: if willBlock -> BeginWrite + Close ?
 358                         ContentLength64 = responseEntity.Length;
 359                         OutputStream.Write (responseEntity, 0, (int) content_length);
 360                         Close (false);
 361                 }
 362
 363                 public void CopyFrom (HttpListenerResponse templateResponse)
 364                 {
 365                         headers.Clear ();
 366                         headers.Add (templateResponse.headers);
 367                         content_length = templateResponse.content_length;
 368                         status_code = templateResponse.status_code;
 369                         status_description = templateResponse.status_description;
 370                         keep_alive = templateResponse.keep_alive;
 371                         version = templateResponse.version;
 372                 }
 373
 374                 public void Redirect (string url)
 375                 {
 376                         StatusCode = 302; // Found
 377                         location = url;
 378                 }
 379
 380                 bool FindCookie (Cookie cookie)
 381                 {
 382                         string name = cookie.Name;
 383                         string domain = cookie.Domain;
 384                         string path = cookie.Path;
 385                         foreach (Cookie c in cookies) {
 386                                 if (name != c.Name)
 387                                         continue;
 388                                 if (domain != c.Domain)
 389                                         continue;
 390                                 if (path == c.Path)
 391                                         return true;
 392                         }
 393
 394                         return false;
 395                 }
 396
 397                 internal void SendHeaders (bool closing, MemoryStream ms)
 398                 {
 399                         Encoding encoding = content_encoding;
 400                         if (encoding == null)
 401                                 encoding = Encoding.Default;
 402
 403                         if (content_type != null) {
 404                                 if (content_encoding != null && content_type.IndexOf ("charset=", StringComparison.Ordinal) == -1) {
 405                                         string enc_name = content_encoding.WebName;
 406                                         headers.SetInternal ("Content-Type", content_type + "; charset=" + enc_name);
 407                                 } else {
 408                                         headers.SetInternal ("Content-Type", content_type);
 409                                 }
 410                         }
 411
 412                         if (headers ["Server"] == null)
 413                                 headers.SetInternal ("Server", "Mono-HTTPAPI/1.0");
 414
 415                         CultureInfo inv = CultureInfo.InvariantCulture;
 416                         if (headers ["Date"] == null)
 417                                 headers.SetInternal ("Date", DateTime.UtcNow.ToString ("r", inv));
 418
 419                         if (!chunked) {
 420                                 if (!cl_set && closing) {
 421                                         cl_set = true;
 422                                         content_length = 0;
 423                                 }
 424
 425                                 if (cl_set)
 426                                         headers.SetInternal ("Content-Length", content_length.ToString (inv));
 427                         }
 428
 429                         Version v = context.Request.ProtocolVersion;
 430                         if (!cl_set && !chunked && v >= HttpVersion.Version11)
 431                                 chunked = true;
 432
 433                         /* Apache forces closing the connection for these status codes:
 434                          *      HttpStatusCode.BadRequest               400
 435                          *      HttpStatusCode.RequestTimeout           408
 436                          *      HttpStatusCode.LengthRequired           411
 437                          *      HttpStatusCode.RequestEntityTooLarge    413
 438                          *      HttpStatusCode.RequestUriTooLong        414
 439                          *      HttpStatusCode.InternalServerError      500
 440                          *      HttpStatusCode.ServiceUnavailable       503
 441                          */
 442                         bool conn_close = (status_code == 400 || status_code == 408 || status_code == 411 ||
 443                                         status_code == 413 || status_code == 414 || status_code == 500 ||
 444                                         status_code == 503);
 445
 446                         if (conn_close == false)
 447                                 conn_close = !context.Request.KeepAlive;
 448
 449                         // They sent both KeepAlive: true and Connection: close!?
 450                         if (!keep_alive || conn_close) {
 451                                 headers.SetInternal ("Connection", "close");
 452                                 conn_close = true;
 453                         }
 454
 455                         if (chunked)
 456                                 headers.SetInternal ("Transfer-Encoding", "chunked");
 457
 458                         int reuses = context.Connection.Reuses;
 459                         if (reuses >= 100) {
 460                                 force_close_chunked = true;
 461                                 if (!conn_close) {
 462                                         headers.SetInternal ("Connection", "close");
 463                                         conn_close = true;
 464                                 }
 465                         }
 466
 467                         if (!conn_close) {
 468                                 headers.SetInternal ("Keep-Alive", String.Format ("timeout=15,max={0}", 100 - reuses));
 469                                 if (context.Request.ProtocolVersion <= HttpVersion.Version10)
 470                                         headers.SetInternal ("Connection", "keep-alive");
 471                         }
 472
 473                         if (location != null)
 474                                 headers.SetInternal ("Location", location);
 475
 476                         if (cookies != null) {
 477                                 foreach (Cookie cookie in cookies)
 478                                         headers.SetInternal ("Set-Cookie", CookieToClientString (cookie));
 479                         }
 480
 481                         StreamWriter writer = new StreamWriter (ms, encoding, 256);
 482                         writer.Write ("HTTP/{0} {1} {2}\r\n", version, status_code, status_description);
 483                         string headers_str = headers.ToStringMultiValue ();
 484                         writer.Write (headers_str);
 485                         writer.Flush ();
 486                         int preamble = (encoding.CodePage == 65001) ? 3 : encoding.GetPreamble ().Length;
 487                         if (output_stream == null)
 488                                 output_stream = context.Connection.GetResponseStream ();
 489
 490                         /* Assumes that the ms was at position 0 */
 491                         ms.Position = preamble;
 492                         HeadersSent = true;
 493                 }
 494
 495                 static string CookieToClientString (Cookie cookie)
 496                 {
 497                         if (cookie.Name.Length == 0)
 498                                 return String.Empty;
 499
 500                         StringBuilder result = new StringBuilder (64);
 501
 502                         if (cookie.Version > 0)
 503                                 result.Append ("Version=").Append (cookie.Version).Append (";");
 504
 505                         result.Append (cookie.Name).Append ("=").Append (cookie.Value);
 506
 507                         if (cookie.Path != null && cookie.Path.Length != 0)
 508                                 result.Append (";Path=").Append (QuotedString (cookie, cookie.Path));
 509
 510                         if (cookie.Domain != null && cookie.Domain.Length != 0)
 511                                 result.Append (";Domain=").Append (QuotedString (cookie, cookie.Domain));
 512
 513                         if (cookie.Port != null && cookie.Port.Length != 0)
 514                                 result.Append (";Port=").Append (cookie.Port);
 515
 516                         return result.ToString ();
 517                 }
 518
 519                 static string QuotedString (Cookie cookie, string value)
 520                 {
 521                         if (cookie.Version == 0 || IsToken (value))
 522                                 return value;
 523                         else
 524                                 return "\"" + value.Replace("\"", "\\\"") + "\"";
 525                 }
 526
 527                 static string tspecials = "()<>@,;:\\\"/[]?={} \t";   // from RFC 2965, 2068
 528
 529             static bool IsToken (string value)
 530                 {
 531                         int len = value.Length;
 532                         for (int i = 0; i < len; i++) {
 533                             char c = value [i];
 534                                 if (c < 0x20 || c >= 0x7f || tspecials.IndexOf (c) != -1)
 535                                         return false;
 536                         }
 537                         return true;
 538                 }
 539
 540                 public void SetCookie (Cookie cookie)
 541                 {
 542                         if (cookie == null)
 543                                 throw new ArgumentNullException ("cookie");
 544
 545                         if (cookies != null) {
 546                                 if (FindCookie (cookie))
 547                                         throw new ArgumentException ("The cookie already exists.");
 548                         } else {
 549                                 cookies = new CookieCollection ();
 550                         }
 551
 552                         cookies.Add (cookie);
 553                 }
 554         }
 555 }
 556 #endif
 557