static private void ReceiveThread(object Param)
{
Logger.WriteLine($"Receive thread started with id {Task.CurrentId}");
SharedObject data = (SharedObject)Param;
while (!data.Ended)
{
data.Socket.ReceiveTimeout = (int)PacketsProps.WAIT_TIME;
try
{
CommunicationPacket p = CommunicationFacade.Receive(data.Socket);
UInt64 currentPoint;
lock (data.CountersLocker)
currentPoint = data.Confirmed;
UInt64 confirmationNumber = CommunicationFacade.ComputeRealNumber(p.ConfirmationNumber, currentPoint, UInt16.MaxValue, (uint)Sizes.WINDOW_SIZE);
UploadRecvPacket recv = new UploadRecvPacket(p.ConnectionNumber, p.Flags, p.Data, confirmationNumber);
lock (data.ArriveQueue)
data.ArriveQueue.Enqueue(recv);
}
catch (SocketException e) when(e.SocketErrorCode == SocketError.TimedOut)
{
}
}
}
private void ProcessNotice(CommunicationPacket packet, BaseResult rs)
{
Frame frame = Frame.Parser.ParseFrom(packet.Buffer);
if (frame.Scope == Frame.Types.Scope.Global)
{
ProcessGlobalNotice(frame);
return;
}
// if we get here the notice is local
switch ((NoticeType)frame.Type)
{
case NoticeType.Warning:
ProcessWarning(rs, frame.Payload.ToByteArray());
break;
case NoticeType.SessionStateChanged:
ProcessSessionStateChanged(rs, frame.Payload.ToByteArray());
break;
case NoticeType.SessionVariableChanged:
break;
}
}
public static UInt32 InitConnection(Socket socket, Command action)
{
int i = 0;
socket.ReceiveTimeout = 100;
while (i < 20)
{
CommunicationFacade.Send(socket, new CommunicationPacket(0, 0, 0, (byte)Flag.SYN, new byte[] { (byte)action }));
try
{
while (true)
{
CommunicationPacket recived = CommunicationFacade.Receive(socket);
if (recived.Flags == (byte)Flag.SYN && recived.Data[0] == (byte)action && recived.SerialNumber == 0 && recived.ConfirmationNumber == 0)
{
Logger.WriteLine($"Connection established - communication {recived.ConnectionNumber:X}");
socket.ReceiveTimeout = 0;
return(recived.ConnectionNumber);
}
else
{
Console.WriteLine("Data obtained before connection packet received, ignoring");
}
}
}
catch (SocketException e) when(e.SocketErrorCode == SocketError.TimedOut)
{
Logger.WriteLine($"Connection timeouted, attemp number {i + 1}");
i++;
}
}
throw new Exceptions.MaximumAttempException();
}
public override bool HasData(BaseResult rs)
{
while (true)
{
CommunicationPacket packet = PeekPacket();
switch (packet.MessageType)
{
case (int)ServerMessageId.RESULTSET_COLUMN_META_DATA:
return(true);
case (int)ServerMessageId.NOTICE:
ProcessNotice(packet, rs);
packet = ReadPacket();
break;
case (int)ServerMessageId.ERROR:
packet = ReadPacket();
DecodeAndThrowError(packet);
break;
default:
return(false);
}
}
}
public static void Send(Socket socket, CommunicationPacket p)
{
if (p.Data.Length > 255)
{
throw new ArgumentException("Data have more then 255 bytes");
}
Logger.WriteLine($"SEND from={p.ConnectionNumber:X} seq={p.SerialNumber} conf={p.ConfirmationNumber} flags={Convert.ToString(p.Flags, 2)} data({p.Data.Length})={getDataInString(p.Data)}", ConsoleColor.Green);
//F*****g rotate it, because that f*****g image send data as f*****g big endian
UInt32 connectionNumber = p.ConnectionNumber;
UInt16 serialNumber = p.SerialNumber;
UInt16 confirmationNumber = p.ConfirmationNumber;
if (BitConverter.IsLittleEndian)
{
connectionNumber = BitConverter.ToUInt32(BitConverter.GetBytes(connectionNumber).Reverse().ToArray(), 0);
serialNumber = BitConverter.ToUInt16(BitConverter.GetBytes(serialNumber).Reverse().ToArray(), 0);
confirmationNumber = BitConverter.ToUInt16(BitConverter.GetBytes(confirmationNumber).Reverse().ToArray(), 0);
}
BitConverter.GetBytes(connectionNumber).CopyTo(outBuffer, 0);
BitConverter.GetBytes(serialNumber).CopyTo(outBuffer, 4);
BitConverter.GetBytes(confirmationNumber).CopyTo(outBuffer, 6);
outBuffer[8] = p.Flags;
p.Data.CopyTo(outBuffer, 9);
socket.Send(outBuffer.Take(p.Data.Length + 9).ToArray());
}
private DownloadPacket receive(CommunicationPacket p)
{
UInt64 realSerial = CommunicationFacade.ComputeRealNumber(p.SerialNumber, this.required, UInt16.MaxValue, (uint)Sizes.WINDOW_SIZE);
DownloadPacket toReturn = new DownloadPacket(p.Data, p.ConnectionNumber, p.Flags, realSerial);;
Logger.WriteLine($"Downloader recive packet with serial={toReturn.SerialNumber}");
return(toReturn);
}
private CommunicationPacket ReadPacket()
{
while (true)
{
CommunicationPacket p = pendingPacket != null ? pendingPacket : _reader.Read();
pendingPacket = null;
return(p);
}
}
private CommunicationPacket PeekPacket()
{
if (pendingPacket != null)
{
return(pendingPacket);
}
pendingPacket = _reader.Read();
return(pendingPacket);
}
public void GetServerCapabilities()
{
_writer.Write(ClientMessageId.CON_CAPABILITIES_GET, new CapabilitiesGet());
CommunicationPacket packet = ReadPacket();
if (packet.MessageType != (int)ServerMessageId.CONN_CAPABILITIES)
{
ThrowUnexpectedMessage(packet.MessageType, (int)ServerMessageId.CONN_CAPABILITIES);
}
Capabilities = Capabilities.Parser.ParseFrom(packet.Buffer);
}
public byte[] ReadAuthContinue()
{
CommunicationPacket p = ReadPacket();
if (p.MessageType != (int)ServerMessageId.SESS_AUTHENTICATE_CONTINUE)
{
throw new MySqlException("Unexpected message encountered during authentication handshake");
}
AuthenticateContinue response = AuthenticateContinue.Parser.ParseFrom(p.Buffer);
if (!response.AuthData.IsEmpty)
{
return(response.AuthData.ToByteArray());
}
return(null);
}
public override List <XDevAPI.Relational.Column> LoadColumnMetadata()
{
List <XDevAPI.Relational.Column> columns = new List <XDevAPI.Relational.Column>();
// we assume our caller has already validated that metadata is there
while (true)
{
if (PeekPacket().MessageType != (int)ServerMessageId.RESULTSET_COLUMN_META_DATA)
{
return(columns);
}
CommunicationPacket p = ReadPacket();
ColumnMetaData response = ColumnMetaData.Parser.ParseFrom(p.Buffer);
columns.Add(DecodeColumn(response));
}
}
internal string ReadOk()
{
CommunicationPacket p = ReadPacket();
if (p.MessageType == (int)ServerMessageId.ERROR)
{
var error = Error.Parser.ParseFrom(p.Buffer);
throw new MySqlException(error.Msg);
}
if (p.MessageType == (int)ServerMessageId.OK)
{
var response = Ok.Parser.ParseFrom(p.Buffer);
return(response.Msg);
}
else
{
throw new InvalidOperationException();
}
}
public override void CloseResult(BaseResult rs)
{
rs._hasData = false;
while (true)
{
CommunicationPacket p = PeekPacket();
if (p.MessageType == (int)ServerMessageId.RESULTSET_FETCH_DONE_MORE_RESULTSETS)
{
rs._hasMoreResults = true;
ReadPacket();
break;
}
if (p.MessageType == (int)ServerMessageId.OK)
{
ReadOk();
break;
}
if (p.MessageType == (int)ServerMessageId.RESULTSET_FETCH_DONE)
{
ReadPacket();
}
else if (p.MessageType == (int)ServerMessageId.NOTICE)
{
ProcessNotice(ReadPacket(), rs);
}
else if (p.MessageType == (int)ServerMessageId.ERROR)
{
rs._session.ActiveResult = null;
DecodeAndThrowError(ReadPacket());
}
else if (p.MessageType == (int)ServerMessageId.SQL_STMT_EXECUTE_OK)
{
ReadPacket();
break;
}
else
{
throw new MySqlException(ResourcesX.ThrowingAwayResults);
}
}
}
public override List <byte[]> ReadRow(BaseResult rs)
{
CommunicationPacket packet = PeekPacket();
if (packet.MessageType != (int)ServerMessageId.RESULTSET_ROW)
{
if (rs != null)
{
CloseResult(rs);
}
return(null);
}
Mysqlx.Resultset.Row protoRow = Mysqlx.Resultset.Row.Parser.ParseFrom(ReadPacket().Buffer);
List <byte[]> values = new List <byte[]>(protoRow.Field.Count);
for (int i = 0; i < protoRow.Field.Count; i++)
{
values.Add(protoRow.Field[i].ToByteArray());
}
return(values);
}
public void ReadAuthOk()
{
CommunicationPacket p = ReadPacket();
switch ((ServerMessageId)p.MessageType)
{
case ServerMessageId.SESS_AUTHENTICATE_OK:
break;
case ServerMessageId.ERROR:
var error = Error.Parser.ParseFrom(p.Buffer);
throw new MySqlException("Unable to connect: " + error.Msg);
case ServerMessageId.NOTICE:
///TODO: fix this
//ProcessNotice(p, new Result(null));
ReadAuthOk();
break;
default:
throw new MySqlException("Unexpected message encountered during authentication handshake");
}
}
private void DecodeAndThrowError(CommunicationPacket p)
{
Error e = Error.Parser.ParseFrom(p.Buffer);
throw new MySqlException(e.Code, e.SqlState, e.Msg);
}
