/// <summary>
 /// Creates a new instance of the <see cref="EpoxyTlsConfig"/> class.
 /// </summary>
 /// <param name="remoteCertificateValidationCallback">
 /// Normal use is to omit this parameter/pass <c>null</c> so that the
 /// system's default behavior is used. Passing something other than
 /// null here is almost always a bug. This delegate is passed to
 /// <see cref="SslStream"/>; consult the SslStream documentation for
 /// more details about its use.
 /// </param>
 /// <param name="checkCertificateRevocation">
 /// Whether certificate revocation is checked. Defaults to <c>true</c>.
 /// </param>
 protected EpoxyTlsConfig(
     RemoteCertificateValidationCallback remoteCertificateValidationCallback = null,
     bool checkCertificateRevocation = true)
 {
     RemoteCertificateValidationCallback = remoteCertificateValidationCallback;
     CheckCertificateRevocation = checkCertificateRevocation;
 }

        internal static SslStream ManageClientRequest(TcpClient client)
        {
            SslStream sslStream = null;

            try
            {
                bool leaveInnerStreamOpen = true;

                RemoteCertificateValidationCallback validationCallback =
                    new RemoteCertificateValidationCallback(ClientValidationCallback);
                LocalCertificateSelectionCallback selectionCallback =
                    new LocalCertificateSelectionCallback(ServerCertificateSelectionCallback);
                EncryptionPolicy encryptionPolicy = EncryptionPolicy.AllowNoEncryption;

                sslStream = new SslStream(client.GetStream(), leaveInnerStreamOpen, validationCallback, selectionCallback, encryptionPolicy);
                Console.WriteLine("Server starting handshake");
                ServerSideHandshake(sslStream);
                Console.WriteLine("Server finished handshake");
            }
            catch(Exception ex)
            {
                sslStream = null;
                Console.WriteLine("\nError detected in sslStream: " + ex.Message);
            }
            return sslStream;
        }

 public MailClient(string hostname, int port, bool isSecure = false, RemoteCertificateValidationCallback validate = null)
 {
     this.hostName = hostname;
     this.port = port;
     this.isSecure = isSecure;
     this.validate = validate;
 }

        internal static SslStream ManageServerRequest(TcpClient client, String connectToIP)
        {
            SslStream sslStream = null;
            try
            {
                bool leaveInnerStreamOpen = true;

                RemoteCertificateValidationCallback validationCallback =
                    new RemoteCertificateValidationCallback(ServerValidationCallback);

                LocalCertificateSelectionCallback selectionCallback =
                    new LocalCertificateSelectionCallback(ClientCertificateSelectionCallback);

                EncryptionPolicy encryptionPolicy = EncryptionPolicy.NoEncryption;

                sslStream = new SslStream(client.GetStream(), leaveInnerStreamOpen, validationCallback, selectionCallback, encryptionPolicy);
                Console.WriteLine("Client starting handshake");
                ClientSideHandshake(sslStream, connectToIP);
                Console.WriteLine("client finished handshake");
            }
            catch(AuthenticationException ex)
            {
                Console.WriteLine("\nAuthentication Exception: " + ex.Message);
            }
            catch(Exception ex)
            {
                Console.WriteLine("\nError detected: " + ex.Message);
            }

            return sslStream;
        }

        public TTlsServerSocketTransport(
            int port,
            bool useBufferedSockets,
            X509Certificate2 certificate,
            RemoteCertificateValidationCallback clientCertValidator = null,
            LocalCertificateSelectionCallback localCertificateSelectionCallback = null,
            SslProtocols sslProtocols = SslProtocols.Tls12)
        {
            if (!certificate.HasPrivateKey)
            {
                throw new TTransportException(TTransportException.ExceptionType.Unknown,
                    "Your server-certificate needs to have a private key");
            }

            _port = port;
            _serverCertificate = certificate;
            _useBufferedSockets = useBufferedSockets;
            _clientCertValidator = clientCertValidator;
            _localCertificateSelectionCallback = localCertificateSelectionCallback;
            _sslProtocols = sslProtocols;

            try
            {
                // Create server socket
                _server = new TcpListener(IPAddress.Any, _port);
                _server.Server.NoDelay = true;
            }
            catch (Exception)
            {
                _server = null;
                throw new TTransportException($"Could not create ServerSocket on port {port}.");
            }
        }

 protected MailClient(string host, int port, bool isSsl, RemoteCertificateValidationCallback validate)
 {
     HostName = host;
     PortNo = port;
     IsSsl = isSsl;
     Validate = validate;
 }

 public SslStream(
   NetworkStream innerStream,
   bool leaveInnerStreamOpen,
   RemoteCertificateValidationCallback userCertificateValidationCallback
 ) : base(innerStream, leaveInnerStreamOpen, userCertificateValidationCallback)
 {
 }

		internal static MSI.MonoRemoteCertificateValidationCallback PublicToMono (RemoteCertificateValidationCallback callback)
		{
			if (callback == null)
				return null;

			return (h, c, ch, e) => callback (h, c, (X509Chain)(object)ch, (SslPolicyErrors)e);
		}

        public SecureTcpServer(int listenPort, X509Certificate serverCertificate,
            SecureConnectionResultsCallback callback,
            RemoteCertificateValidationCallback certValidationCallback)
        {
            if (listenPort < 0 || listenPort > UInt16.MaxValue)
                throw new ArgumentOutOfRangeException("listenPort");

            if (serverCertificate == null)
                throw new ArgumentNullException("serverCertificate");

            if (callback == null)
                throw new ArgumentNullException("callback");

            onAcceptConnection = new AsyncCallback(OnAcceptConnection);
            onAuthenticateAsServer = new AsyncCallback(OnAuthenticateAsServer);

            this.serverCert = serverCertificate;
            this.certValidationCallback = certValidationCallback;
            this.connectionCallback = callback;
            this.listenPort = listenPort;
            this.disposed = 0;
            this.checkCertifcateRevocation = false;
            this.clientCertificateRequired = false;
            this.sslProtocols = SslProtocols.Default;
        }

        internal TcpClientAdapter()
        {
            _sendQueue = new Queue<SendState>();

            _sendCallback = new AsyncCallback(sendHandler);
            _receiveCallback = new AsyncCallback(receiveHandler);
            _certCallback = new RemoteCertificateValidationCallback(ValidateCert);
        }

        /// <summary>
        /// Initialises ssl client as a client side endpoint.
        /// </summary>
        public SslClient(IRawByteClient client,
                         string targetHost,
                         RemoteCertificateValidationCallback remoteCertificateValidationCallback)
        {
            Ensure.IsNotNull(client, "client");
            Ensure.IsNotNullOrWhiteSpace(targetHost, "targetHost");

            InitializeAsClient(client, targetHost, remoteCertificateValidationCallback);
        }

        /// <summary>
        /// Initializes a new instance of a <see cref="BaseHttpQrCodeProvider"/>.
        /// </summary>
        /// <param name="baseUri">The base Uri for the QR code provider.</param>
        /// <param name="remoteCertificateValidationCallback">
        /// The <see cref="RemoteCertificateValidationCallback"/> to be used by the QR code provider.
        /// </param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="baseUri"/> is null.</exception>
        protected BaseHttpQrCodeProvider(Uri baseUri, RemoteCertificateValidationCallback remoteCertificateValidationCallback)
        {
            if (baseUri == null)
                throw new ArgumentNullException("baseUri");
            this.BaseUri = baseUri;

            this.RemoteCertificateValidationCallback = remoteCertificateValidationCallback;
            this.TimeOut = DEFAULTTIMEOUT;
        }

        //private string hostname, username, password;
        public static void UploadFiles(ConfigurationProfile profile, string temppath, string remotedir)
        {
            // Setup session options
            // add support for: scp/sftp protocols, ssh host/private keys, active/passive mode, port, FtpSecure, timeout, ssl cert,

            using (FTPSClient session = new FTPSClient())
            {

                ESSLSupportMode sslSupportMode = ESSLSupportMode.ClearText;
                RemoteCertificateValidationCallback userValidateServerCertificate;
                userValidateServerCertificate = new RemoteCertificateValidationCallback(ValidateServerCertificate);

                // enable encryption if desired
                if (profile.Encryption.IsTrue())
                {
                    sslSupportMode |= ESSLSupportMode.ControlAndDataChannelsRequired | ESSLSupportMode.CredentialsRequired;
                    if (profile.EncryptionImplicit.IsTrue())
                    {
                        // implicit if desired
                        sslSupportMode |= ESSLSupportMode.Implicit;
                    }
                    if (profile.ForceEncryption.IsTrue())
                    {
                        // force encryption if desired
                        userValidateServerCertificate = new RemoteCertificateValidationCallback(delegate { return true; });
                    }
                }

                session.Connect(profile.Hostname, new System.Net.NetworkCredential(profile.Username, profile.Password), sslSupportMode, userValidateServerCertificate);

                // Upload files
                //TransferOptions transferOptions = new TransferOptions();
                //transferOptions.TransferMode = TransferMode.Binary;

                //TransferOperationResult transferResult;
                //transferResult = session.PutFiles(Path.Combine(temppath, "*"), Common.Parse(remotedir), false, transferOptions);

                try
                {
                    session.SetCurrentDirectory(Common.ParseTemplate(remotedir));
                }
                catch
                {
                    session.MakeDir(Common.ParseTemplate(remotedir));
                }
                session.PutFiles(temppath, Common.ParseTemplate(remotedir), "*", EPatternStyle.Wildcard, false, new FileTransferCallback(TransferCallback));

                // Throw on any error
                //transferResult.Check();

                // Print results
                //foreach (TransferEventArgs transfer in transferResult.Transfers)
                //{
                //    Console.WriteLine("Upload of {0} succeeded", transfer.FileName);
                //}
            }
        }

 /// <summary>
 /// 表示SSL客户端会话对象
 /// </summary>  
 /// <param name="targetHost">目标主机</param>
 /// <param name="certificateValidationCallback">远程证书验证回调</param>
 /// <exception cref="ArgumentNullException"></exception>
 public SslTcpSession(string targetHost, RemoteCertificateValidationCallback certificateValidationCallback)
 {
     if (string.IsNullOrEmpty(targetHost) == true)
     {
         throw new ArgumentNullException("targetHost");
     }
     this.targetHost = targetHost;
     this.certificateValidationCallback = certificateValidationCallback;
 }

        public SslCertificateValidator(bool acceptAll, string[] validHashes)
        {
            m_acceptAll = acceptAll;
            m_validHashes = validHashes;
            m_oldCallback = System.Net.ServicePointManager.ServerCertificateValidationCallback;

            System.Net.ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertficate);
            m_isAttached = true;
        }

        private void connect(string host, int port, bool isSsl, RemoteCertificateValidationCallback validate)
        {
            if (_client == null)
            {
                _client = new TcpClient { ReceiveTimeout = 20000 };
            }

            if (!_client.Connected)
            {
                try
                {
                    _client.Connect(host, port);
                }
                catch (SocketException ex)
                {
                    var retVal = string.Empty;
                    switch (ex.ErrorCode)
                    {
                        case 11001: // Host not found.
                            retVal = ex.Message;
                            break;
                        case 10060: //Connection timed out.  (invalid portNo) (yahoo,hotmail and indiatimes)
                        case 10061: //Connection refused.
                        case 10013: // Permission denied. from hotmail
                            retVal = "Invalid host or port number";
                            break;
                        default:
                            retVal = "Invalid host or port number";
                            break;
                    }

                    throw new Exception(retVal);
                }
            }

            if (_client.Connected)
            {
                _stream = _client.GetStream();
                if (isSsl)
                {
                    try
                    {
                        var sslStream = new SslStream(_stream, false, validate ?? ((sender, cert, chain, err) => true));
                        sslStream.AuthenticateAsClient(host);
                        _stream = sslStream;
                    }
                    catch(Exception)
                    {
                        throw;
                    }
                }

                var response = ReadResponse();

                ValidateResponse(response);
            }
        }

		public DotNetSslStreamImpl (
			Stream innerStream, bool leaveInnerStreamOpen,
			RemoteCertificateValidationCallback userCertificateValidationCallback,
			LocalCertificateSelectionCallback userCertificateSelectionCallback)
		{
			impl = new SslStream (
				innerStream, leaveInnerStreamOpen,
				userCertificateValidationCallback,
				userCertificateSelectionCallback);
		}

 /// <summary>
 /// Create a new HTTPClient using the given optional parameters.
 /// </summary>
 /// <param name="RemoteSocket">The remote IP socket to connect to.</param>
 /// <param name="RemoteCertificateValidator">A delegate to verify the remote TLS certificate.</param>
 /// <param name="ClientCert">The TLS client certificate to use.</param>
 /// <param name="DNSClient">An optional DNS client.</param>
 public HTTPSClient(IPSocket                             RemoteSocket,
                    RemoteCertificateValidationCallback  RemoteCertificateValidator,
                    X509Certificate                      ClientCert  = null,
                    DNSClient                            DNSClient   = null)
     : base(RemoteSocket,
            RemoteCertificateValidator,
            ClientCert,
            DNSClient)
 {
 }

        /// <summary>
        ///     Creates new instance of <see cref="HttpProxy" /> using provided default port and internal buffer size.
        /// </summary>
        /// <param name="defaultPort">
        ///     Port number on destination server which will be used if not specified in request
        /// </param>
        /// <param name="certificate">
        ///     Certificate used for server authentication
        /// </param>
        /// <param name="rcValidationCallback">
        ///     Used to validate destination server certificate. By default it accepts anything provided by server
        /// </param>
        public SslProxy(X509Certificate certificate, Int32 defaultPort,
            RemoteCertificateValidationCallback rcValidationCallback = null)
            : base(defaultPort)
        {
            Contract.Requires<ArgumentNullException>(certificate != null, "certificate");

            _certificateValidationCallback = rcValidationCallback ?? DefaultCertificateValidationCallback;

            _certificate = certificate;
        }

        /// <include file='../../../_Doc/System.xml' path='doc/members/member[@name="M:System.Net.Security.SslStream.#ctor(System.IO.Stream,System.Boolean,System.Net.Security.RemoteCertificateValidationCallback)"]/*' />
        public SslStream(Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback)
        {
            var tcpClientStream = innerStream as NetworkStream;
            if (tcpClientStream == null)
                throw new ArgumentException("Stream type not associated with TCP client", "innerStream");

            _innerStream = tcpClientStream;
            _leaveInnerStreamOpen = leaveInnerStreamOpen;
            this.userCertificateValidationCallback = userCertificateValidationCallback;
        }