Changeset 183 for SimpleHttpServer

Timestamp:

07/25/07 03:49:16 (18 months ago)

Author:

mayuki

Message:

 

Files:

• SimpleHttpServer/SimpleHttpServer/SimpleHttpServer.cs (modified) (14 diffs)

SimpleHttpServer/SimpleHttpServer/SimpleHttpServer.cs

@@ -19 +19 @@
         private SimpleHttpServer _server;
 
+        private Response _response;
         private Dictionary<String, String> _headers;
+
         public String RequestUri;
         public String Method;
@@ -38 +40 @@
         public Dictionary<String, String> Headers
         {
-            get
-            {
-                return _headers;
-            }
+            get { return _headers; }
         }
         public Stream Stream
         {
-            get
-            {
-                return _stream;
-            }
+            get { return _stream; }
+        }
+        public Response Response
+        {
+            get { return _response; }
         }
 
@@ -56 +56 @@
             _tcpClient = tcpClient;
             _server = server;
-
-            _headers = new Dictionary<string, string>();
-
-            Contexts[Thread.CurrentThread.ManagedThreadId] = this;
+            _response = new Response(this);
+
+            _headers = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+            
+            lock (Contexts)
+            {
+                Contexts[Thread.CurrentThread.ManagedThreadId] = this;
+            }
         }
 
@@ -96 +100 @@
                     if (ctx.Headers.ContainsKey(headerField[0]))
                     {
-                        ctx.Headers[headerField[1]] += ", "+headerField[1];
+                        ctx.Headers[headerField[1]] += ", " + headerField[1].Trim();
                     }
                     else
                     {
-                        ctx.Headers[headerField[0]] = headerField[1];
+                        ctx.Headers[headerField[0]] = headerField[1].Trim();
                     }
                 }
@@ -114 +118 @@
             Dispose();
         }
+
 
         #region IDisposable �����o
@@ -133 +138 @@
     }
 
+    public class Response : IDisposable
+    {
+        private Context _ctx;
+        private HttpStatusCode _statusCode;
+        private Dictionary<String, String> _headers;
+        private String _contentType;
+        private String _charSet;
+        private HttpStream _httpStream;
+
+        public Response(Context ctx)
+        {
+            _ctx = ctx;
+            _contentType = "text/html";
+            _charSet = "UTF-8";
+            _statusCode = HttpStatusCode.OK;
+            _headers = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+            _httpStream = new HttpStream(_ctx.Stream, HttpStream_OnBeforeWrite);
+        }
+
+        private void HttpStream_OnBeforeWrite(Object sender, EventArgs e)
+        {
+            WriteHeaders();
+        }
+
+        public Stream OutputStream
+        {
+            get { return _httpStream; }
+        }
+        public Dictionary<String, String> Headers
+        {
+            get { return _headers; }
+        }
+        public HttpStatusCode StatusCode
+        {
+            set { _statusCode = value; }
+            get { return _statusCode; }
+        }
+        public String ContentType
+        {
+            set { _contentType = value.Replace('\n', ' '); }
+            get { return _contentType; }
+        }
+        public String CharSet
+        {
+            set { _charSet = value.Replace('\n', ' '); }
+            get { return _charSet; }
+        }
+
+        private Boolean _alreadySentHeaders = false;
+        public void WriteHeaders()
+        {
+            if (_alreadySentHeaders)
+                return;
+
+            StreamWriter sw = new StreamWriter(_ctx.Stream);
+            sw.WriteLine("HTTP/1.0 {0} {1}", (Int32)_statusCode, _statusCode.ToString());
+            foreach (KeyValuePair<String, String> pair in _headers)
+            {
+                sw.WriteLine("{0}: {1}", pair.Key, pair.Value);
+            }
+            if (!_headers.ContainsKey("Server"))
+            {
+                sw.WriteLine("Server: {0}", _ctx.Server.VersionString);
+            }
+            if (!_headers.ContainsKey("Content-Type"))
+            {
+                if (ContentType.StartsWith("text/"))
+                {
+                    sw.WriteLine("Conetent-Type: {0}; CharSet={1}", ContentType, CharSet);
+                }
+                else
+                {
+                    sw.WriteLine("Conetent-Type: {0}", ContentType);
+                }
+            }
+            sw.WriteLine("Connection: close");
+            sw.WriteLine();
+            sw.Flush();
+
+            _alreadySentHeaders = true;
+        }
+
+        private Boolean _responseEnded = false;
+        public void End()
+        {
+            WriteHeaders();
+            _ctx.Stream.Flush();
+            _ctx.Stream.Close();
+
+            _responseEnded = true;
+        }
+
+        #region IDisposable �����o
+
+        public void Dispose()
+        {
+            if (!_responseEnded)
+            {
+                End();
+            }
+        }
+
+        #endregion
+    }
+
+    #region HTTP �T�[�o�N���X
     public delegate void RequestEventHandler(Context ctx);
     public class SimpleHttpServer
@@ -175 +286 @@
         protected void OnRequest(Context ctx)
         {
-            if (Request != null)
-            {
-                Request(ctx);
-            }
-            else
-            {
-                // not handled
-                Trace.WriteLineIf(_loggingEnabled, "Request Not Handled", "error");
-                throw new HttpException(501, "Not Implemented");
+            try
+            {
+                if (Request != null)
+                {
+                    Request(ctx);
+                    ctx.Response.End();
+                }
+                else
+                {
+                    // not handled
+                    Trace.WriteLineIf(_loggingEnabled, "Request Not Handled", "error");
+                    throw new HttpException(501, "Not Implemented");
+                }
+            }
+            catch (Exception ex)
+            {
+                if (ex is HttpException || (ex is IOException && ex.InnerException is SocketException))
+                    throw;
+                else 
+                    throw new HttpException(500, "Internal Server Error", ex);
             }
         }
@@ -204 +326 @@
                     sw.WriteLine("Connection: close");
                     sw.WriteLine("");
+                    sw.WriteLine("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">");
                     sw.WriteLine("<title>{0} {1}</title>", he.GetHttpCode(), he.Message);
                     sw.WriteLine("<h1>{0} {1}</h1>", he.GetHttpCode(), he.Message);
                     sw.WriteLine("<p>{0}</p>", he.GetHtmlErrorMessage());
-                    sw.WriteLine("<h2>��</h2>");
-                    sw.WriteLine("<pre>{0}</pre>", HttpUtility.HtmlEncode(he.ToString()));
+                    if (IPAddress.IsLoopback(((IPEndPoint)Context.Current.TcpClient.Client.RemoteEndPoint).Address))
+                    {
+                        sw.WriteLine("<h2>��</h2>");
+                        sw.WriteLine("<pre>{0}</pre>", HttpUtility.HtmlEncode(he.ToString()));
+                    }
                 }
             }
@@ -235 +361 @@
                 }
             }
+            catch (IOException)
+            {
+                //
+            }
             catch (Exception e)
             {
-                Trace.WriteLineIf(_loggingEnabled, e.Message, "error");
-                sw.WriteLine("HTTP/1.0 500 Internal Server Error");
-                sw.WriteLine("Content-Type: text/html; charset=utf-8");
-                sw.WriteLine("Server: {0}", VersionString);
-                sw.WriteLine("Connection: close");
-                sw.WriteLine("");
-                sw.WriteLine("<title>500 Internal Server Error</title>");
-                sw.WriteLine("<h1>500 Internal Server Error</h1>");
-                sw.WriteLine("<p>�T�[�o�ŏ�����s���ɃG���[���������܂����B</p>");
-                if (IPAddress.IsLoopback(((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address))
-                {
-                    sw.WriteLine("<h2>��</h2>");
-                    sw.WriteLine("<pre>{0}</pre>", HttpUtility.HtmlEncode(e.ToString()));
-                }
-                sw.Flush();
+                Trace.WriteLineIf(_loggingEnabled, e.ToString(), "error");
+                if (stream.CanWrite)
+                {
+                    sw.WriteLine("HTTP/1.0 500 Internal Server Error");
+                    sw.WriteLine("Content-Type: text/html; charset=utf-8");
+                    sw.WriteLine("Server: {0}", VersionString);
+                    sw.WriteLine("Connection: close");
+                    sw.WriteLine("");
+                    sw.WriteLine("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">");
+                    sw.WriteLine("<title>500 Internal Server Error</title>");
+                    sw.WriteLine("<h1>500 Internal Server Error</h1>");
+                    sw.WriteLine("<p>�T�[�o�ŏ�����s���ɃG���[���������܂����B</p>");
+                    if (IPAddress.IsLoopback(((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address))
+                    {
+                        sw.WriteLine("<h2>��</h2>");
+                        sw.WriteLine("<pre>{0}</pre>", HttpUtility.HtmlEncode(e.ToString()));
+                    }
+                    sw.Flush();
+                }
             }
             finally
@@ -268 +402 @@
         }
 
-        
+
         public void Start(IPEndPoint endPoint)
         {
@@ -275 +409 @@
             _tcpListener = new TcpListener(endPoint);
             _AcceptTcpClientCallback = new AsyncCallback(AcceptTcpClientCallback);
-            
+
             _tcpListener.Start();
             _tcpListener.BeginAcceptTcpClient(_AcceptTcpClientCallback, _tcpListener);
             _isRunning = true;
-            
+
             //TcpClient tcpClient;
             //while ((tcpClient = _tcpListener.AcceptTcpClient()) != null)
@@ -297 +431 @@
         private void AcceptTcpClientCallback(IAsyncResult ar)
         {
-            //TcpListener tcpListener = ar.AsyncState as TcpListener;
-            TcpClient tcpClient = _tcpListener.EndAcceptTcpClient(ar);
-            _tcpListener.BeginAcceptTcpClient(_AcceptTcpClientCallback, _tcpListener);
+            if (!_isRunning)
+                return;
             try
             {
-                HandleRequest(tcpClient);
-            }
-            catch (Exception e)
-            {
-                Trace.WriteLineIf(_loggingEnabled, e.Message, "error");
+                _tcpListener.BeginAcceptTcpClient(_AcceptTcpClientCallback, _tcpListener);
+                TcpClient tcpClient = _tcpListener.EndAcceptTcpClient(ar);
+
+                try
+                {
+                    HandleRequest(tcpClient);
+                }
+                catch (Exception e)
+                {
+                    Trace.WriteLineIf(_loggingEnabled, e.Message, "error");
+                    if (!(e.InnerException is SocketException))
+                    {
+                        throw;
+                    }
+                }
+            }
+            catch (SocketException se)
+            {
+                Trace.WriteLineIf(_loggingEnabled, se.Message, "error");
             }
         }
@@ -312 +459 @@
         public void Stop()
         {
+            _isRunning = false;
             _tcpListener.Stop();
         }
@@ -328 +476 @@
         }
     }
+    #endregion
+
+    #region HttpStream �N���X
+    public class HttpStream : Stream
+    {
+        private Stream _baseStream;
+        private Boolean _contentWritten = false;
+        public event EventHandler BeforeWrite;
+
+        public HttpStream(Stream stream, EventHandler beforeWriteHandler)
+        {
+            _baseStream = stream;
+            BeforeWrite += beforeWriteHandler;
+        }
+        public Stream BaseStream
+        {
+            get { return _baseStream; }
+        }
+        public override bool CanRead
+        {
+            get { return _baseStream.CanRead; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return _baseStream.CanSeek; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return _baseStream.CanWrite; }
+        }
+
+        public override void Flush()
+        {
+            _baseStream.Flush();
+        }
+
+        public override long Length
+        {
+            get { return _baseStream.Length; }
+        }
+
+        public override long Position
+        {
+            get
+            {
+                return _baseStream.Position;
+            }
+            set
+            {
+                _baseStream.Position = value;
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return _baseStream.Read(buffer, offset, count);
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return _baseStream.Seek(offset, origin);
+        }
+
+        public override void SetLength(long value)
+        {
+            _baseStream.SetLength(value);
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (BeforeWrite != null && !_contentWritten)
+            {
+                _contentWritten = true;
+                BeforeWrite(this, EventArgs.Empty);
+            }
+
+            _baseStream.Write(buffer, offset, count);
+        }
+    }
+    #endregion
 
     public class LoggingTraceListener : ConsoleTraceListener