public bool Connect()
{
try
{
//Terminate current connection
Disconnect();
//Establish TCP connection
_tcpClient = new TCPClientEx(_server, _port);
_networkStream = ((TcpClient)_tcpClient).GetStream();
//Create data thread
_receivedData = new MemoryStream();
_dataThread = new Thread(() => ReceiveData(_tcpClient, _networkStream));
_dataThread.Start();
//Set connection state
_connected = 1;
//Fire Connected event
if (Connected != null)
{
Connected();
}
}
catch (Exception ex)
{
OutLogMessage(string.Format("CLN CONNECTION ERROR: {0}", ex));
}
//Done
return(IsConnected);
}
public bool Send(TCPClientEx tcpClient, IEnumerable <ITransferable> packets, object userData = null)
{
if (!tcpClient.Connected)
{
return(false);
}
try
{
int dataSize = 0, idx = 0, cnt = packets.Count();
byte[][] data = new byte[packets.Count()][];
foreach (byte[] byteBuffer in packets.Select(packet => packet.Serialize()))
{
data[idx++] = byteBuffer;
dataSize += byteBuffer.Length;
}
idx = 0;
byte[] outData = new byte[dataSize];
for (int i = 0; i < cnt; i++)
{
byte[] array = data[i];
int length = array.Length;
Array.Copy(array, 0, outData, idx, length);
idx += length;
}
((TcpClient)tcpClient).GetStream().Write(outData, 0, dataSize);
return(true);
}
catch { }
return(false);
}
private void ProcessReceivedData(TCPClientEx tcpClientEx, MemoryStream stream)
{
List <BasePacket> packets = new List <BasePacket>();
byte[] buf = stream.GetBuffer();
//Parse packets
short rSize;
int pos = 0, dataSize = (int)stream.Length;
BasePacket packet;
do
{
packet = BasePacket.Deserialize(buf, dataSize, pos, out rSize);
if (rSize > 0 && packet != null)
{
packets.Add(packet);
pos += rSize;
}
} while (rSize > 0 && packet != null);
//Shrink stream
if (pos > 0)
{
Buffer.BlockCopy(buf, pos, buf, 0, dataSize - pos);
stream.SetLength(dataSize - pos);
}
//Fire ClientDataReceived event
if (ClientDataReceived != null && packets.Count > 0)
{
ClientDataReceived(tcpClientEx, packets);
}
}
public bool Send(TCPClientEx tcpClient, ITransferable packet, object userData = null)
{
if (!tcpClient.Connected)
{
return(false);
}
try
{
//Send data
byte[] byteBuffer = packet.Serialize();
int dataLength = byteBuffer.Length;
((TcpClient)tcpClient).GetStream().Write(byteBuffer, 0, dataLength);
//Fire DataSent event
if (ClientDataSent != null)
{
ClientDataSent(tcpClient, packet, userData);
}
return(true);
}
catch (Exception ex)
{
if (ClientDataSendError != null)
{
ClientDataSendError(tcpClient, packet, userData, ex);
}
}
return(false);
}
private void ReceiveData(TCPClientEx tcpClientEx, NetworkStream networkStream)
{
TcpClient tcpClient = tcpClientEx;
try
{
int dataSize;
byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
while ((dataSize = networkStream.Read(buffer, 0, buffer.Length)) != 0)
{
_receivedData.Write(buffer, 0, dataSize);
ProcessReceivedData(_receivedData);
}
}
catch (Exception ex)
{
if (IsConnected && DataReceiveError != null)
{
DataReceiveError(ex);
}
}
finally
{
//Disconnect from a server
if (IsConnected)
{
Disconnect();
}
}
}
public bool Send(long clientId, ITransferable packet)
{
TCPClientEx tcpClient = GetConnectedClient(clientId);
if (tcpClient == null)
{
OutLogMessage(string.Format("SRV DATA SEND ERROR, client ID is invalid: {0}", clientId));
return(false);
}
return(Send(tcpClient, packet));
}
public bool DropClient(int clientId)
{
TCPClientEx tcpClient = GetConnectedClient(clientId);
if (tcpClient == null)
{
OutLogMessage(string.Format("SRV DROP CLIENT ERROR, client ID is invalid: {0}", clientId));
return(false);
}
return(DropClient(tcpClient));
}
private MemoryStream AddConnectedClient(TCPClientEx tcpClient)
{
lock (_clientsData)
{
long clietnId = tcpClient.Id;
RemoveConnectedClient(clietnId);
_connectedClients.Add(clietnId, tcpClient);
MemoryStream data = new MemoryStream();
_clientsData.Add(clietnId, data);
return(data);
}
}
public bool DropClient(TCPClientEx tcpClient)
{
try
{
((TcpClient)tcpClient).Close();
return(true);
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV DROP CLIENT ERROR: {0}", ex));
}
return(false);
}
private void ListenForClients()
{
//Start listener
try
{
_tcpListener.Start();
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV START LISTENER ERROR: {0}", ex));
return;
}
//While this thread is alive and listener is not destroyes
while (Thread.CurrentThread.IsAlive && _tcpListener != null)
{
//Check for new clients
while (_tcpListener != null && _tcpListener.Pending())
{
try
{
//Accept the client
TCPClientEx tcpClient = new TCPClientEx(_tcpListener.AcceptTcpClient());
MemoryStream clientData = AddConnectedClient(tcpClient);
//Create input stream reader for the client
NetworkStream networkStream = ((TcpClient)tcpClient).GetStream();
ThreadPool.QueueUserWorkItem(IncomingClientPrc,
new object[]
{
tcpClient,
clientData,
networkStream
});
//Fire ClientConnected event
if (ClientConnected != null)
{
ClientConnected(tcpClient);
}
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV ACCEPT CLIENT ERROR: {0}", ex));
}
}
Thread.Sleep(1);
}
}
private void IncomingClientPrc(object client)
{
//Get TCP objects
TCPClientEx tcpClientEx = (TCPClientEx)((object[])client)[0];
MemoryStream clientData = (MemoryStream)((object[])client)[1];
NetworkStream networkStream = (NetworkStream)((object[])client)[2];
TcpClient tcpClient = tcpClientEx;
try
{
byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
try
{
int dataSize;
while ((dataSize = networkStream.Read(buffer, 0, buffer.Length)) != 0)
{
clientData.Write(buffer, 0, dataSize);
ProcessReceivedData(tcpClientEx, clientData);
}
}
catch (Exception ex)
{
if (!ex.Message.Contains("WSACancelBlockingCall") &&
ClientDataReceiveError != null)
{
ClientDataReceiveError(tcpClientEx, ex);
}
}
//Remove current client
RemoveConnectedClient(tcpClientEx.Id);
//Disconnect TCP client
if (tcpClientEx.Connected)
{
tcpClient.Close();
}
//Fire ClientDisonnected event
if (ClientDisonnected != null)
{
ClientDisonnected(tcpClientEx);
}
}
catch {}
}
public bool Connect()
{
try
{
//Terminate current connection
Disconnect();
//Establish TCP connection
_tcpClient = new TCPClientEx(_server, _port);
_networkStream = ((TcpClient)_tcpClient).GetStream();
//Create data thread
_receivedData = new MemoryStream();
_dataThread = new Thread(() => ReceiveData(_tcpClient, _networkStream));
_dataThread.Start();
//Set connection state
_connected = 1;
//Fire Connected event
if (Connected != null)
{
Connected();
}
}
catch (Exception ex)
{
OutLogMessage(string.Format("CLN CONNECTION ERROR: {0}", ex));
}
//Done
return IsConnected;
}
private void ReceiveData(TCPClientEx tcpClientEx, NetworkStream networkStream)
{
TcpClient tcpClient = tcpClientEx;
try
{
int dataSize;
byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
while ((dataSize = networkStream.Read(buffer, 0, buffer.Length)) != 0)
{
_receivedData.Write(buffer, 0, dataSize);
ProcessReceivedData(_receivedData);
}
}
catch (Exception ex)
{
if (IsConnected && DataReceiveError != null)
{
DataReceiveError(ex);
}
}
finally
{
//Disconnect from a server
if (IsConnected)
{
Disconnect();
}
}
}
private void ProcessReceivedData(TCPClientEx tcpClientEx, MemoryStream stream)
{
List<BasePacket> packets = new List<BasePacket>();
byte[] buf = stream.GetBuffer();
//Parse packets
short rSize;
int pos = 0, dataSize = (int) stream.Length;
BasePacket packet;
do
{
packet = BasePacket.Deserialize(buf, dataSize, pos, out rSize);
if (rSize > 0 && packet != null)
{
packets.Add(packet);
pos += rSize;
}
} while (rSize > 0 && packet != null);
//Shrink stream
if (pos > 0)
{
Buffer.BlockCopy(buf, pos, buf, 0, dataSize - pos);
stream.SetLength(dataSize - pos);
}
//Fire ClientDataReceived event
if (ClientDataReceived != null && packets.Count > 0)
{
ClientDataReceived(tcpClientEx, packets);
}
}
private void ListenForClients()
{
//Start listener
try
{
_tcpListener.Start();
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV START LISTENER ERROR: {0}", ex));
return;
}
//While this thread is alive and listener is not destroyes
while (Thread.CurrentThread.IsAlive && _tcpListener != null)
{
//Check for new clients
while (_tcpListener != null && _tcpListener.Pending())
{
try
{
//Accept the client
TCPClientEx tcpClient = new TCPClientEx(_tcpListener.AcceptTcpClient());
MemoryStream clientData = AddConnectedClient(tcpClient);
//Create input stream reader for the client
NetworkStream networkStream = ((TcpClient)tcpClient).GetStream();
ThreadPool.QueueUserWorkItem(IncomingClientPrc,
new object[]
{
tcpClient,
clientData,
networkStream
});
//Fire ClientConnected event
if (ClientConnected != null)
{
ClientConnected(tcpClient);
}
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV ACCEPT CLIENT ERROR: {0}", ex));
}
}
Thread.Sleep(1);
}
}
private MemoryStream AddConnectedClient(TCPClientEx tcpClient)
{
lock (_clientsData)
{
long clietnId = tcpClient.Id;
RemoveConnectedClient(clietnId);
_connectedClients.Add(clietnId, tcpClient);
MemoryStream data = new MemoryStream();
_clientsData.Add(clietnId, data);
return data;
}
}
public bool Send(TCPClientEx tcpClient, IEnumerable<ITransferable> packets, object userData = null)
{
if (!tcpClient.Connected)
{
return false;
}
try
{
int dataSize = 0, idx = 0, cnt = packets.Count();
byte[][] data = new byte[packets.Count()][];
foreach (byte[] byteBuffer in packets.Select(packet => packet.Serialize()))
{
data[idx++] = byteBuffer;
dataSize += byteBuffer.Length;
}
idx = 0;
byte[] outData = new byte[dataSize];
for (int i = 0; i < cnt; i++)
{
byte[] array = data[i];
int length = array.Length;
Array.Copy(array, 0, outData, idx, length);
idx += length;
}
((TcpClient)tcpClient).GetStream().Write(outData, 0, dataSize);
return true;
}
catch { }
return false;
}
public bool Send(TCPClientEx tcpClient, ITransferable packet, object userData = null)
{
if (!tcpClient.Connected)
{
return false;
}
try
{
//Send data
byte[] byteBuffer = packet.Serialize();
int dataLength = byteBuffer.Length;
((TcpClient) tcpClient).GetStream().Write(byteBuffer, 0, dataLength);
//Fire DataSent event
if (ClientDataSent != null)
{
ClientDataSent(tcpClient, packet, userData);
}
return true;
}
catch (Exception ex)
{
if (ClientDataSendError != null)
{
ClientDataSendError(tcpClient, packet, userData, ex);
}
}
return false;
}
public bool DropClient(TCPClientEx tcpClient)
{
try
{
((TcpClient)tcpClient).Close();
return true;
}
catch (Exception ex)
{
OutLogMessage(string.Format("SRV DROP CLIENT ERROR: {0}", ex));
}
return false;
}
