示例#1
0
        public static HttpRequestObject ReadRequest(Stream stream)
        {
            HttpRequestObject request = null;

            byte[] buffer = null;

            buffer = Read(stream);
            if (buffer == null)
            {
                return(null);
            }

            HttpRequestHeader header = new HttpRequestHeader(Encoding.UTF8.GetString(buffer));

            if (header._isParse == false)
            {
                return(null);
            }

            HttpContent content = new HttpContent();

            if (0 < header._contentSize)
            {
                content.Set(ReadContent(stream, header._contentSize));
            }

            request = new HttpRequestObject(header, content);

            return(request);
        }
示例#2
0
        public static SslStreamSet Handshake(TcpClient client, HttpRequestObject request, Stream serverStream)
        {
            ConnectionInfo connectionInfo = ParseReceiveConnect(request);

            SslStreamSet _sslStream = new SslStreamSet();

            // Connection Remote Server.
            SslTcpServer._traceLogger.OutputLog(string.Format("Connection Remote Server {0}:{1}.", connectionInfo.host, Convert.ToInt32(connectionInfo.port)));
            SslTcpClient clientSocket = new SslTcpClient(client);

            SslStream sslClientStream = clientSocket.Connect(connectionInfo.host, Convert.ToInt32(connectionInfo.port));

            // Get Remote PublicKey.
            ServerCertificate hostCertificate = clientSocket.ServerCertificate;

            // Connection Established.
            ConnectionEstablished(serverStream, connectionInfo.protocol);


            // Authenticate to Client by Self PublicKey.
            SslTcpServer._traceLogger.OutputLog("Authenticate with Client by Self PublicKey.");
            SslStream sslServerStream = AuthenticateAsServer(serverStream);

            // Output log.
            OutputSslInfo(sslServerStream, sslClientStream, SslTcpServer._traceLogger);

            _sslStream._serverStream = sslServerStream;
            _sslStream._clientStream = sslClientStream;
            return(_sslStream);
        }
示例#3
0
        private static ConnectionInfo ParseReceiveConnect(HttpRequestObject request)
        {
            ConnectionInfo info = new ConnectionInfo();

            string[] s = request._header._path.Split(':');

            info.host     = s[0];
            info.port     = s[1];
            info.protocol = request._header._httpVersion;

            SslTcpServer._traceLogger.OutputLog(request._header._source.Replace(System.Environment.NewLine, "\t"));

            return(info);
        }
示例#4
0
        public static void Write(HttpObject http, Stream stream)
        {
            byte[] bytes = null;
            stream.WriteTimeout = SslTcpServer._write_timeout;

            if (http.GetType() == typeof(HttpRequestObject))
            {
                HttpRequestObject request = (HttpRequestObject)http;
                bytes = Encoding.UTF8.GetBytes(request._header._source);
            }
            else if (http.GetType() == typeof(HttpResponseObject))
            {
                HttpResponseObject response = (HttpResponseObject)http;
                bytes = Encoding.UTF8.GetBytes(response._header._source);
            }

            Write(stream, bytes);

            if (0 < http._content._length)
            {
                Write(stream, http._content.Get());
            }
        }
示例#5
0
        static public void Proxy(TcpClient serverSocket, IHttpEventListener listner)
        {
            Stream    server       = serverSocket.GetStream();
            Stream    client       = null;
            TcpClient clinetSocket = null;
            bool      bConnect     = false;
            string    host         = string.Empty;
            bool      bSSL         = false;


            while (true)
            {
                //-----------------------------------------
                // Request.
                // Clinet -> Proxy
                //-----------------------------------------

                HttpRequestObject request = null;
                try
                {
                    request = HttpStream.ReadRequest(server);

                    if (request == null)
                    {
                        break;
                    }

                    //-----------------------------------------
                    // SSL Handshake.
                    //-----------------------------------------
                    if (SslHandshake.IsSslConnection(request))
                    {
                        SslStreamSet sslset = SslHandshake.Handshake(clinetSocket, request, server);
                        server   = sslset._serverStream;
                        client   = sslset._clientStream;
                        bConnect = true;
                        bSSL     = true;
                        continue;
                    }
                    //-----------------------------------------
                    // HTTP Conection.
                    //-----------------------------------------
                    else if (bSSL == false && (bConnect == false || host != request._header._host))
                    {
                        if (clinetSocket != null)
                        {
                            client.Close();
                            clinetSocket.Close();
                        }

                        clinetSocket = new TcpClient();
                        clinetSocket.Connect(request._header._host, request._header._port);
                        client   = clinetSocket.GetStream();
                        bConnect = true;
                    }

                    //-----------------------------------------
                    // save host.
                    //-----------------------------------------
                    host = request._header._host;


                    //-----------------------------------------
                    // Observer.
                    //-----------------------------------------
                    if (listner != null)
                    {
                        request = listner.OnHttpRequestClient(request, server, client);
                    }
                }catch (Exception ex) {
                    Close(serverSocket, clinetSocket, server, client);
                    throw ex;
                }


                //-----------------------------------------
                // Modify Request.
                // Proxy -> Server
                //-----------------------------------------
                try
                {
                    HttpHeader.ModifyProxyRequest(request._header);
                }catch (Exception ex) {
                    Close(serverSocket, clinetSocket, server, client);
                    throw ex;
                }



                //-----------------------------------------
                // Request.
                // Proxy -> Server
                //-----------------------------------------
                try
                {
                    HttpStream.Write(request, client);

                    //-----------------------------------------
                    // Observer.
                    //-----------------------------------------
                    if (listner != null)
                    {
                        request = listner.OnHttpRequestServer(request, server, client);
                    }
                }
                catch (Exception ex)
                {
                    Close(serverSocket, clinetSocket, server, client);
                    throw ex;
                }



                //-----------------------------------------
                // Response.
                // Proxy <- Server
                //-----------------------------------------
                HttpResponseObject response = null;
                try
                {
                    response = HttpStream.ReadResponse(client);
                    if (response == null)
                    {
                        break;
                    }

                    //-----------------------------------------
                    // Observer.
                    //-----------------------------------------
                    if (listner != null)
                    {
                        response = listner.OnHttpResponseClient(response, server, client);
                    }
                }
                catch (Exception ex)
                {
                    Close(serverSocket, clinetSocket, server, client);
                    throw ex;
                }



                //-----------------------------------------
                // Response.
                // Client <- Proxy
                //-----------------------------------------
                try
                {
                    HttpStream.Write(response, server);

                    //-----------------------------------------
                    // Observer.
                    //-----------------------------------------
                    if (listner != null)
                    {
                        response = listner.OnHttpResponseServer(response, server, client);
                    }
                }
                catch (Exception ex)
                {
                    Close(serverSocket, clinetSocket, server, client);
                    throw ex;
                }


                if (request._header._isKeepAllive == false || response._header._isKeepAllive == false)
                {
                    break;
                }
            }

            Close(serverSocket, clinetSocket, server, client);
        }
示例#6
0
 public HttpRequestObject OnHttpRequestServer(HttpRequestObject request, Stream serverStream, Stream clientStream)
 {
     _logger.OutputLog("Request Proxy -> Server");
     _logger.OutputLog(request._header._source);
     return(request);
 }
示例#7
0
 public static bool IsSslConnection(HttpRequestObject request)
 {
     return(request._header._method == HTTP_METHOD.CONNECT);
 }