public static DataBufferModel BufferSerialize(TransferCommandObject ObjectToSerialize) //changed serialization into pattern seperated text: <SPLITPATTERN>
{
string data = $"{ObjectToSerialize.Command}<SPLITPATTERN>{ObjectToSerialize.Value}";
byte[] byteArray = Encoding.Default.GetBytes(data);
DataBufferModel buffer = new DataBufferModel();
buffer.DataId = Guid.NewGuid();
int count = 0;
int bytesLeft = byteArray.Length;
int index = 0;
int increment = 2029;
while (bytesLeft > 0)
{
count++;
byte[] subArray = byteArray.SubArray(index, increment);
bytesLeft -= increment;
index += increment;
buffer.BufferedData.Add(count, subArray);
}
buffer.SeriesLength = count;
return(buffer);
}
public static DataBufferModel BufferSerialize(TransferCommandObject ObjectToSerialize)
{
string data = JsonConvert.SerializeObject(ObjectToSerialize);
byte[] byteArray = Encoding.Default.GetBytes(data);
DataBufferModel buffer = new DataBufferModel();
buffer.DataId = Guid.NewGuid();
int count = 0;
int bytesLeft = byteArray.Length;
int index = 0;
int increment = SharedProperties.DataLength;
while (bytesLeft > 0)
{
count++;
byte[] subArray = byteArray.SubArray(index, increment);
bytesLeft -= increment;
index += increment;
buffer.BufferedData.Add(count, subArray);
}
buffer.SeriesLength = count;
return(buffer);
}
/// <summary>
/// Sends a text message to the specified
/// socket.
/// </summary>
/// <param name="s">The socket.</param>
/// <param name="message">The message.</param>
public void SendDataObjectToSocket(byte type, Socket s, DataBufferModel message)
{
WriteLine("Sending data with id: " + message.DataId.ToString(), ConsoleColor.Magenta);
foreach (KeyValuePair <int, byte[]> item in message.BufferedData)
{
byte[] sendArray = new byte[] { type, (byte)message.SeriesLength, (byte)item.Key };
sendArray = sendArray.Concat(message.DataId.ToBigEndian().ToByteArray()).Concat(item.Value).ToArray();
SendBytesToSocket(s, sendArray);
}
}
public void SendDataObjectToAll(byte type, DataBufferModel message)
{
foreach (Socket s in clients.Keys)
{
try
{
SendDataObjectToSocket(type, s, message);
}
catch { }
}
}
/// <summary>
/// Function that checks for the client you selected and then according to that sends the object.
/// </summary>
/// <param name="type"></param>
/// <param name="message"></param>
public void SendDataObjectToSelectedClient(DataByteType type, DataBufferModel message)
{
if (allClientsSelected)
{
SendDataObjectToAll(type, message);
}
else
{
SendDataObjectToSocket(type, GetSocketByClient(SelectedClient), message);
}
}
/// <summary>
/// Sends a text message to the specified
/// socket.
/// </summary>
/// <param name="s">The socket.</param>
/// <param name="message">The message.</param>
public void SendDataObjectToSocket(DataByteType type, Socket s, DataBufferModel message)
{
BConsole.WriteLine("Sending data with id: " + message.DataId.ToString());
byte[] lengthByteArray = BitConverter.GetBytes(message.SeriesLength);
foreach (KeyValuePair <int, byte[]> item in message.BufferedData)
{
byte[] seriesByteArray = BitConverter.GetBytes(item.Key);
byte[] sendArray = new byte[] { (byte)type, lengthByteArray[0], lengthByteArray[1], seriesByteArray[0], seriesByteArray[1] };
sendArray = sendArray.Concat(message.DataId.ToByteArray()).Concat(item.Value).ToArray();
SendBytesToSocket(s, sendArray);
}
}
private void SendObjectToSocket(Socket s, DataBufferModel message, byte type)
{
BConsole.WriteLine("Sending data with id: " + message.DataId.ToString());
byte[] lengthByteArray = BitConverter.GetBytes(message.SeriesLength);
foreach (KeyValuePair <int, byte[]> item in message.BufferedData)
{
byte[] seriesByteArray = BitConverter.GetBytes(item.Key);
byte[] sendArray = new byte[] { type, lengthByteArray[0], lengthByteArray[1], seriesByteArray[0], seriesByteArray[1] };
sendArray = sendArray.Concat(message.DataId.ToByteArray()).Concat(item.Value).ToArray();
s.Send(sendArray, 0, sendArray.Length, SocketFlags.None);
}
//s.Send(item.Value, 0, item.Value.Length, SocketFlags.None);
}
public static TransferCommandObject BufferDeserialize(DataBufferModel bufferModel)
{
if (bufferModel.BufferedData.Count == bufferModel.SeriesLength)
{
byte[] fullBuffer = bufferModel.BufferedData[1]; //index starts at 1 NOT at 0
if (bufferModel.SeriesLength > 1)
{
for (int i = 2; i <= bufferModel.SeriesLength; i++)
{
fullBuffer = fullBuffer.Concat(bufferModel.BufferedData[i]).ToArray();
}
}
string data = Encoding.Default.GetString(fullBuffer.Where(n => n != 0).ToArray()).Replace("\0", "");
return(JsonConvert.DeserializeObject <TransferCommandObject>(data));
}
return(default);
/// <summary>
/// Receives and processes data from a socket.
/// It triggers the message received event in
/// case the client pressed the return key.
/// </summary>
private void ReceiveData(IAsyncResult result)
{
try
{
Socket clientSocket = (Socket)result.AsyncState;
Client client = GetClientBySocket(clientSocket);
int bytesReceived = clientSocket.EndReceive(result);
// guidelines for the received data:
// first byte is check:
// 0x1A: Response
// 0x1B: Command
// 0x1C: Data
// second byte is data length:
// 0x01: 1x 2029 bytes sets
// 0x1B: 27x 2029 bytes sets
// 0x22: 34x 2029 bytes sets etc...
// third byte is series:
// 0x01: 1/N byte set
// 0x1A: 26/N byte set etc...
// the next 16 bytes are unique id:
// 0x00112233445566778899AABBCCDDFF00
if (bytesReceived == 0)
{
CloseSocket(clientSocket);
serverSocket.BeginAccept(new AsyncCallback(HandleIncomingConnection), serverSocket);
}
else if (client.Data[0] == 0x1A || client.Data[0] == 0x1B || client.Data[0] == 0x1C) //less than the max byte check
{
int length = client.Data[1];
int series = client.Data[2];
Guid guid = new Guid(client.Data.SubArray(3, 16)).ToLittleEndian();
DataBufferModel buffer = Buffers.FirstOrDefault(n => n.DataId == guid);
if (buffer != null)
{
buffer.BufferedData.Add(series, client.Data.SubArray(19, 2028));
buffer.LatestSeries = series;
}
else
{
//create a new buffer
buffer = new DataBufferModel();
buffer.BufferedData.Add(series, client.Data.SubArray(19, 2028));
buffer.DataId = guid;
buffer.SeriesLength = length;
buffer.LatestSeries = series;
Buffers.Add(buffer);
}
WriteLine($"Received data with id: {guid.ToString()}", ConsoleColor.Magenta);
if (buffer.BufferedData.Count == buffer.SeriesLength)
{
bool handled = false;
switch (client.Data[0])
{
case 0x1A:
handled = HandleIncomingData(ClientServerPipeline.BufferDeserialize(buffer), client, DataEventType.RESPONSE);
break;
case 0x1B:
handled = HandleIncomingData(ClientServerPipeline.BufferDeserialize(buffer), client, DataEventType.COMMAND);
break;
case 0x1C:
handled = HandleIncomingData(ClientServerPipeline.BufferDeserialize(buffer), client, DataEventType.DATA);
break;
}
if (handled)
{
//remove the id from the buffer, else report it and set it up for future handling
//TODO: this^
}
}
}
client.Data = new byte[2048];
clientSocket.BeginReceive(client.Data, 0, dataSize, SocketFlags.None, new AsyncCallback(ReceiveData), clientSocket);
}
catch (SocketException e)
{
Socket clientSocket = (Socket)result.AsyncState;
Client client = GetClientBySocket(clientSocket);
KickClient(client);
}
catch (Exception e)
{
WriteLine($"Error occured: {e.Message}", ConsoleColor.Red);
}
}
/// <summary>
/// The async callback of receivedata
/// </summary>
/// <param name="result"></param>
private void ReceiveData(IAsyncResult result)
{
try
{
Socket clientSocket = (Socket)result.AsyncState;
Client client = GetClientBySocket(clientSocket);
if (client == null)
{
return;
}
int bytesReceived = clientSocket.EndReceive(result);
DataByteType type = (DataByteType)client.Data[SharedProperties.TypeByte];
if (bytesReceived == 0)
{
CloseSocket(clientSocket);
serverSocket.BeginAccept(new AsyncCallback(HandleIncomingConnection), serverSocket);
}
else if (Enum.IsDefined(typeof(DataByteType), (DataByteType)client.Data[SharedProperties.TypeByte]))
{
int length = BitConverter.ToInt32(new byte[] { client.Data[SharedProperties.LengthByte1], client.Data[SharedProperties.LengthByte2], 0, 0 }, 0);
int series = BitConverter.ToInt32(new byte[] { client.Data[SharedProperties.SeriesByte1], client.Data[SharedProperties.SeriesByte2], 0, 0 }, 0);
Guid guid = new Guid(client.Data.SubArray(SharedProperties.GuidStartByte, 16));
DataBufferModel buffer = Buffers.FirstOrDefault(n => n.DataId == guid);
if (buffer != null)
{
buffer.BufferedData.Add(series, client.Data.SubArray(SharedProperties.HeaderByteSize, SharedProperties.DataLength));
buffer.LatestSeries = series;
}
else
{
buffer = new DataBufferModel();
buffer.BufferedData.Add(series, client.Data.SubArray(SharedProperties.HeaderByteSize, SharedProperties.DataLength));
buffer.DataId = guid;
buffer.SeriesLength = length;
buffer.LatestSeries = series;
Buffers.Add(buffer);
}
BConsole.WriteLine($"Received data with id: {guid.ToString()}");
if (buffer.BufferedData.Count == buffer.SeriesLength)
{
if (HandleIncomingData(ClientServerPipeline.BufferDeserialize(buffer), client, type))
{
Buffers.Remove(buffer);
}
}
}
clientSocket.BeginReceive(client.Data, 0, dataSize, SocketFlags.None, new AsyncCallback(ReceiveData), clientSocket);
}
catch (SocketException)
{
Socket clientSocket = (Socket)result.AsyncState;
Client client = GetClientBySocket(clientSocket);
KickClient(client);
}
catch (Exception e)
{
BConsole.WriteLine("Recieve error occured: " + e.Message, ConsoleColor.Red);
}
}
/// <summary>
/// Connects to the Remote host and receives data, returns if connection is lost
/// </summary>
/// <param name="ip"></param>
/// <returns>Returns if the client should attempt a reconnect</returns>
public bool ConnectAndReceive(string ip)
{
remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
remoteSocket.Connect(new IPEndPoint(IPAddress.Parse(ip), SharedProperties.MainPort));
BConsole.WriteLine($"Connected to Trollkit host at {ip}:{SharedProperties.MainPort}", ConsoleColor.DarkGreen);
while (remoteSocket.IsConnected())
{
//receive data from server.
byte[] array = new byte[SharedProperties.DataSize];
try
{
remoteSocket.Receive(array);
}
catch (SocketException e)
{
if (e.SocketErrorCode == SocketError.ConnectionReset)
{
BConsole.WriteLine("Host connection closed unexpectedly...", ConsoleColor.Red);
return(true);
}
else
{
BConsole.WriteLine("Application crashed, closing now");
return(false);
}
}
catch (Exception e)
{
BConsole.WriteLine("Application crashed, closing now");
return(false);
}
int length = BitConverter.ToInt32(new byte[] { array[SharedProperties.LengthByte1], array[SharedProperties.LengthByte2], 0, 0 }, 0);
int series = BitConverter.ToInt32(new byte[] { array[SharedProperties.SeriesByte1], array[SharedProperties.SeriesByte2], 0, 0 }, 0);
byte[] guidBytes = Extensions.SubArray(array, SharedProperties.GuidStartByte, 16);
Guid guid = new Guid(guidBytes);
if (guid != Guid.Empty)
{
DataBufferModel buffer = buffers.FirstOrDefault(n => n.DataId == guid);
if (buffer != null)
{
buffer.BufferedData.Add(series, Extensions.SubArray(array, SharedProperties.HeaderByteSize, SharedProperties.DataLength));
buffer.LatestSeries = series;
}
else
{
buffer = new DataBufferModel();
buffer.BufferedData.Add(series, Extensions.SubArray(array, SharedProperties.HeaderByteSize, SharedProperties.DataLength));
buffer.LatestSeries = series;
buffer.DataId = guid;
buffer.SeriesLength = length;
buffers.Add(buffer);
}
if (buffer.BufferedData.Count == buffer.SeriesLength)
{
OnDataReceived?.Invoke(remoteSocket, ClientServerPipeline.BufferDeserialize(buffer));
}
}
}
return(false); //if code reaches here, the client was gracefully kicked
}
public void SendResponseObjectToSocket(Socket s, DataBufferModel message)
{
SendObjectToSocket(s, message, 0x1A);
}
public void SendDataObjectToSocket(Socket s, DataBufferModel message)
{
SendObjectToSocket(s, message, 0x1C);
}
public void SendCommandObjectToSocket(Socket s, DataBufferModel message)
{
SendObjectToSocket(s, message, 0x1B);
}
