/// <summary>
/// Retrieves a <see cref="String"/> value
/// describing the given <see cref="SslStream"/>
/// value.
/// </summary>
/// <param name="stream">
/// For which to retrieve the <c>String</c> value.
/// </param>
/// <returns>
/// The corresponding value.
/// </returns>
internal static string SslStreamPropertiesToString(SslStream stream)
{
using (StringWriter writer = new StringWriter())
{
writer.WriteLine("------------------------- SSL Stream -----------------------");
writer.WriteLine("Check Cert Revocation Status : {0}", stream.CheckCertRevocationStatus);
writer.WriteLine("Cipher Algorithm : {0}", stream.CipherAlgorithm);
writer.WriteLine("Cipher Strength : {0}", stream.CipherStrength);
writer.WriteLine("Hash Algorithm : {0}", stream.HashAlgorithm);
writer.WriteLine("Hash Strength : {0}", stream.HashStrength);
writer.WriteLine("Is Authenticated : {0}", stream.IsAuthenticated);
writer.WriteLine("Is Encrypted : {0}", stream.IsEncrypted);
writer.WriteLine("Is MutuallyAuthenticated : {0}", stream.IsMutuallyAuthenticated);
writer.WriteLine("Key Exchange Algorithm : {0}", stream.KeyExchangeAlgorithm);
writer.WriteLine("Key Exchange Strength : {0}", stream.KeyExchangeStrength);
writer.WriteLine("Local Certificate :");
writer.WriteLine(HsqlDiagnostics.CertificateToString(stream.LocalCertificate));
writer.WriteLine("Read Timeout : {0}", stream.ReadTimeout);
writer.WriteLine("Remote Certificate :");
writer.WriteLine(HsqlDiagnostics.CertificateToString(stream.RemoteCertificate));
writer.WriteLine("Ssl Protocol : {0}", stream.SslProtocol);
writer.WriteLine("Write Timeout : {0}", stream.WriteTimeout);
writer.WriteLine();
writer.Flush();
return(writer.ToString());
}
}
/// <summary>
/// Implements the local certificate selection callback.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="targetHost">The target host.</param>
/// <param name="localCertificates">The local certificates.</param>
/// <param name="remoteCertificate">The remote certificate.</param>
/// <param name="acceptableIssuers">The acceptable issuers.</param>
/// <returns></returns>
protected virtual X509Certificate SelectLocalCertificate(
object sender,
string targetHost,
X509CertificateCollection localCertificates,
X509Certificate remoteCertificate,
string[] acceptableIssuers)
{
HsqlDiagnostics.Debug("Selection started....");
if (localCertificates == null)
{
HsqlDiagnostics.Debug("localCertificates == null");
}
else
{
if (acceptableIssuers == null)
{
HsqlDiagnostics.Debug("acceptableIssuers == null");
}
else
{
// Use the first certificate that is from an acceptable issuer.
HsqlDiagnostics.Debug(
"Searching {0} local certificates for acceptable issuer...",
localCertificates.Count);
for (int i = 0; i < localCertificates.Count; i++)
{
X509Certificate certificate = localCertificates[i];
string issuer = certificate.Issuer;
if (Array.IndexOf(acceptableIssuers, issuer) != -1)
{
HsqlDiagnostics.Debug("Acceptable issuer found.");
HsqlDiagnostics.Debug("Returning localCertificates[{0}]:", i);
HsqlDiagnostics.DebugCert(certificate);
return(certificate);
}
}
HsqlDiagnostics.Debug(
"Did not find a local certificate with an acceptable issuer.");
}
if (localCertificates.Count > 0)
{
HsqlDiagnostics.Debug("returning localCertificates[0]:");
HsqlDiagnostics.DebugCert(localCertificates[0]);
return(localCertificates[0]);
}
}
HsqlDiagnostics.Debug("returning null.");
return(null);
}
/// <summary>
/// Initializes the connection.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="port">The port.</param>
/// <param name="tls">
/// if set to <c>true</c>, use transport layer security.
/// </param>
/// <exception cref="HsqlException"></exception>
protected virtual void InitializeConnection(
string host,
int port,
bool tls)
{
HsqlDiagnostics.Debug("...");
OpenConnection(host, port, tls);
}
/// <summary>
/// Performs common instance-scope initialization.
/// </summary>
protected void InitializeInstance()
{
HsqlDiagnostics.Debug("...");
m_rowOutput = new RowOutputBinary(m_buffer);
m_rowInput = new RowInputBinary(m_rowOutput);
m_request = m_Protocol.CreateAttributeRequest();
m_autoCommit = true;
}
/// <summary>
/// Opens the connection.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="port">The port.</param>
/// <param name="tls">
/// if set to <c>true</c>, use transport layer security.
/// </param>
/// <exception cref="HsqlException">
/// </exception>
protected virtual void OpenConnection(
string host,
int port,
bool tls)
{
if (m_tcpClient != null)
{
throw new System.InvalidOperationException(
"The connection is already open.");
}
HsqlDiagnostics.Debug("...");
try
{
HsqlDiagnostics.Debug("Entered with arguments ({0},{1},{2})",
host, port, tls);
m_tcpClient = new TcpClient(host, port);
HsqlDiagnostics.Debug("Created TcpClient({0},{1})", host, port);
Stream stream = m_tcpClient.GetStream();
HsqlDiagnostics.Debug("Got client stream from TcpClient");
if (m_tls)
{
HsqlDiagnostics.Debug("Initializing Client TLS...");
SslStream sslStream = new SslStream(
stream,
false,
ValidateRemoteCertificate,
null);
HsqlDiagnostics.Debug("Invoking sslStream.AuthenticateAsClient({0})",
host);
sslStream.AuthenticateAsClient(host);
stream = sslStream;
}
JavaInputStreamAdapter input = new JavaInputStreamAdapter(stream);
JavaOutputStreamAdapter output = new JavaOutputStreamAdapter(stream);
m_dataInput = new DataInputStream(new BufferedInputStream(input));
m_dataOutput = new BufferedOutputStream(output);
}
catch (System.Exception e)
{
throw Trace.error(Trace.SOCKET_ERROR, e);
}
}
/// <summary>
/// Implements the remote certificate validation callback.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="certificate">The certificate.</param>
/// <param name="chain">The chain.</param>
/// <param name="sslPolicyErrors">The SSL policy errors.</param>
/// <returns>
/// <c>true</c> if validation succeeds;
/// <c>false</c> otherwise.
/// </returns>
protected virtual bool ValidateRemoteCertificate(
object sender,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
HsqlDiagnostics.Debug("...");
if (sslPolicyErrors == SslPolicyErrors.None)
{
// its all good.
return(true);
}
else
{
HsqlDiagnostics.Debug("Certificate error: {0}",
sslPolicyErrors);
return(false);
}
}
/// <summary>
/// Closes the connection.
/// </summary>
protected virtual void CloseConnection()
{
HsqlDiagnostics.Debug("...");
TcpClient tcpClient = m_tcpClient;
if (tcpClient != null)
{
try
{
tcpClient.Client.Close();
}
catch { }
try
{
tcpClient.Close();
}
catch { }
m_tcpClient = null;
}
}
/// <summary>
/// Writes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <exception cref="java.io.IOException"></exception>
/// <exception cref="org.hsqldb.HsqlException"></exception>
//[CLSCompliant(false)]
protected void WriteRequest(Request request)
{
HsqlDiagnostics.DebugRequest(request);
Request.write(request, m_rowOutput, m_dataOutput);
}
