public WebConnectionGroup (ServicePoint sPoint, string name)
		{
			this.sPoint = sPoint;
			this.name = name;
			connections = new ArrayList (1);
			queue = new Queue ();
		}

        internal bool Invoke(string hostName,
                             ServicePoint servicePoint,
                             X509Certificate certificate,
                             WebRequest request,
                             X509Chain chain,
                             SslPolicyErrors sslPolicyErrors)
        {
            PolicyWrapper policyWrapper = new PolicyWrapper(m_CertificatePolicy,
                                                            servicePoint,
                                                            (WebRequest) request);

            if (m_Context == null)
            {
                return policyWrapper.CheckErrors(hostName,
                                                 certificate,
                                                 chain,
                                                 sslPolicyErrors);
            }
            else
            {
                ExecutionContext execContext = m_Context.CreateCopy();
                CallbackContext callbackContext = new CallbackContext(policyWrapper,
                                                                      hostName,
                                                                      certificate,
                                                                      chain,
                                                                      sslPolicyErrors);
                ExecutionContext.Run(execContext, Callback, callbackContext);
                return callbackContext.result;
            }
        }

 public bool CheckValidationResult(ServicePoint sPoint,
     System.Security.Cryptography.X509Certificates.X509Certificate cert,
     WebRequest wRequest, int certProb)
 {
     // Always accept
     return true;
 }

      // ICertificatePolicy
      public bool CheckValidationResult(ServicePoint sp, X509Certificate cert, WebRequest request, int problem) {
         if (problem == 0) {
            // Check whether we have accumulated any problems so far:
            ArrayList problemArray = (ArrayList) request2problems_[request];
            if (problemArray == null) {
               // No problems so far
               return true;
            }

            string problemList = "";
            foreach (uint problemCode in problemArray) {
               string problemText = (string) problem2text_[problemCode];
               if (problemText == null) {
                  problemText = "Unknown problem";
               }
               problemList += "* " + problemText + "\n\n";
            }

            request2problems_.Remove(request);
            System.Console.WriteLine("There were one or more problems with the server certificate:\n\n" + problemList);
            return true;


         } else {
            // Stash the problem in the problem array:
            ArrayList problemArray = (ArrayList) request2problems_[request];
            if (problemArray == null) {
               problemArray = new ArrayList();
               request2problems_[request] = problemArray;
            }
            problemArray.Add((uint) problem);
            return true;
         }
      }   

        //
        // This version of an Ssl Stream is for internal HttpWebrequest use.
        // This Ssl client owns the underlined socket
        // The TlsStream will own secured read/write and disposal of the passed "networkStream" stream.
        //
        public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext)
               :base(networkStream, true) {

        // WebRequest manages the execution context manually so we have to ensure we get one for SSL client certificate demand
        _ExecutionContext = executionContext;
        if (_ExecutionContext == null)
        {
            _ExecutionContext = ExecutionContext.Capture();
        }

        // 


         GlobalLog.Enter("TlsStream::TlsStream", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "none" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));
         if (Logging.On) Logging.PrintInfo(Logging.Web, this, ".ctor", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo)));

         m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure;
         m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy);

         m_DestinationHost = destinationHost;
         m_ClientCertificates = clientCertificates;

         RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest);
         m_Worker.SetCertValidationDelegate(certValidationCallback);

         // The Handshake is NOT done at this point
         GlobalLog.Leave("TlsStream::TlsStream (Handshake is not done)");
        }

        public bool CheckValidationResult(ServicePoint sp, 
						   X509Certificate certificate,
						   WebRequest request,
						   int error)
        {
            return true;
        }

 public bool CheckValidationResult(ServicePoint sp,
     X509Certificate cert,
     WebRequest req,
     int problem)
 {
     return true;
 }

 public bool CheckValidationResult(ServicePoint sp, 
     System.Security.Cryptography.X509Certificates.X509Certificate crt,
     WebRequest req, 
     int problem)
 {
     return true;
 }

        public bool CheckValidationResult(ServicePoint sp, X509Certificate cert, WebRequest request, int problem)
        {
            if (problem == -2146762487 || problem == 0 || problem == -2146762481)
                return true;

            return false;
        }

 internal IAsyncResult BeginGetConnection(ServicePoint servicePoint, ContextAwareResult outerResult, AsyncCallback callback, object state)
 {
     IAsyncResult result = null;
     try
     {
         this.UpdateServicePoint(servicePoint);
         this.connection = new SmtpConnection(this, this.client, this.credentials, this.authenticationModules);
         this.connection.Timeout = this.timeout;
         if (Logging.On)
         {
             Logging.Associate(Logging.Web, this, this.connection);
         }
         if (this.EnableSsl)
         {
             this.connection.EnableSsl = true;
             this.connection.ClientCertificates = this.ClientCertificates;
         }
         result = this.connection.BeginGetConnection(servicePoint, outerResult, callback, state);
     }
     catch (Exception exception)
     {
         throw new SmtpException(SR.GetString("MailHostNotFound"), exception);
     }
     return result;
 }

 public bool CheckValidationResult(ServicePoint srvPoint,
     X509Certificate certificate, WebRequest request,
     int certificateProblem)
 {
     //Return True to force the certificate to be accepted.
     return true;
 }

            public bool CheckValidationResult(ServicePoint sp, X509Certificate cert,
            WebRequest request, int problem)
            {
                var validationResult = true;
                                
                if (IssuerName != "[email protected]==")
                    if (!cert.Issuer.ToUpper().Contains(IssuerName.ToUpper().Trim())) return false;

                var chain = new X509Chain();


                chain.Build(new X509Certificate2(cert));

                foreach (X509ChainElement e in chain.ChainElements)
                {
                    foreach (X509ChainStatus s in e.ChainElementStatus)
                    {
                        if (((X509ChainStatusFlags.Revoked | X509ChainStatusFlags.NotTimeValid
                            | X509ChainStatusFlags.NotSignatureValid | X509ChainStatusFlags.InvalidExtension
                            | X509ChainStatusFlags.NotValidForUsage | X509ChainStatusFlags.Cyclic) & s.Status) == s.Status)
                        {
                            validationResult = false;
                        }
                    }
                }

                return validationResult;
            }

		public WebConnectionGroup (ServicePoint sPoint, string name)
		{
			this.sPoint = sPoint;
			this.name = name;
			connections = new LinkedList<ConnectionState> ();
			queue = new Queue ();
		}

 public bool CheckValidationResult(
     ServicePoint srvPoint,
     X509Certificate certificate,
     WebRequest request,
     int certificateProblem)
 {
     return true;
 }

        public bool CheckValidationResult(ServicePoint service_point,
		                                   X509Certificate certificate,
		                                   WebRequest request,
						   int problem)
        {
            Log.Warning ("Blindly trusting " + request.RequestUri);
            return true;
        }

 //
 // Constructors
 //
 internal ConnectionGroup(ServicePoint servicePoint, string connName) {
     m_ServicePoint      = servicePoint;
     m_ConnectionLimit   = servicePoint.ConnectionLimit;
     m_ConnectionList    = new ArrayList(DefaultConnectionListSize); //it may grow beyond
     m_Name              = MakeQueryStr(connName);
     m_AbortDelegate     = new HttpAbortDelegate(Abort);
     GlobalLog.Print("ConnectionGroup::.ctor m_ConnectionLimit:" + m_ConnectionLimit.ToString());
 }

 /// <summary>
 /// Used internally as callback delegate for the <see cref="ServicePoint.BindIPEndPointDelegate"/> property
 /// in <see cref="HttpWebRequest.ServicePoint"/>.
 /// </summary>
 /// <param name="servicePoint">The service point which is currently being bound.</param>
 /// <param name="remoteEndPoint">The desired remote endoint to reach.</param>
 /// <param name="preferredLocalIpAddress">Address which specifies the preferred local endpoint. This address is not part of the delegate
 /// signature and must be provided from outside.</param>
 /// <param name="retryCount">The number of times this delegate was called for a specified connection.</param>
 /// <returns>The local IPEndPoint to which the ServicePoint should bind.</returns>
 public static IPEndPoint BindIPEndPointCallback(ServicePoint servicePoint, IPEndPoint remoteEndPoint,
     IPAddress preferredLocalIpAddress, int retryCount)
 {
   if (retryCount > 0)
     return null;
   IPEndPoint ipe = new IPEndPoint(preferredLocalIpAddress, 0);
   return ipe;
 }

 // Default policy for certificate validation.
 // public static bool DefaultValidate = false;
 public bool CheckValidationResult(ServicePoint sp, X509Certificate cert, WebRequest request, int problem)
 {
     //bool ValidationResult = false;
        //Console.WriteLine("Certificate Problem with accessing " + request.RequestUri);
        //Console.Write("Problem code 0x{0:X8},", (int)problem);
        //Console.WriteLine(GetProblemMessage((CertificateProblem)problem));
        //ValidationResult = DefaultValidate;
        return true;
 }

        public bool CheckValidationResult(ServicePoint srvPoint, X509Certificate certificate, WebRequest request, int certificateProblem)
        {
            // Don't care about any certificate issues, always accept.
            // More information can be found on:
            //    - http://www.mono-project.com/UsingTrustedRootsRespectfully
            //    - http://www.mono-project.com/FAQ:_Security

            return true;
        }

		/// <summary>
		/// Simulates a certificate verification.
		/// </summary>
		/// <param name="sp">The associated ServicePoint.</param>
		/// <param name="cert">The certificate to examine.</param>
		/// <param name="req">The WebRequest to use.</param>
		/// <param name="problem">I have no idea.</param>
		/// <returns>Always returns true.</returns>
		public bool CheckValidationResult(ServicePoint sp, System.Security.Cryptography.X509Certificates.X509Certificate cert, WebRequest req, int problem) {
			try {
				Debug.WriteLine("ICertificatePolicy: Address: " + sp.Address);
				Debug.WriteLine("ICertificatePolicy: ProtocolVersion: " + sp.ProtocolVersion);
				Debug.WriteLine("ICertificatePolicy: Expect100Continue: " + sp.Expect100Continue);
			} catch(Exception ex) {
				Debug.WriteLine("ICertificatePolicy: Exception: " + ex.Message);
			}
			return true;
		}