public virtual int Read(out byte[] buffer, int size)
{
try
{
buffer = new byte[size];
int readed = 0;
while (socket.Available != 0 && readed < size)
{
readed = ns.Read(buffer, readed, size);
}
return(readed);
}
catch (SocketException se)
{
DebugLogger.AddLog("Socket Exception:" + se.Message);
if (TimeOutConnection != null)
{
TimeOutConnection(this, new ClientEvent(EventType.TimeOut));
}
}
catch (Exception ex)
{
DebugLogger.AddLog("Exception:" + ex.Message);
}
buffer = new byte[0];
return(0);
}
public override void Run()
{
DebugLogger.AddLog("Server start accepting connection.");
server.Start();
while (IsRunning)
{
try
{
TcpClient client = server.AcceptTcpClient();
if (OnConnect == null)
{
client.Close();
}
OnConnect(this, client);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.Interrupted)
{
DebugLogger.AddLog("Server stoped.");
return;
}
DebugLogger.AddLog("SocketException:" + se.Message);
}
catch (Exception ex)
{
DebugLogger.AddLog("Exception:" + ex);
}
}
}
private void Server_OnConnect(object sender, TcpClient client)
{
try
{
WebSocket c = new WebSocket(client);
ClientManager.AddClient(c);
}
catch (WebSocketException ex)
{
DebugLogger.AddLog("Exception:" + ex.Message);
}
}
public virtual void Write(byte[] buffer)
{
if (buffer.Length == 0)
{
return;
}
try
{
ns.Write(buffer, 0, buffer.Length);
}
catch (SocketException se)
{
DebugLogger.AddLog("Socket Exception:" + se.Message);
if (TimeOutConnection != null)
{
TimeOutConnection(this, new ClientEvent(EventType.TimeOut));
}
}
catch (Exception ex)
{
DebugLogger.AddLog("Exception:" + ex.Message);
}
}
private void BroadCast(IClient client, Packet packet)
{
byte[] buffer;
try
{
buffer = Encoding.UTF8.GetBytes(JsonConvertor.ToJSON(packet));
if (buffer == null || buffer.Length == 0)
{
return;
}
}
catch (Exception ex)
{
DebugLogger.AddLog("Exception:" + ex);
return;
}
foreach (IClient c in Clients)
{
if (c != client && c.IsConnected)
{
c.Write(buffer);
}
}
}
public override void Run()
{
while (IsRunning)
{
try
{
if (addQueue.Count > 0)
{
lock (addQueue)
{
foreach (IClient c in addQueue)
{
Clients.Add(c);
}
addQueue.Clear();
if (OnUserCountChange != null)
{
OnUserCountChange(this, Clients.Count);
}
}
}
if (removeQueue.Count > 0)
{
lock (removeQueue)
{
foreach (IClient c in removeQueue)
{
Clients.Remove(c);
}
removeQueue.Clear();
if (OnUserCountChange != null)
{
OnUserCountChange(this, Clients.Count);
}
if (Clients.Count == 0)
{
SleepMode();
}
}
}
foreach (IClient client in Clients)
{
if (client.IsConnected == false)
{
client.Close();
Clients.Remove(client);
continue;
}
if (client.DataAvailable)
{
while (client.DataAvailable)
{
byte[] buffer;
client.Read(out buffer);
if (buffer == null || buffer.Length == 0)
{
continue;
}
Packet packet = JsonConvertor.FromJSON <Packet>(Encoding.UTF8.GetString(buffer));
HandleRequest(client, packet);
}
}
}
if (Clients.Count < 250)
{
Thread.Sleep(2);
}
}
catch (Exception ex)
{
DebugLogger.AddLog("Exception:" + ex.Message);
}
}
}
private void Client_CloseConnection(object sender, ClientEvent e)
{
DebugLogger.AddLog("CloseConnection:" + sender.ToString());
RemoveClient((IClient)sender);
}
public override int Read(out byte[] buffer, int size)
{
byte[] header;
base.Read(out header, 6);
OpCodeType opCode = (OpCodeType)(header[0] & 0x0F);
int i = 2;
int dataSize = (header[1] & (~0x80));
if (dataSize == 126)
{
dataSize += BitConverter.ToInt16(header, i);
i = 4;
Array.Resize(ref header, 10);
Read(ref header, 6, 2);
}
else if (dataSize == 127)
{
i = 10;
Array.Resize(ref header, 14);
Read(ref header, 6, 14);
dataSize += (int)BitConverter.ToInt64(header, 2);
}
byte[] mask = new byte[4];
Array.Copy(header, i, mask, 0, 4);
base.Read(out buffer, dataSize);
for (i = 0; i < buffer.Length; i++)
{
buffer[i] = (byte)(buffer[i] ^ mask[i % 4]);
}
switch (opCode)
{
case OpCodeType.CONTINUATION_FRAME:
break;
case OpCodeType.TEXT_FRAME:
break;
case OpCodeType.BINARY_FRAME:
break;
case OpCodeType.CONNECTION_CLOSE:
Close();
break;
case OpCodeType.PING:
DebugLogger.AddLog("Recive PING.");
Write(buffer, OpCodeType.PONG);
break;
case OpCodeType.PONG:
break;
default:
break;
}
return(buffer.Length);
}
