public void Close(bool isOpen)
{
try
{
if (isOpen)
{
try
{
packet.Clear();
packet.WriteByte((byte)DBCmd.QUIT);
ExecutePacket(packet);
}
catch (Exception)
{
// Eat exception here. We should try to closing
// the stream anyway.
}
}
if (stream != null)
{
stream.Close();
}
stream = null;
}
catch (Exception)
{
// we are just going to eat any exceptions
// generated here
}
}
private async void StartSSL()
{
RemoteCertificateValidationCallback sslValidateCallback =
new RemoteCertificateValidationCallback(ServerCheckValidation);
SslStream ss = new SslStream(baseStream, true, sslValidateCallback, null);
X509CertificateCollection certs = GetClientCertificates();
await ss.AuthenticateAsClientAsync(Settings.Server, certs, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12, false);
baseStream = ss;
stream = new MyCatStream(ss, Encoding, false);
stream.SequenceByte = 2;
}
private void ReadNextPacket(int len)
{
if (!Platform.IsMono())
{
inBuffer = inBufferRef.Target as byte[];
}
if (inBuffer == null || inBuffer.Length < len)
{
inBuffer = new byte[len];
}
MyCatStream.ReadFully(baseStream, inBuffer, 0, len);
}
private void PrepareNextPacket()
{
MyCatStream.ReadFully(baseStream, lengthBytes, 0, 7);
int compressedLength = lengthBytes[0] + (lengthBytes[1] << 8) + (lengthBytes[2] << 16);
// lengthBytes[3] is seq
int unCompressedLength = lengthBytes[4] + (lengthBytes[5] << 8) +
(lengthBytes[6] << 16);
if (unCompressedLength == 0)
{
unCompressedLength = compressedLength;
zInStream = null;
}
else
{
ReadNextPacket(compressedLength);
MemoryStream ms = new MemoryStream(inBuffer);
zInStream = new ZInputStream(ms);
zInStream.maxInput = compressedLength;
}
inPos = 0;
maxInPos = unCompressedLength;
}
public void Open()
{
// connect to one of our specified hosts
try
{
baseStream = StreamCreator.GetStream(Settings);
#if NET451
if (Settings.IncludeSecurityAsserts)
{
MyCatSecurityPermission.CreatePermissionSet(false).Assert();
}
#endif
}
catch (System.Security.SecurityException)
{
throw;
}
catch (Exception ex)
{
throw new MyCatException(Resources.UnableToConnectToHost,
(int)MyCatErrorCode.UnableToConnectToHost, ex);
}
if (baseStream == null)
{
throw new MyCatException(Resources.UnableToConnectToHost,
(int)MyCatErrorCode.UnableToConnectToHost);
}
int maxSinglePacket = 255 * 255 * 255;
stream = new MyCatStream(baseStream, Encoding, false);
stream.ResetTimeout((int)Settings.ConnectionTimeout * 1000);
// read off the welcome packet and parse out it's values
packet = stream.ReadPacket();
int protocol = packet.ReadByte();
string versionString = packet.ReadString();
owner.isFabric = versionString.EndsWith("fabric", StringComparison.OrdinalIgnoreCase);
version = DBVersion.Parse(versionString);
if (!owner.isFabric && !version.isAtLeast(5, 0, 0))
{
throw new NotSupportedException(Resources.ServerTooOld);
}
threadId = packet.ReadInteger(4);
encryptionSeed = packet.ReadString();
maxSinglePacket = (256 * 256 * 256) - 1;
// read in Server capabilities if they are provided
ClientFlags serverCaps = 0;
if (packet.HasMoreData)
{
serverCaps = (ClientFlags)packet.ReadInteger(2);
}
/* New protocol with 16 bytes to describe server characteristics */
owner.ConnectionCharSetIndex = (int)packet.ReadByte();
serverStatus = (ServerStatusFlags)packet.ReadInteger(2);
// Since 5.5, high bits of server caps are stored after status.
// Previously, it was part of reserved always 0x00 13-byte filler.
uint serverCapsHigh = (uint)packet.ReadInteger(2);
serverCaps |= (ClientFlags)(serverCapsHigh << 16);
packet.Position += 11;
string seedPart2 = packet.ReadString();
encryptionSeed += seedPart2;
string authenticationMethod = "";
if ((serverCaps & ClientFlags.PLUGIN_AUTH) != 0)
{
authenticationMethod = packet.ReadString();
}
else
{
// Some MyCat versions like 5.1, don't give name of plugin, default to native password.
authenticationMethod = "mysql_native_password";
}
// based on our settings, set our connection flags
SetConnectionFlags(serverCaps);
packet.Clear();
packet.WriteInteger((int)connectionFlags, 4);
if ((serverCaps & ClientFlags.SSL) == 0)
{
if ((Settings.SslMode != MyCatSslMode.None) &&
(Settings.SslMode != MyCatSslMode.Preferred))
{
// Client requires SSL connections.
string message = String.Format(Resources.NoServerSSLSupport,
Settings.Server);
throw new MyCatException(message);
}
}
else if (Settings.SslMode != MyCatSslMode.None)
{
stream.SendPacket(packet);
StartSSL();
packet.Clear();
packet.WriteInteger((int)connectionFlags, 4);
}
packet.WriteInteger(maxSinglePacket, 4);
packet.WriteByte(8);
packet.Write(new byte[23]);
Authenticate(authenticationMethod, false);
// if we are using compression, then we use our CompressedStream class
// to hide the ugliness of managing the compression
if ((connectionFlags & ClientFlags.COMPRESS) != 0)
{
stream = new MyCatStream(baseStream, Encoding, true);
}
// give our stream the server version we are connected to.
// We may have some fields that are read differently based
// on the version of the server we are connected to.
packet.Version = version;
stream.MaxBlockSize = maxSinglePacket;
}
