private void WritePassword(MyCatPacket packet)
{
bool secure = (Flags & ClientFlags.SECURE_CONNECTION) != 0;
object password = GetPassword();
if (password is string)
{
if (secure)
{
packet.WriteLenString((string)password);
}
else
{
packet.WriteString((string)password);
}
}
else if (password == null)
{
packet.WriteByte(0);
}
else if (password is byte[])
{
packet.Write(password as byte[]);
}
else
{
throw new MyCatException("Unexpected password format: " + password.GetType());
}
}
private void AuthenticationChange()
{
MyCatPacket packet = driver.Packet;
packet.Clear();
byte[] moreData = MoreData(null);
while (moreData != null && moreData.Length > 0)
{
packet.Clear();
packet.Write(moreData);
driver.SendPacket(packet);
packet = ReadPacket();
byte prefixByte = packet.Buffer[0];
if (prefixByte != 1)
{
return;
}
// a prefix of 0x01 means need more auth data
byte[] responseData = new byte[packet.Length - 1];
Array.Copy(packet.Buffer, 1, responseData, 0, responseData.Length);
moreData = MoreData(responseData);
}
// we get here if MoreData returned null but the last packet read was a more data packet
ReadPacket();
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
MyCatGuid g = new MyCatGuid();
g.isNull = true;
g.OldGuids = OldGuids;
if (!nullVal)
{
if (OldGuids)
{
return(ReadOldGuid(packet, length));
}
string s = String.Empty;
if (length == -1)
{
s = packet.ReadLenString();
}
else
{
s = packet.ReadString(length);
}
g.mValue = new Guid(s);
g.isNull = false;
}
return(g);
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
decimal v = (val is decimal) ? (decimal)val : Convert.ToDecimal(val);
string valStr = v.ToString(CultureInfo.InvariantCulture);
if (binary)
packet.WriteLenString(valStr);
else
packet.WriteStringNoNull(valStr);
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
return new MyCatDecimal(true);
string s = String.Empty;
if (length == -1)
s = packet.ReadLenString();
else
s = packet.ReadString(length);
return new MyCatDecimal(s);
}
public void WriteValue(MyCatPacket packet, bool binary, object value, int length)
{
ulong v = (value is UInt64) ? (UInt64)value : Convert.ToUInt64(value);
if (binary)
{
packet.WriteInteger((long)v, 8);
}
else
{
packet.WriteStringNoNull(v.ToString());
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
long v = (val is Int64) ? (Int64)val : Convert.ToInt64(val);
if (binary)
{
packet.WriteInteger(v, 8);
}
else
{
packet.WriteStringNoNull(v.ToString());
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
double v = (val is double) ? (double)val : Convert.ToDouble(val);
if (binary)
{
packet.Write(BitConverter.GetBytes(v));
}
else
{
packet.WriteStringNoNull(v.ToString("R", CultureInfo.InvariantCulture));
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
sbyte v = (val is sbyte) ? (sbyte)val : Convert.ToSByte(val);
if (binary)
{
packet.WriteByte((byte)v);
}
else
{
packet.WriteStringNoNull(v.ToString());
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
int v = (val is Int32) ? (int)val : Convert.ToInt32(val);
if (binary)
{
packet.WriteInteger((long)v, is24Bit ? 3 : 4);
}
else
{
packet.WriteStringNoNull(v.ToString());
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object v, int length)
{
uint val = (v is uint) ? (uint)v : Convert.ToUInt32(v);
if (binary)
{
packet.WriteInteger((long)val, is24Bit ? 3 : 4);
}
else
{
packet.WriteStringNoNull(val.ToString());
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
int v = (val is UInt16) ? (UInt16)val : Convert.ToUInt16(val);
if (binary)
{
packet.WriteInteger((long)v, 2);
}
else
{
packet.WriteStringNoNull(v.ToString());
}
}
internal void Authenticate(bool reset)
{
CheckConstraints();
MyCatPacket packet = driver.Packet;
// send auth response
packet.WriteString(GetUsername());
// now write the password
WritePassword(packet);
if ((Flags & ClientFlags.CONNECT_WITH_DB) != 0 || reset)
{
if (!String.IsNullOrEmpty(Settings.Database))
{
packet.WriteString(Settings.Database);
}
}
if (reset)
{
packet.WriteInteger(8, 2);
}
if ((Flags & ClientFlags.PLUGIN_AUTH) != 0)
{
packet.WriteString(PluginName);
}
driver.SetConnectAttrs();
driver.SendPacket(packet);
//read server response
packet = ReadPacket();
byte[] b = packet.Buffer;
if (b[0] == 0xfe)
{
if (packet.IsLastPacket)
{
driver.Close(true);
throw new MyCatException(Resources.OldPasswordsNotSupported);
}
else
{
HandleAuthChange(packet);
}
}
driver.ReadOk(false);
AuthenticationSuccessful();
}
private MyCatPacket ReadPacket()
{
try
{
MyCatPacket p = driver.ReadPacket();
return(p);
}
catch (MyCatException ex)
{
// make sure this is an auth failed ex
AuthenticationFailed(ex);
return(null);
}
}
private MyCatGuid ReadOldGuid(MyCatPacket packet, long length)
{
if (length == -1)
{
length = (long)packet.ReadFieldLength();
}
byte[] buff = new byte[length];
packet.Read(buff, 0, (int)length);
MyCatGuid g = new MyCatGuid(buff);
g.OldGuids = OldGuids;
return(g);
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatTimeSpan(true));
}
if (length >= 0)
{
string value = packet.ReadString(length);
ParseMyCat(value);
return(this);
}
long bufLength = packet.ReadByte();
int negate = 0;
if (bufLength > 0)
{
negate = packet.ReadByte();
}
isNull = false;
if (bufLength == 0)
{
isNull = true;
}
else if (bufLength == 5)
{
mValue = new TimeSpan(packet.ReadInteger(4), 0, 0, 0);
}
else if (bufLength == 8)
{
mValue = new TimeSpan(packet.ReadInteger(4),
packet.ReadByte(), packet.ReadByte(), packet.ReadByte());
}
else
{
mValue = new TimeSpan(packet.ReadInteger(4),
packet.ReadByte(), packet.ReadByte(), packet.ReadByte(),
packet.ReadInteger(4) / 1000000);
}
if (negate == 1)
{
mValue = mValue.Negate();
}
return(this);
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
byte[] buffToWrite = (val as byte[]);
if (buffToWrite == null)
{
char[] valAsChar = (val as Char[]);
if (valAsChar != null)
{
buffToWrite = packet.Encoding.GetBytes(valAsChar);
}
else
{
string s = val.ToString();
if (length == 0)
{
length = s.Length;
}
else
{
s = s.Substring(0, length);
}
buffToWrite = packet.Encoding.GetBytes(s);
}
}
// we assume zero length means write all of the value
if (length == 0)
{
length = buffToWrite.Length;
}
if (buffToWrite == null)
{
throw new MyCatException("Only byte arrays and strings can be serialized by MyCatBinary");
}
if (binary)
{
packet.WriteLength(length);
packet.Write(buffToWrite, 0, length);
}
else
{
packet.WriteStringNoNull("X");
packet.WriteStringNoNull("\'");
packet.WriteStringNoNull(ToHexString(buffToWrite));
packet.WriteStringNoNull("\'");
}
}
private void SerializeText(MyCatPacket packet, MyCatDateTime value)
{
string val = String.Empty;
val = String.Format("{0:0000}-{1:00}-{2:00}",
value.Year, value.Month, value.Day);
if (type != MyCatDbType.Date)
{
val = value.Microsecond > 0 ? String.Format("{0} {1:00}:{2:00}:{3:00}.{4:000000}", val,
value.Hour, value.Minute, value.Second, value.Microsecond) : String.Format("{0} {1:00}:{2:00}:{3:00} ", val,
value.Hour, value.Minute, value.Second);
}
packet.WriteStringNoNull("'" + val + "'");
}
private void HandleAuthChange(MyCatPacket packet)
{
byte b = packet.ReadByte();
Debug.Assert(b == 0xfe);
string method = packet.ReadString();
byte[] authData = new byte[packet.Length - packet.Position];
Array.Copy(packet.Buffer, packet.Position, authData, 0, authData.Length);
MyCatAuthenticationPlugin plugin = MyCatAuthenticationPlugin.GetPlugin(method, driver, authData);
plugin.AuthenticationChange();
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
Guid guid = Guid.Empty;
string valAsString = val as string;
byte[] valAsByte = val as byte[];
if (val is Guid)
{
guid = (Guid)val;
}
else
{
try
{
if (valAsString != null)
{
guid = new Guid(valAsString);
}
else if (valAsByte != null)
{
guid = new Guid(valAsByte);
}
}
catch (Exception ex)
{
throw new MyCatException(Resources.DataNotInSupportedFormat, ex);
}
}
if (OldGuids)
{
WriteOldGuid(packet, guid, binary);
}
else
{
guid.ToString("D");
if (binary)
{
packet.WriteLenString(guid.ToString("D"));
}
else
{
packet.WriteStringNoNull("'" + MyCatHelper.EscapeString(guid.ToString("D")) + "'");
}
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatUInt16(true));
}
if (length == -1)
{
return(new MyCatUInt16((ushort)packet.ReadInteger(2)));
}
else
{
return(new MyCatUInt16(UInt16.Parse(packet.ReadString(length))));
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatInt64(true));
}
if (length == -1)
{
return(new MyCatInt64((long)packet.ReadULong(8)));
}
else
{
return(new MyCatInt64(Int64.Parse(packet.ReadString(length))));
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatSingle(true));
}
if (length == -1)
{
byte[] b = new byte[4];
packet.Read(b, 0, 4);
return(new MyCatSingle(BitConverter.ToSingle(b, 0)));
}
return(new MyCatSingle(Single.Parse(packet.ReadString(length),
CultureInfo.InvariantCulture)));
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatUByte(true));
}
if (length == -1)
{
return(new MyCatUByte((byte)packet.ReadByte()));
}
else
{
return(new MyCatUByte(Byte.Parse(packet.ReadString(length))));
}
}
private void WriteOldGuid(MyCatPacket packet, Guid guid, bool binary)
{
byte[] bytes = guid.ToByteArray();
if (binary)
{
packet.WriteLength(bytes.Length);
packet.Write(bytes);
}
else
{
packet.WriteStringNoNull("_binary ");
packet.WriteByte((byte)'\'');
EscapeByteArray(bytes, bytes.Length, packet);
packet.WriteByte((byte)'\'');
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatUInt32((this as IMyCatValue).MyCatDbType, true));
}
if (length == -1)
{
return(new MyCatUInt32((this as IMyCatValue).MyCatDbType,
(uint)packet.ReadInteger(4)));
}
else
{
return(new MyCatUInt32((this as IMyCatValue).MyCatDbType,
UInt32.Parse(packet.ReadString(length), NumberStyles.Any, CultureInfo.InvariantCulture)));
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
if (nullVal)
{
return(new MyCatByte(true));
}
if (length == -1)
{
return(new MyCatByte((sbyte)packet.ReadByte()));
}
else
{
string s = packet.ReadString(length);
MyCatByte b = new MyCatByte(SByte.Parse(s, NumberStyles.Any, CultureInfo.InvariantCulture));
b.TreatAsBoolean = TreatAsBoolean;
return(b);
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
string v = val.ToString();
if (length > 0)
{
length = Math.Min(length, v.Length);
v = v.Substring(0, length);
}
if (binary)
{
packet.WriteLenString(v);
}
else
{
packet.WriteStringNoNull("'" + MyCatHelper.EscapeString(v) + "'");
}
}
void IMyCatValue.WriteValue(MyCatPacket packet, bool binary, object val, int length)
{
if (!(val is TimeSpan))
{
throw new MyCatException("Only TimeSpan objects can be serialized by MyCatTimeSpan");
}
TimeSpan ts = (TimeSpan)val;
bool negative = ts.TotalMilliseconds < 0;
ts = ts.Duration();
if (binary)
{
if (ts.Milliseconds > 0)
{
packet.WriteByte(12);
}
else
{
packet.WriteByte(8);
}
packet.WriteByte((byte)(negative ? 1 : 0));
packet.WriteInteger(ts.Days, 4);
packet.WriteByte((byte)ts.Hours);
packet.WriteByte((byte)ts.Minutes);
packet.WriteByte((byte)ts.Seconds);
if (ts.Milliseconds > 0)
{
long mval = ts.Milliseconds * 1000;
packet.WriteInteger(mval, 4);
}
}
else
{
String s = String.Format("'{0}{1} {2:00}:{3:00}:{4:00}.{5:0000000}'",
negative ? "-" : "", ts.Days, ts.Hours, ts.Minutes, ts.Seconds, ts.Ticks % 10000000);
packet.WriteStringNoNull(s);
}
}
IMyCatValue IMyCatValue.ReadValue(MyCatPacket packet, long length, bool nullVal)
{
MyCatGeometry g;
if (nullVal)
{
g = new MyCatGeometry(_type, true);
}
else
{
if (length == -1)
{
length = (long)packet.ReadFieldLength();
}
byte[] newBuff = new byte[length];
packet.Read(newBuff, 0, (int)length);
g = new MyCatGeometry(_type, newBuff);
}
return(g);
}
