GetKey() публичный Метод

public GetKey ( int index ) : string
index int
Результат string
 private static Dictionary<string, string> GetHeadersDictionaryFrom(WebHeaderCollection headers)
 {
     string pattern = "\\s+";
     Dictionary<string, string> dictionary = new Dictionary<string, string>();
     for (int i = 0; i < headers.Keys.Count; i++)
     {
         string key = headers.GetKey(i).Replace("-", " ").ToUpper();
         key = Regex.Replace(key, pattern, "");
         string value = headers.Get(headers.GetKey(i));
         //System.Console.WriteLine("Key => " + key + " Value => " + value);
         dictionary.Add(key, value);
     }
     return dictionary;
 }
        private string HeadersToString(WebHeaderCollection Headers)
        {
            string Output = string.Empty;
            for (int i = 0; i < Headers.Count; i++)
            {
                Output += Headers.GetKey(i) + ": " + Headers[i] + "\r\n";
            }

            return Output;
        }
		public Dictionary<string, string> MapHeaders(WebHeaderCollection headerCollection)
		{
			var headers = new Dictionary<string, string>();

			for (var i = 0; i < headerCollection.Count; i++)
			{
				headers.Add(headerCollection.GetKey(i), string.Join(",", headerCollection.GetValues(i)));
			}

			return headers;
		}
Пример #4
0
        public string GetHeadersString(WebHeaderCollection header = null)
        {
            if (header == null)
            {
                header = _header;
            }
            if (header.IsNullOrEmpty())
            {
                return(string.Empty);
            }

            var sb = new StringBuilder();

            sb.AppendFormat(HeaderFormat, _header.GetKey(0), _header.Get(0));
            for (int i = 1; i < _header.Count; i++)
            {
                sb.Append(Environment.NewLine)
                .AppendFormat(HeaderFormat, _header.GetKey(i), _header.Get(i));
            }
            return(sb.ToString());
        }
Пример #5
0
 public void AddHeaders(WebHeaderCollection headers)
 {
     if (headers != null)
     {
         Headers = new List<Header>();
         for (int i = 0; i < headers.Count; ++i)
         {
             string header = headers.GetKey(i);
             foreach (string value in headers.GetValues(i))
             {
                 Headers.Add(new Header(header, value));
             }
         }
     }
 }
Пример #6
0
 public static void Test_WebHeader_01()
 {
     WebHeaderCollection headers = new WebHeaderCollection();
     headers.Add("xxx", "yyy");
     headers.Add("xxx", "yyy222");
     headers.Add("zzz", "fff");
     headers.Add("xxx", "ttt");
     for (int i = 0; i < headers.Count; ++i)
     {
         string key = headers.GetKey(i);
         foreach (string value in headers.GetValues(i))
         {
             Trace.WriteLine("{0}: {1}", key, value);
         }
     }
 }
Пример #7
0
        private static string FormatHeaders(WebHeaderCollection headers)
        {
            var sb = new StringBuilder();

            for (int i = 0; i < headers.Count; i++)
            {
                string   key    = headers.GetKey(i);
                string[] values = headers.GetValues(i);
                for (int j = 0; j < values.Length; j++)
                {
                    sb.Append(key).Append(": ").Append(values[j]).Append("\r\n");
                }
            }

            return(sb.Append("\r\n").ToString());
        }
Пример #8
0
        static string FormatHeaders(WebHeaderCollection headers)
        {
            var sb = new StringBuilder();

            for (int i = 0; i < headers.Count; i++)
            {
                string key = headers.GetKey(i);
                if (WebHeaderCollection.AllowMultiValues(key))
                {
                    foreach (string v in headers.GetValues(i))
                    {
                        sb.Append(key).Append(": ").Append(v).Append("\r\n");
                    }
                }
                else
                {
                    sb.Append(key).Append(": ").Append(headers.Get(i)).Append("\r\n");
                }
            }

            return(sb.Append("\r\n").ToString());
        }
Пример #9
0
 private static string CanonicalizedUCloudHeaders(WebHeaderCollection header)
 {
     string canoncializedUCloudHeaders = string.Empty;
     SortedDictionary<string, string> headerMap = new SortedDictionary<string, string> ();
     for (int i = 0; i < header.Count; ++i) {
         string headerKey = header.GetKey (i);
         if (headerKey.ToLower().StartsWith ("x-ucloud-")) {
             foreach (string value in header.GetValues(i)) {
                 if (headerMap.ContainsKey (headerKey)) {
                     headerMap [headerKey] += value;
                     headerMap [headerKey] += @",";
                 } else {
                     headerMap.Add (headerKey, value);
                 }
             }
         }
     }
     foreach (KeyValuePair<string, string> item in headerMap) {
         canoncializedUCloudHeaders += (item.Key + @":" + item.Value + @"\n");
     }
     return canoncializedUCloudHeaders;
 }
Пример #10
0
 private static IEnumerable<KeyValuePair<string, IEnumerable<string>>> ConvertHeaders(
     WebHeaderCollection webHeaders)
 {
     for (var i = 0; i < webHeaders.Count; i++)
     {
         var key = webHeaders.GetKey(i);
         yield return new KeyValuePair<string, IEnumerable<string>>(key, webHeaders.GetValues(i));
     }
 }
Пример #11
0
		static string FormatHeaders (WebHeaderCollection headers)
		{
			var sb = new StringBuilder();

			for (int i = 0; i < headers.Count ; i++) {
				string key = headers.GetKey (i);
				if (WebHeaderCollection.AllowMultiValues (key)) {
					foreach (string v in headers.GetValues (i)) {
						sb.Append (key).Append (": ").Append (v).Append ("\r\n");
					}
				} else {
					sb.Append (key).Append (": ").Append (headers.Get (i)).Append ("\r\n");
				}
			}

			return sb.Append("\r\n").ToString();
		}
Пример #12
0
        /// <summary>
        /// Handle response headers
        /// </summary>
        private void HandleHeader(string url, WebHeaderCollection headers)
        {
            for (int i = 0; i < headers.Count; i++)
            {
                string Key = headers.GetKey(i);
                string Value = headers.Get(i);

                switch (Key)
                {
                    case "Set-Cookie":
                        HandleResponseSetCookie(url, Value);
                        break;
                    case "Location":
                        this.RedirectLocation = Value;
                        break;
                }
            }
        }
Пример #13
0
        public static string HTTPFetch(string url, string method,
            WebHeaderCollection headers, 
            byte[] streamBytes, 
            int contentLength, 
            out string[] responseFields,
            string contentType = "application/x-www-form-urlencoded",
            string requestAccept = null, 
            string host = null)
        {
            _active = true;
            try
            {
                var uri = new Uri(url);
                if (EndpointCallback != null) EndpointCallback(uri.AbsolutePath);
                if (string.IsNullOrEmpty(host)) host = uri.Host;

                string reqStr =
                    String.Format("{0} {1} HTTP/1.1\r\n", method, url) +
                    String.Format("Host: {0}\r\n", host) +
                    String.Format("Connection: Close\r\n");

                if (!IsNullOrWhiteSpace(requestAccept))
                    reqStr += String.Format("Accept: {0}\r\n", requestAccept);
                if (contentType != null)
                    reqStr += String.Format("Content-Type: {0}\r\n", contentType);

                if (headers != null)
                {
                    for (int i = 0; i < headers.Count; ++i)
                    {
                        string header = headers.GetKey(i);
                        foreach (string value in headers.GetValues(i))
                        {
                            reqStr += String.Format("{0}: {1}\r\n", header, value);
                        }
                    }
                }

                reqStr += String.Format("Content-Length: {0}\r\n", contentLength);
                reqStr += "\r\n";
                byte[] headerBytes = ToByteArray(reqStr);

                byte[] finalBytes = headerBytes;
                if (contentLength > 0)
                {
                    var requestBytes = new byte[headerBytes.Length + contentLength];
                    Buffer.BlockCopy(headerBytes, 0, requestBytes, 0, headerBytes.Length);
                    Buffer.BlockCopy(streamBytes, 0, requestBytes, headerBytes.Length, contentLength);
                    finalBytes = requestBytes;
                }

                string responseFromServer = "";
                responseFields = new string[] { };
                var tcpClient = new TcpClient();
                string responseStr = "";
                int responseLength = 0;

                if (url.ToLower().StartsWith("https"))
                {
                    //HTTPS
                    tcpClient.Connect(uri.Host, 443);
                    ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback((sender, certificate, chain, policyErrors) => true);

                    //This has a bug on mono: Message	"The authentication or decryption has failed."
                    //Therefore unfortunately we have to ignore certificates.
                    using (var s = new SslStream(tcpClient.GetStream(), false,
                        new RemoteCertificateValidationCallback((sender, certificate, chain, policyErrors) => true)))
                    {
                        s.AuthenticateAsClient(uri.Host, null, SslProtocols.Tls, false);
                        if (UpstreamCallback != null && UpstreamCallbackRate > 0)
                        {
                            int i = 0;
                            while (i < finalBytes.Length)
                            {
                                if (!_active) throw new Exception("Halt");
                                if (i + _upstreamCallbackRate > finalBytes.Length)
                                {
                                    s.Write(finalBytes, i, finalBytes.Length - i);
                                    UpstreamCallback(contentLength, contentLength);
                                    break;
                                }
                                s.Write(finalBytes, i, (int)_upstreamCallbackRate);
                                i += (int)_upstreamCallbackRate;
                                UpstreamCallback(Math.Min(i, contentLength), contentLength);
                            }
                        }
                        else s.Write(finalBytes, 0, finalBytes.Length);
                        s.Flush();

                        while (true)
                        {
                            var responseBytes = new byte[8192];
                            int i = s.Read(responseBytes, 0, responseBytes.Length);
                            if (i == 0) break;
                            responseStr += Encoding.UTF8.GetString(responseBytes, 0, i);
                            responseLength += i;
                        }
                    }
                }
                else
                {
                    //HTTP
                    tcpClient.Connect(uri.Host, 80);
                    if (UpstreamCallback != null && UpstreamCallbackRate > 0)
                    {
                        var s = tcpClient.GetStream();
                        int i = 0;
                        while (i < finalBytes.Length)
                        {
                            if (!_active) throw new Exception("Halt");
                            if (i + _upstreamCallbackRate > finalBytes.Length)
                            {
                                s.Write(finalBytes, i, finalBytes.Length - i);
                                UpstreamCallback(contentLength, contentLength);
                                break;
                            }
                            s.Write(finalBytes, i, (int)_upstreamCallbackRate);
                            i += (int)_upstreamCallbackRate;
                            UpstreamCallback(Math.Min(i, contentLength), contentLength);
                        }
                    }
                    else tcpClient.Client.Send(finalBytes);

                    while (true)
                    {
                        var responseBytes = new byte[8192];
                        int i = tcpClient.Client.Receive(responseBytes);
                        if (i == 0) break;
                        responseStr += Encoding.UTF8.GetString(responseBytes, 0, i);
                        responseLength += i;
                    }
                }

                tcpClient.Close();

                var bodyPos = responseStr.IndexOf("\r\n\r\n");
                if (bodyPos >= 0)
                {
                    responseFields = responseStr.Substring(0, bodyPos).Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    bodyPos += 4;
                    responseFromServer = responseStr.Substring(bodyPos, responseStr.Length - bodyPos);
                }

                Debug.WriteLine(String.Format("Response from URL {0}:", url), "HTTPFetch");
                Debug.WriteLine(responseFromServer, "HTTPFetch");

                if (VerboseCallback != null)
                {
                    VerboseCallback(String.Format("Response from URL {0}:", url));
                    VerboseCallback(responseFromServer);
                }

                return responseFromServer;
            }
            catch (Exception e)
            {
                _active = false;
                throw e;
            }
        }
Пример #14
0
        public static void Test_WebHeader_02()
        {
            string file = @"http\header_01.json";
            string file2 = @"http\header_02.json";

            file = zPath.Combine(_directory, file);
            file2 = zPath.Combine(_directory, file2);

            WebHeaderCollection headers = new WebHeaderCollection();
            headers.Add("xxx", "yyy");
            headers.Add("xxx", "yyy222");
            headers.Add("zzz", "fff");
            headers.Add("yyy", "ttt");
            for (int i = 0; i < headers.Count; ++i)
            {
                string key = headers.GetKey(i);
                foreach (string value in headers.GetValues(i))
                {
                    Trace.WriteLine("{0}: {1}", key, value);
                }
            }

            //headers.zSave(file);
            BsonDocument doc = headers.ToBsonDocument();
            doc.zSave(file);
        }
        /// <summary>
        /// Fills the Response Header Collection.
        /// </summary>
        /// <param name="resp"> The ResponseBuffer type.</param>
        /// <param name="request"> The HttpWebRequest type.</param>
        /// <param name="responseHeaders"> The Response WebHeaderCollection.</param>
        /// <param name="hwr"> The HttpWebResponse type.</param>
        /// <returns> An updated ResponseBuffer type containing the change.</returns>
        public static ResponseBuffer FillResponseHeader(ResponseBuffer resp,HttpWebRequest request, WebHeaderCollection responseHeaders, HttpWebResponse hwr)
        {
            Hashtable coll = new Hashtable();

            coll.Add("Character Set",hwr.CharacterSet);
            coll.Add("Content Encoding",hwr.ContentEncoding);
            coll.Add("Last Modified",hwr.LastModified);
            coll.Add("Method",hwr.Method);
            coll.Add("Protocol Version",hwr.ProtocolVersion);
            coll.Add("Response Uri",hwr.ResponseUri);
            coll.Add("Server",hwr.Server);
            coll.Add("Status Code",hwr.StatusCode);
            coll.Add("Status Description",hwr.StatusDescription);
            coll.Add("Referer", request.Referer);

            for (int i = 0;i<responseHeaders.Count;i++)
            {
                if (!coll.ContainsKey(responseHeaders.GetKey(i)) )
                {
                    coll.Add(responseHeaders.GetKey(i), responseHeaders[i]);
                }
            }

            StringBuilder sb = new StringBuilder();

            sb.Append("---------------------");
            sb.Append("=RESPONSE HEADERS=");
            sb.Append("---------------------\r\n");
            foreach (DictionaryEntry de in coll)
            {
                sb.Append(de.Key);
                sb.Append(":");
                sb.Append(de.Value);
                sb.Append("\r\n");
            }

            resp.ResponseHeader = sb.ToString();
            resp.ResponseHeaderCollection = coll;
            return resp;
        }
Пример #16
0
        private static string GetCookieString(WebHeaderCollection webHeaderCollection)
        {
            try
            {
                string CokString = "";
                for (int i = 0; i < webHeaderCollection.Count; i++)
                {
                    String header__ = webHeaderCollection.GetKey(i);
                    if (header__ != "Set-Cookie")
                        continue;
                    String[] values = webHeaderCollection.GetValues(header__);
                    if (values.Length < 1)
                        continue;
                    foreach (string v in values)
                        if (v != "")
                            CokString += MrHTTP.StripCokNameANdVal(v)+";";

                }
                if (CokString.Length > 0)
                    return CokString.Substring(0, CokString.Length - 1);

                return CokString;
            }
            catch { return ""; }
        }
        /// <summary>
        /// Receives the continue header from delegate and sets it to ContinueHeader property.
        /// </summary>
        /// <param name="statusCode"> The status code</param>
        /// <param name="header"> The header collection.</param>
        protected void GetRedirectHeaders(int statusCode, WebHeaderCollection header)
        {
            StringBuilder textStream = new StringBuilder();

            for (int i = 0;i<header.Count;i++)
            {
                textStream.Append(header.GetKey(i));
                textStream.Append(": ");
                textStream.Append(header.Get(i));
                textStream.Append("\r\n");
            }

            ContinueHeader= textStream.ToString();
        }
Пример #18
0
 public void ResetCookie(WebHeaderCollection whc, string host)
 {
     for (int i = 0; i < whc.Count; i++) {
         string key = whc.GetKey(i);
         string value = whc.Get(i);
         if (key == "Set-Cookie") {
             Match match = Regex.Match(value, "(.+?)=(.+?);");
             if (match.Captures.Count > 0) {
                 cookieContainer.Add(new Cookie(match.Groups[1].Value, match.Groups[2].Value, "/", host.Split(':')[0]));
             }
         }
     }
 }
Пример #19
0
        private void ThreadLoop()
        {
            while (true)
            {
                if (Socket != null) Socket.Close(); // securité: on ferme l'eventuelle Socket précédente
                try
                {
                    Socket = tcpListener.AcceptSocket();
                }
                catch (SocketException e)
                {
                    if (e.SocketErrorCode == SocketError.Interrupted)
                        return; // arrêt du serveur
                    throw;
                }
                if (ValidateRemoteAddr((Socket.RemoteEndPoint as IPEndPoint).Address))
                try
                {
                    NetworkStream networkStream = new NetworkStream(Socket, true);
                    networkStream.ReadTimeout = 1000; // timeout if read doesn't succeed after 1 sec
                    using (RequestContent = new StreamReader(networkStream, Encoding.Default))
                    {
                        string line = null;
                        int index;
                        ProtocolVersion = HttpVersion.Version10;
                        HttpStatusCode StatusCode;// = HttpStatusCode.OK;
                        ErrorDescription = null;
                        Url = null;
                        Query = null;
                        QueryArgs = null;
                        LastModified = DateTime.Now;
                        ResponseHeaders = new WebHeaderCollection();
                        ContentType = new ContentType("text/html");
                        ContentLength = -1;
                        Content = null;
                        try
                        {
                            try
                            {
                                line = RequestContent.ReadLine();
                            }
                            catch (IOException e)
                            {
                                throw new ApplicationException(e.Message, e);
                            }
                            Console.WriteLine("HTTP< " + line);
                            if (line == null) continue;
                            index = line.IndexOf(' ');
                            HttpMethod = line.Substring(0, index);
                            line = line.Substring(index + 1);
                            index = line.IndexOf(' ');
                            if (index >= 0)
                            {
                                string protocolVersion = line.Substring(index + 1);
                                Match m = (new Regex("HTTP/(\\d+).(\\d+)")).Match(protocolVersion);
                                if (!m.Success) throw new Exception("Protocole HTTP invalide");
                                line = line.Substring(0, index);
                                ProtocolVersion = new Version(Convert.ToInt32(m.Groups[1].Value), Convert.ToInt32(m.Groups[2].Value));
                            }
                            else
                                ProtocolVersion = HttpVersion.Version10;
                            if (line.Length == 0) throw new Exception("URI manquante");
                            index = line.IndexOf('?');
                            if (index >= 0)
                            {
                                Query = line.Substring(index);
                                QueryArgs = System.Web.HttpUtility.ParseQueryString(System.Web.HttpUtility.HtmlDecode(line.Substring(index + 1)));
                                line = line.Substring(0, index);
                            }
                            else
                            {
                                Query = String.Empty;
                                QueryArgs = new NameValueCollection();
                            }
                            Url = line;

                            Accept = null;
                            Connection = null;
                            RequestContentLength = -1;
                            RequestContentType = null;
                            Host = null;
                            IfModifiedSince = new DateTime(); // DateTime vide
                            Referer = null;
                            UserAgent = null;
                            RequestHeaders = new WebHeaderCollection();
                            while ((line = RequestContent.ReadLine()).Length != 0)
                            {
                                index = line.IndexOf(':');
                                if (index < 0)
                                {
                                    Console.WriteLine("BasicHttpServer: Header HTTP invalide: " + line);
                                    continue;
                                }
                                string headerName = line.Substring(0, index);
                                line = line.Substring(index + 1).Trim();
                                switch (headerName.ToLower())
                                {
                                    case "accept": Accept = line; break;
                                    case "connection": Connection = line; break;
                                    case "content-length": RequestContentLength = Convert.ToInt64(line); break;
                                    case "content-type": RequestContentType = new ContentType(line); break;
                                    case "host": Host = line; break;
                                    case "if-modified-since": IfModifiedSince = DateTime.Parse(line); break;
                                    case "referer": Referer = line; Console.WriteLine("HTTP< Referer: " + line); break;
                                    case "user-agent": UserAgent = line; break;
                                    default:
                                        Console.WriteLine("BasicHttpServer: Header inconnu: {0}: {1}", headerName, line);
                                        RequestHeaders.Add(headerName, line);
                                        break;
                                }
                            }

                            try
                            {
                                // handle the request (this function is eventually overriden)
                                StatusCode = HandleRequest();
                                if (StatusCode != HttpStatusCode.OK)
                                    Console.WriteLine("BasicHttpServer: {0} {1}: {2}\r\n\t{3}", (int) StatusCode, StatusCode, Url, ErrorDescription);
                            }
            #if DEBUG
                            catch (ApplicationException e)
            #else
                            catch (Exception e) // en mode RELEASE, catch toutes les exceptions pour ne pas planter le serveur
            #endif
                            {
                                StatusCode = HttpStatusCode.InternalServerError;
                                ErrorDescription = e.Message;
                                Console.WriteLine("BasicHttpServer: {0}:\r\n\tsur la requete {1}{2}", e, Url, Query);
                            }
                        }
            #if DEBUG
                        catch (ApplicationException e)
            #else
                        catch (Exception e) // en mode RELEASE, catch toutes les exceptions pour ne pas planter le serveur
            #endif
                        {
                            StatusCode = HttpStatusCode.BadRequest;
                            ErrorDescription = e.Message;
                            Console.WriteLine("BasicHttpServer: {0}:\r\nsur le parsing de {1}", e, line);
                        }
                        if ((Content == null) && (StatusCode != HttpStatusCode.OK))
                        {
                            ContentType = new ContentType("text/html");
                            ReplyFormattedFile(ErrorFile, (int)StatusCode, StatusCode, Url, ErrorDescription.Replace("\r\n", "<br>"));
                        }

                        if (HackStatusCodeAlwaysOK) // cas particulier des clients HTTP qui n'aiment pas autre chose qu'OK (ex: Freebox ...)
                            StatusCode = HttpStatusCode.OK;

                        // envoi des Headers de la réponse
                        StreamWriter writer = new StreamWriter(networkStream, Encoding.Default);
                        writer.WriteLine("HTTP/{0}.{1} {2} {3}", ProtocolVersion.Major, ProtocolVersion.Minor,
                                                                (int)StatusCode, StatusCode);
                        writer.WriteLine("Last-Modified: " + LastModified.ToString("R"));
                        writer.WriteLine("Location: " + ResponseUri);
                        if (ProtocolVersion > HttpVersion.Version10)
                        {
                            writer.WriteLine("Connection: close"); // c'est un serveur vraiment basique... pas de Keep-Alive
                            for (index = 0; index < ResponseHeaders.Count; index++)
                                writer.WriteLine("{0}: {1}", ResponseHeaders.GetKey(index), ResponseHeaders.Get(index));
                        }
                        if (Content != null)
                        {
                            writer.WriteLine("Content-Type: " + ContentType);
                            //Console.WriteLine("HTTP> Content-Type: " + ContentType);
                            if ((ContentLength == -1) && Content.CanSeek)
                                ContentLength = Content.Length;
                            if (ContentLength != -1)
                            {
                                writer.WriteLine("Content-Length: " + ContentLength);
                                //Console.WriteLine("HTTP> Content-Length: " + ContentLength);
                            }
                        }
                        writer.WriteLine(); // termine les headers avec une ligne vide
                        try
                        {
                            writer.Flush();
                        }
                        catch (IOException)
                        {
                        }

                        if (Content != null)
                        {
                            if (HttpMethod != "HEAD")
                                try
                                {
                                    // TODO: faire un choix sur le comportement si la position n'est pas au debut du Stream)
                                    // actuellement, pour MemoryStream, on balance tout depuis le debut, meme si la position n'est pas au debut
                                    // et pour les autres Stream, on balance à partir de la position en cours
                                    // (ce qui permet de n'envoyer qu'une portion précise si on veut)

                                    if ((Content is MemoryStream) && (ContentLength == Content.Length))
                                    { // variante optimisée pour les MemoryStream
                                        ((MemoryStream)Content).WriteTo(networkStream);
                                    }
                                    else if (ContentLength == -1)
                                    {
                                        byte[] buffer = new byte[4096L];
                                        do
                                        {
                                            index = Content.Read(buffer, 0, 4096);
                                            networkStream.Write(buffer, 0, index);
                                        } while (index != 0);
                                    }
                                    else
                                    {
                                        byte[] buffer = new byte[Math.Min(ContentLength, 4096L)];
                                        while (ContentLength > 0)
                                        {
                                            index = Content.Read(buffer, 0, buffer.Length);
                                            if (index == 0)
                                            {
                                                Console.WriteLine("BasicHttpServer: Supplied Content stream did not contain expected ContentLength");
                                                break;
                                            }
                                            networkStream.Write(buffer, 0, index);
                                            ContentLength -= index;
                                        }
                                    }
                                }
                                catch (IOException)
                                {
                                }
                            Content.Close();
                        } // if (Content != null)
                    } // using (content) => Terminate the connection

                    HandleAfterReply(); // opportunité de faire un traitement après que la réponse aie été envoyée
                }
            #if DEBUG
                catch (ApplicationException e)
            #else
                catch (Exception e) // en mode RELEASE, catch toutes les exceptions pour ne pas planter le serveur
            #endif
                {
                    Console.WriteLine("BasicHttpServer: " + e);
                }
            } // while
        }
        /// <summary>
        /// Fills The Request Header Collection.
        /// </summary>
        /// <param name="resp"> The ResponseBuffer type.</param>
        /// <param name="h"> The WebHeaderCollection type.</param>
        /// <param name="hwrq"> The HttpWebRequest type.</param>
        /// <returns> An updated ResponseBuffer type containing the change.</returns>
        public static ResponseBuffer FillRequestHeader(ResponseBuffer resp,WebHeaderCollection h,HttpWebRequest hwrq)
        {
            Hashtable coll = new Hashtable();

            coll.Add("Accept",hwrq.Accept);
            coll.Add("User Agent",hwrq.UserAgent);
            coll.Add("ContentType",hwrq.ContentType);
            coll.Add("Method",hwrq.Method);
            coll.Add("Pipelined",hwrq.Pipelined);
            coll.Add("Keep Alive",hwrq.KeepAlive);
            coll.Add("Request Uri",hwrq.RequestUri);
            coll.Add("Send Chunked",hwrq.SendChunked);
            coll.Add("Transfer Encoding",hwrq.TransferEncoding);

            for (int i = 0;i<h.Count;i++)
            {
                if ( !coll.ContainsKey(h.GetKey(i)) )
                {
                    coll.Add(h.GetKey(i),h[i]);
                }
            }

            StringBuilder sb = new StringBuilder();
            sb.Append("---------------------");
            sb.Append("=REQUEST HEADERS=");
            sb.Append("---------------------\r\n");

            foreach (DictionaryEntry de in coll)
            {
                sb.Append(de.Key);
                sb.Append(":");
                sb.Append(de.Value);
                sb.Append("\r\n");
            }

            resp.RequestHeaderCollection = coll;
            resp.RequestHeader = sb.ToString();

            return resp;
        }