- public static bool IsRestricted (string headerName)\r
- {\r
- if (headerName == null)\r
- throw new ArgumentNullException ("headerName");\r
-\r
- if (headerName == "") // MS throw nullexception here!\r
- throw new ArgumentException ("empty string", "headerName");\r
-\r
- return restricted.ContainsKey (headerName);\r
- }\r
-\r
- public override void OnDeserialization (object sender)\r
- {\r
- }\r
-\r
- public override void Remove (string name)\r
- {\r
- if (name == null)\r
- throw new ArgumentNullException ("name");\r
- if (internallyCreated && IsRestricted (name))\r
- throw new ArgumentException ("restricted header");\r
- base.Remove (name);\r
- }\r
-\r
- public override void Set (string name, string value)\r
- {\r
- if (name == null)\r
- throw new ArgumentNullException ("name");\r
- if (internallyCreated && IsRestricted (name))\r
- throw new ArgumentException ("restricted header");\r
- if (!IsHeaderName (name))\r
- throw new ArgumentException ("invalid header name");\r
- if (value == null)\r
- value = String.Empty;\r
- else\r
- value = value.Trim ();\r
- if (!IsHeaderValue (value))\r
- throw new ArgumentException ("invalid header value");\r
- base.Set (name, value); \r
- }\r
-\r
- public byte[] ToByteArray ()\r
- {\r
- return Encoding.UTF8.GetBytes(ToString ());\r
- }\r
-\r
- public override string ToString ()\r
- {\r
- StringBuilder sb = new StringBuilder();\r
-\r
- int count = base.Count;\r
- for (int i = 0; i < count ; i++)\r
- sb.Append (GetKey (i))\r
- .Append (": ")\r
- .Append (Get (i))\r
- .Append ("\r\n");\r
- \r
- return sb.Append("\r\n").ToString();\r
- }\r
- \r
- void ISerializable.GetObjectData (SerializationInfo serializationInfo,\r
- StreamingContext streamingContext)\r
- {\r
- int count = base.Count;\r
- serializationInfo.AddValue ("count", count);\r
- for (int i = 0; i < count ; i++) {\r
- serializationInfo.AddValue ("k" + i, GetKey (i));\r
- serializationInfo.AddValue ("v" + i, Get (i));\r
- }\r
- }\r
- \r
- // Internal Methods\r
- \r
- // With this we don't check for invalid characters in header. See bug #55994.\r
- internal void SetInternal (string header)\r
- {\r
- int pos = header.IndexOf (':');\r
- if (pos == -1)\r
- throw new ArgumentException ("no colon found", "header"); \r
-\r
- SetInternal (header.Substring (0, pos), header.Substring (pos + 1));\r
- }\r
-\r
- internal void SetInternal (string name, string value)\r
- {\r
- if (value == null)\r
- value = String.Empty;\r
- else\r
- value = value.Trim ();\r
- if (!IsHeaderValue (value))\r
- throw new ArgumentException ("invalid header value");\r
-\r
+ public static bool IsRestricted (string headerName)
+ {
+ if (headerName == null)
+ throw new ArgumentNullException ("headerName");
+
+ if (headerName == "") // MS throw nullexception here!
+ throw new ArgumentException ("empty string", "headerName");
+
+ if (!IsHeaderName (headerName))
+ throw new ArgumentException ("Invalid character in header");
+
+ return restricted.ContainsKey (headerName);
+ }
+
+ public static bool IsRestricted (string headerName, bool response)
+ {
+ if (String.IsNullOrEmpty (headerName))
+ throw new ArgumentNullException ("headerName");
+
+ if (!IsHeaderName (headerName))
+ throw new ArgumentException ("Invalid character in header");
+
+
+ if (response)
+ return restricted_response.ContainsKey (headerName);
+ return restricted.ContainsKey (headerName);
+ }
+
+ public override void OnDeserialization (object sender)
+ {
+ }
+
+ public override void Remove (string name)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (internallyCreated && IsRestricted (name))
+ throw new ArgumentException ("restricted header");
+ base.Remove (name);
+ }
+
+ public override void Set (string name, string value)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (internallyCreated && IsRestricted (name))
+ throw new ArgumentException ("restricted header");
+ if (!IsHeaderName (name))
+ throw new ArgumentException ("invalid header name");
+ if (value == null)
+ value = String.Empty;
+ else
+ value = value.Trim ();
+ if (!IsHeaderValue (value))
+ throw new ArgumentException ("invalid header value");
+ base.Set (name, value);
+ }
+
+ public byte[] ToByteArray ()
+ {
+ return Encoding.UTF8.GetBytes(ToString ());
+ }
+
+ public override string ToString ()
+ {
+ StringBuilder sb = new StringBuilder();
+
+ int count = base.Count;
+ for (int i = 0; i < count ; i++)
+ sb.Append (GetKey (i))
+ .Append (": ")
+ .Append (Get (i))
+ .Append ("\r\n");
+
+ return sb.Append("\r\n").ToString();
+ }
+#if !TARGET_JVM
+ void ISerializable.GetObjectData (SerializationInfo serializationInfo,
+ StreamingContext streamingContext)
+ {
+ GetObjectData (serializationInfo, streamingContext);
+ }
+#endif
+ public override void GetObjectData (SerializationInfo serializationInfo, StreamingContext streamingContext)
+ {
+ int count = base.Count;
+ serializationInfo.AddValue ("Count", count);
+ for (int i = 0; i < count; i++) {
+ serializationInfo.AddValue (i.ToString (), GetKey (i));
+ serializationInfo.AddValue ((count + i).ToString (), Get (i));
+ }
+ }
+
+ public override string[] AllKeys
+ {
+ get {
+ return(base.AllKeys);
+ }
+ }
+
+ public override int Count
+ {
+ get {
+ return(base.Count);
+ }
+ }
+
+ public override KeysCollection Keys
+ {
+ get {
+ return(base.Keys);
+ }
+ }
+
+ public override string Get (int index)
+ {
+ return(base.Get (index));
+ }
+
+ public override string Get (string name)
+ {
+ return(base.Get (name));
+ }
+
+ public override string GetKey (int index)
+ {
+ return(base.GetKey (index));
+ }
+
+ public void Add (HttpRequestHeader header, string value)
+ {
+ Add (RequestHeaderToString (header), value);
+ }
+
+ public void Remove (HttpRequestHeader header)
+ {
+ Remove (RequestHeaderToString (header));
+ }
+
+ public void Set (HttpRequestHeader header, string value)
+ {
+ Set (RequestHeaderToString (header), value);
+ }
+
+ public void Add (HttpResponseHeader header, string value)
+ {
+ Add (ResponseHeaderToString (header), value);
+ }
+
+ public void Remove (HttpResponseHeader header)
+ {
+ Remove (ResponseHeaderToString (header));
+ }
+
+ public void Set (HttpResponseHeader header, string value)
+ {
+ Set (ResponseHeaderToString (header), value);
+ }
+
+ string RequestHeaderToString (HttpRequestHeader value)
+ {
+ switch (value){
+ case HttpRequestHeader.CacheControl:
+ return "Cache-Control";
+ case HttpRequestHeader.Connection:
+ return "Connection";
+ case HttpRequestHeader.Date:
+ return "Date";
+ case HttpRequestHeader.KeepAlive:
+ return "Keep-Alive";
+ case HttpRequestHeader.Pragma:
+ return "Pragma";
+ case HttpRequestHeader.Trailer:
+ return "Trailer";
+ case HttpRequestHeader.TransferEncoding:
+ return "Transfer-Encoding";
+ case HttpRequestHeader.Upgrade:
+ return "Upgrade";
+ case HttpRequestHeader.Via:
+ return "Via";
+ case HttpRequestHeader.Warning:
+ return "Warning";
+ case HttpRequestHeader.Allow:
+ return "Allow";
+ case HttpRequestHeader.ContentLength:
+ return "Content-Length";
+ case HttpRequestHeader.ContentType:
+ return "Content-Type";
+ case HttpRequestHeader.ContentEncoding:
+ return "Content-Encoding";
+ case HttpRequestHeader.ContentLanguage:
+ return "Content-Language";
+ case HttpRequestHeader.ContentLocation:
+ return "Content-Location";
+ case HttpRequestHeader.ContentMd5:
+ return "Content-MD5";
+ case HttpRequestHeader.ContentRange:
+ return "Content-Range";
+ case HttpRequestHeader.Expires:
+ return "Expires";
+ case HttpRequestHeader.LastModified:
+ return "Last-Modified";
+ case HttpRequestHeader.Accept:
+ return "Accept";
+ case HttpRequestHeader.AcceptCharset:
+ return "Accept-Charset";
+ case HttpRequestHeader.AcceptEncoding:
+ return "Accept-Encoding";
+ case HttpRequestHeader.AcceptLanguage:
+ return "accept-language";
+ case HttpRequestHeader.Authorization:
+ return "Authorization";
+ case HttpRequestHeader.Cookie:
+ return "Cookie";
+ case HttpRequestHeader.Expect:
+ return "Expect";
+ case HttpRequestHeader.From:
+ return "From";
+ case HttpRequestHeader.Host:
+ return "Host";
+ case HttpRequestHeader.IfMatch:
+ return "If-Match";
+ case HttpRequestHeader.IfModifiedSince:
+ return "If-Modified-Since";
+ case HttpRequestHeader.IfNoneMatch:
+ return "If-None-Match";
+ case HttpRequestHeader.IfRange:
+ return "If-Range";
+ case HttpRequestHeader.IfUnmodifiedSince:
+ return "If-Unmodified-Since";
+ case HttpRequestHeader.MaxForwards:
+ return "Max-Forwards";
+ case HttpRequestHeader.ProxyAuthorization:
+ return "Proxy-Authorization";
+ case HttpRequestHeader.Referer:
+ return "Referer";
+ case HttpRequestHeader.Range:
+ return "Range";
+ case HttpRequestHeader.Te:
+ return "TE";
+ case HttpRequestHeader.Translate:
+ return "Translate";
+ case HttpRequestHeader.UserAgent:
+ return "User-Agent";
+ default:
+ throw new InvalidOperationException ();
+ }
+ }
+
+
+ public string this[HttpRequestHeader hrh]
+ {
+ get {
+ return Get (RequestHeaderToString (hrh));
+ }
+
+ set {
+ Add (RequestHeaderToString (hrh), value);
+ }
+ }
+
+ string ResponseHeaderToString (HttpResponseHeader value)
+ {
+ switch (value){
+ case HttpResponseHeader.CacheControl:
+ return "Cache-Control";
+ case HttpResponseHeader.Connection:
+ return "Connection";
+ case HttpResponseHeader.Date:
+ return "Date";
+ case HttpResponseHeader.KeepAlive:
+ return "Keep-Alive";
+ case HttpResponseHeader.Pragma:
+ return "Pragma";
+ case HttpResponseHeader.Trailer:
+ return "Trailer";
+ case HttpResponseHeader.TransferEncoding:
+ return "Transfer-Encoding";
+ case HttpResponseHeader.Upgrade:
+ return "Upgrade";
+ case HttpResponseHeader.Via:
+ return "Via";
+ case HttpResponseHeader.Warning:
+ return "Warning";
+ case HttpResponseHeader.Allow:
+ return "Allow";
+ case HttpResponseHeader.ContentLength:
+ return "Content-Length";
+ case HttpResponseHeader.ContentType:
+ return "Content-Type";
+ case HttpResponseHeader.ContentEncoding:
+ return "Content-Encoding";
+ case HttpResponseHeader.ContentLanguage:
+ return "Content-Language";
+ case HttpResponseHeader.ContentLocation:
+ return "Content-Location";
+ case HttpResponseHeader.ContentMd5:
+ return "Content-MD5";
+ case HttpResponseHeader.ContentRange:
+ return "Content-Range";
+ case HttpResponseHeader.Expires:
+ return "Expires";
+ case HttpResponseHeader.LastModified:
+ return "Last-Modified";
+ case HttpResponseHeader.AcceptRanges:
+ return "Accept-Ranges";
+ case HttpResponseHeader.Age:
+ return "Age";
+ case HttpResponseHeader.ETag:
+ return "ETag";
+ case HttpResponseHeader.Location:
+ return "Location";
+ case HttpResponseHeader.ProxyAuthenticate:
+ return "Proxy-Authenticate";
+ case HttpResponseHeader.RetryAfter:
+ return "Retry-After";
+ case HttpResponseHeader.Server:
+ return "Server";
+ case HttpResponseHeader.SetCookie:
+ return "Set-Cookie";
+ case HttpResponseHeader.Vary:
+ return "Vary";
+ case HttpResponseHeader.WwwAuthenticate:
+ return "WWW-Authenticate";
+ default:
+ throw new InvalidOperationException ();
+ }
+ }
+ public string this[HttpResponseHeader hrh]
+ {
+ get
+ {
+ return Get (ResponseHeaderToString (hrh));
+ }
+
+ set
+ {
+ Add (ResponseHeaderToString (hrh), value);
+ }
+ }
+
+ public override void Clear ()
+ {
+ base.Clear ();
+ }
+
+
+ public override IEnumerator GetEnumerator ()
+ {
+ return(base.GetEnumerator ());
+ }
+
+ // Internal Methods
+
+ // With this we don't check for invalid characters in header. See bug #55994.
+ internal void SetInternal (string header)
+ {
+ int pos = header.IndexOf (':');
+ if (pos == -1)
+ throw new ArgumentException ("no colon found", "header");
+
+ SetInternal (header.Substring (0, pos), header.Substring (pos + 1));
+ }
+
+ internal void SetInternal (string name, string value)
+ {
+ if (value == null)
+ value = String.Empty;
+ else
+ value = value.Trim ();
+ if (!IsHeaderValue (value))
+ throw new ArgumentException ("invalid header value");
+