mcs/class/System/System.Net/WebHeaderCollection.cs

   1 //
   2 // System.Net.WebHeaderCollection
   3 //
   4 // Authors:
   5 //      Lawrence Pit (loz@cable.a2000.nl)
   6 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 // (c) 2003 Ximian, Inc. (http://www.ximian.com)
   9 //
  10
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections;
  34 using System.Collections.Specialized;
  35 using System.Runtime.InteropServices;
  36 using System.Runtime.Serialization;
  37 using System.Text;
  38
  39 // See RFC 2068 par 4.2 Message Headers
  40
  41 namespace System.Net
  42 {
  43         [Serializable]
  44         [ComVisible(true)]
  45         public class WebHeaderCollection : NameValueCollection, ISerializable
  46         {
  47                 private static readonly Hashtable restricted;
  48                 private static readonly Hashtable multiValue;
  49                 private bool internallyCreated = false;
  50
  51                 // Static Initializer
  52
  53                 static WebHeaderCollection ()
  54                 {
  55                         // the list of restricted header names as defined
  56                         // by the ms.net spec
  57                         restricted = new Hashtable (CaseInsensitiveHashCodeProvider.Default,
  58                                                     CaseInsensitiveComparer.Default);
  59
  60                         restricted.Add ("accept", true);
  61                         restricted.Add ("connection", true);
  62                         restricted.Add ("content-length", true);
  63                         restricted.Add ("content-type", true);
  64                         restricted.Add ("date", true);
  65                         restricted.Add ("expect", true);
  66                         restricted.Add ("host", true);
  67                         restricted.Add ("range", true);
  68                         restricted.Add ("referer", true);
  69                         restricted.Add ("transfer-encoding", true);
  70                         restricted.Add ("user-agent", true);
  71
  72                         // see par 14 of RFC 2068 to see which header names
  73                         // accept multiple values each separated by a comma
  74                         multiValue = new Hashtable (CaseInsensitiveHashCodeProvider.Default,
  75                                                     CaseInsensitiveComparer.Default);
  76
  77                         multiValue.Add ("accept", true);
  78                         multiValue.Add ("accept-charset", true);
  79                         multiValue.Add ("accept-encoding", true);
  80                         multiValue.Add ("accept-language", true);
  81                         multiValue.Add ("accept-ranges", true);
  82                         multiValue.Add ("allow", true);
  83                         multiValue.Add ("authorization", true);
  84                         multiValue.Add ("cache-control", true);
  85                         multiValue.Add ("connection", true);
  86                         multiValue.Add ("content-encoding", true);
  87                         multiValue.Add ("content-language", true);
  88                         multiValue.Add ("expect", true);
  89                         multiValue.Add ("if-match", true);
  90                         multiValue.Add ("if-none-match", true);
  91                         multiValue.Add ("proxy-authenticate", true);
  92                         multiValue.Add ("public", true);
  93                         multiValue.Add ("range", true);
  94                         multiValue.Add ("transfer-encoding", true);
  95                         multiValue.Add ("upgrade", true);
  96                         multiValue.Add ("vary", true);
  97                         multiValue.Add ("via", true);
  98                         multiValue.Add ("warning", true);
  99
 100                         // Extra
 101                         multiValue.Add ("set-cookie", true);
 102                         multiValue.Add ("set-cookie2", true);
 103                 }
 104
 105                 // Constructors
 106
 107                 public WebHeaderCollection () { }
 108
 109                 protected WebHeaderCollection (SerializationInfo serializationInfo,
 110                                                StreamingContext streamingContext)
 111                 {
 112                         // TODO: test for compatibility with ms.net
 113                         int count = serializationInfo.GetInt32("count");
 114                         for (int i = 0; i < count; i++)
 115                                 this.Add (serializationInfo.GetString ("k" + i),
 116                                           serializationInfo.GetString ("v" + i));
 117                 }
 118
 119                 internal WebHeaderCollection (bool internallyCreated)
 120                 {
 121                         this.internallyCreated = internallyCreated;
 122                 }
 123
 124                 // Methods
 125
 126                 public void Add (string header)
 127                 {
 128                         if (header == null)
 129                                 throw new ArgumentNullException ("header");
 130                         int pos = header.IndexOf (':');
 131                         if (pos == -1)
 132                                 throw new ArgumentException ("no colon found", "header");
 133                         this.Add (header.Substring (0, pos),
 134                                   header.Substring (pos + 1));
 135                 }
 136
 137                 public override void Add (string name, string value)
 138                 {
 139                         if (name == null)
 140                                 throw new ArgumentNullException ("name");
 141                         if (internallyCreated && IsRestricted (name))
 142                                 throw new ArgumentException ("restricted header");
 143                         this.AddWithoutValidate (name, value);
 144                 }
 145
 146                 protected void AddWithoutValidate (string headerName, string headerValue)
 147                 {
 148                         if (!IsHeaderName (headerName))
 149                                 throw new ArgumentException ("invalid header name: " + headerName, "headerName");
 150                         if (headerValue == null)
 151                                 headerValue = String.Empty;
 152                         else
 153                                 headerValue = headerValue.Trim ();
 154                         if (!IsHeaderValue (headerValue))
 155                                 throw new ArgumentException ("invalid header value: " + headerValue, "headerValue");
 156                         base.Add (headerName, headerValue);
 157                 }
 158
 159                 public override string [] GetValues (string header)
 160                 {
 161                         if (header == null)
 162                                 throw new ArgumentNullException ("header");
 163
 164                         string [] values = base.GetValues (header);
 165                         if (values == null || values.Length == 0)
 166                                 return null;
 167
 168                         return values;
 169                 }
 170
 171                 public static bool IsRestricted (string headerName)
 172                 {
 173                         if (headerName == null)
 174                                 throw new ArgumentNullException ("headerName");
 175
 176                         if (headerName == "") // MS throw nullexception here!
 177                                 throw new ArgumentException ("empty string", "headerName");
 178
 179                         return restricted.ContainsKey (headerName);
 180                 }
 181
 182                 public override void OnDeserialization (object sender)
 183                 {
 184                 }
 185
 186                 public override void Remove (string name)
 187                 {
 188                         if (name == null)
 189                                 throw new ArgumentNullException ("name");
 190                         if (internallyCreated && IsRestricted (name))
 191                                 throw new ArgumentException ("restricted header");
 192                         base.Remove (name);
 193                 }
 194
 195                 public override void Set (string name, string value)
 196                 {
 197                         if (name == null)
 198                                 throw new ArgumentNullException ("name");
 199                         if (internallyCreated && IsRestricted (name))
 200                                 throw new ArgumentException ("restricted header");
 201                         if (!IsHeaderName (name))
 202                                 throw new ArgumentException ("invalid header name");
 203                         if (value == null)
 204                                 value = String.Empty;
 205                         else
 206                                 value = value.Trim ();
 207                         if (!IsHeaderValue (value))
 208                                 throw new ArgumentException ("invalid header value");
 209                         base.Set (name, value);
 210                 }
 211
 212                 public byte[] ToByteArray ()
 213                 {
 214                         return Encoding.UTF8.GetBytes(ToString ());
 215                 }
 216
 217                 public override string ToString ()
 218                 {
 219                         StringBuilder sb = new StringBuilder();
 220
 221                         int count = base.Count;
 222                         for (int i = 0; i < count ; i++)
 223                                 sb.Append (GetKey (i))
 224                                   .Append (": ")
 225                                   .Append (Get (i))
 226                                   .Append ("\r\n");
 227
 228                         return sb.Append("\r\n").ToString();
 229                 }
 230
 231                 void ISerializable.GetObjectData (SerializationInfo serializationInfo,
 232                                                   StreamingContext streamingContext)
 233                 {
 234                         int count = base.Count;
 235                         serializationInfo.AddValue ("count", count);
 236                         for (int i = 0; i < count ; i++) {
 237                                 serializationInfo.AddValue ("k" + i, GetKey (i));
 238                                 serializationInfo.AddValue ("v" + i, Get (i));
 239                         }
 240                 }
 241
 242                 // Internal Methods
 243
 244                 // With this we don't check for invalid characters in header. See bug #55994.
 245                 internal void SetInternal (string header)
 246                 {
 247                         int pos = header.IndexOf (':');
 248                         if (pos == -1)
 249                                 throw new ArgumentException ("no colon found", "header");
 250
 251                         SetInternal (header.Substring (0, pos), header.Substring (pos + 1));
 252                 }
 253
 254                 internal void SetInternal (string name, string value)
 255                 {
 256                         if (value == null)
 257                                 value = String.Empty;
 258                         else
 259                                 value = value.Trim ();
 260                         if (!IsHeaderValue (value))
 261                                 throw new ArgumentException ("invalid header value");
 262
 263                         if (IsMultiValue (name)) {
 264                                 base.Add (name, value);
 265                         } else {
 266                                 base.Remove (name);
 267                                 base.Set (name, value);
 268                         }
 269                 }
 270
 271                 internal void RemoveAndAdd (string name, string value)
 272                 {
 273                         if (value == null)
 274                                 value = String.Empty;
 275                         else
 276                                 value = value.Trim ();
 277
 278                         base.Remove (name);
 279                         base.Set (name, value);
 280                 }
 281
 282                 internal void RemoveInternal (string name)
 283                 {
 284                         if (name == null)
 285                                 throw new ArgumentNullException ("name");
 286                         base.Remove (name);
 287                 }
 288
 289                 // Private Methods
 290
 291                 internal static bool IsMultiValue (string headerName)
 292                 {
 293                         if (headerName == null || headerName == "")
 294                                 return false;
 295
 296                         return multiValue.ContainsKey (headerName);
 297                 }
 298
 299                 internal static bool IsHeaderValue (string value)
 300                 {
 301                         // TEXT any 8 bit value except CTL's (0-31 and 127)
 302                         //      but including \r\n space and \t
 303                         //      after a newline at least one space or \t must follow
 304                         //      certain header fields allow comments ()
 305
 306                         int len = value.Length;
 307                         for (int i = 0; i < len; i++) {
 308                                 char c = value [i];
 309                                 if (c == 127)
 310                                         return false;
 311                                 if (c < 0x20 && (c != '\r' && c != '\n' && c != '\t'))
 312                                         return false;
 313                                 if (c == '\n' && ++i < len) {
 314                                         c = value [i];
 315                                         if (c != ' ' && c != '\t')
 316                                                 return false;
 317                                 }
 318                         }
 319
 320                         return true;
 321                 }
 322
 323                 internal static bool IsHeaderName (string name)
 324                 {
 325                         // token          = 1*<any CHAR except CTLs or tspecials>
 326                         // tspecials      = "(" | ")" | "<" | ">" | "@"
 327                         //                | "," | ";" | ":" | "\" | <">
 328                         //                | "/" | "[" | "]" | "?" | "="
 329                         //                | "{" | "}" | SP | HT
 330
 331                         if (name == null || name.Length == 0)
 332                                 return false;
 333
 334                         int len = name.Length;
 335                         for (int i = 0; i < len; i++) {
 336                                 char c = name [i];
 337                                 if (c < 0x20 || c >= 0x7f)
 338                                         return false;
 339                         }
 340
 341                         return name.IndexOfAny (tspecials) == -1;
 342                 }
 343
 344                 private static char [] tspecials =
 345                                 new char [] {'(', ')', '<', '>', '@',
 346                                              ',', ';', ':', '\\', '"',
 347                                              '/', '[', ']', '?', '=',
 348                                              '{', '}', ' ', '\t'};
 349
 350         }
 351 }