// Add a SocketAsyncEventArg instance to the pool.
// "item" = ClientSocketAsyncEventArgs instance to add to the pool.
internal void Push(ClientSocketAsyncEventArgs item)
{
if (item == null)
{
throw new ServerException("Items added to a ClientSocketAsyncEventArgsPool cannot be null");
}
lock (this._pool)
{
this._pool.Push(item);
}
}
private void CloseClientSocket(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
clientSocketAsyncEventArgs.IOEvent.Set();
//clientSocketAsyncEventArgs.IsReceiveing = false;
//clientSocketAsyncEventArgs.IsSending = false;
clientSocketAsyncEventArgs.Status = SocketStatus.Idle;
clientSocketAsyncEventArgs.Clear();
if (!clientSocketAsyncEventArgs.IsClosed)
{
CloseSocket(clientSocketAsyncEventArgs);
ClientDisconnected(new ClientAction() { ActionType = ServerEventTypes.ClientDisconnected, Saea = clientSocketAsyncEventArgs });
this.TheMaxConnectionsEnforcer.Release();
}
}
public virtual IEnumerable<int> ProcessRequest(ClientSocketAsyncEventArgs client, int remainingBytesToProcess)
{
throw new NotImplementedException();
}
public virtual byte[] CreateResponse(ClientSocketAsyncEventArgs client, byte[] packet)
{
throw new NotImplementedException();
}
private void CloseSocket(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
try
{
clientSocketAsyncEventArgs.AcceptSocket.Shutdown(SocketShutdown.Both);
clientSocketAsyncEventArgs.IsClosed = true;
}
catch (Exception ex)
{
Log(string.Format("CloseClientSocket, Shutdown catch, id {0}\r\n", clientSocketAsyncEventArgs.IsClosed));
}
clientSocketAsyncEventArgs.AcceptSocket.Close();
clientSocketAsyncEventArgs.IsReadyToReceive = false;
this._poolOfReceiveSendEventArgs.Push(clientSocketAsyncEventArgs);
}
private void AddMessageToSendQueue(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs, byte[] message)
{
var encodedMessage = RequestHandler.CreateResponse(clientSocketAsyncEventArgs, message);
clientSocketAsyncEventArgs.SendQueue.Enqueue(encodedMessage);
SendMessage(clientSocketAsyncEventArgs);
}
private void StartReceive(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
if (clientSocketAsyncEventArgs.Status == SocketStatus.Idle)
{
clientSocketAsyncEventArgs.IOEvent.WaitOne();
clientSocketAsyncEventArgs.Status = SocketStatus.Receiving;
clientSocketAsyncEventArgs.SetBuffer(clientSocketAsyncEventArgs.BufferOffsetReceive,
this.Settings.BufferSize);
if (!clientSocketAsyncEventArgs.AcceptSocket.Connected || clientSocketAsyncEventArgs.IsClosed)
{
clientSocketAsyncEventArgs.Status = SocketStatus.Idle;
clientSocketAsyncEventArgs.IOEvent.Set();
return;
}
bool willRaiseEvent = clientSocketAsyncEventArgs.AcceptSocket.ReceiveAsync(clientSocketAsyncEventArgs);
if (!willRaiseEvent)
{
ProcessReceive(clientSocketAsyncEventArgs);
}
}
}
private void CreateNewSaeaForReceiveSend(SocketAsyncEventArgsPool poolOfReceiveSendEventArgs)
{
var eventArgObjectForPool = new ClientSocketAsyncEventArgs();
this._bufferManager.SetBuffer(eventArgObjectForPool);
eventArgObjectForPool.Completed += IO_Completed;
eventArgObjectForPool.BufferOffsetReceive = eventArgObjectForPool.Offset;
eventArgObjectForPool.BufferOffsetSend = eventArgObjectForPool.Offset +
this.Settings.BufferSize * this.Settings.OpsToPreAllocate / 2;
poolOfReceiveSendEventArgs.Push(eventArgObjectForPool);
}
private void ProcessSend(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
if (clientSocketAsyncEventArgs.SocketError == SocketError.Success)
{
clientSocketAsyncEventArgs.SendBytesRemainingCount = clientSocketAsyncEventArgs.SendBytesRemainingCount - clientSocketAsyncEventArgs.BytesTransferred;
if (clientSocketAsyncEventArgs.SendBytesRemainingCount == 0)
{
clientSocketAsyncEventArgs.Status = SocketStatus.Idle;
clientSocketAsyncEventArgs.IOEvent.Set();
SendMessage(clientSocketAsyncEventArgs);
StartReceive(clientSocketAsyncEventArgs);
}
else
{
clientSocketAsyncEventArgs.BytesSentAlreadyCount += clientSocketAsyncEventArgs.BytesTransferred;
SendMessage(clientSocketAsyncEventArgs);
}
}
else
{
CloseClientSocket(clientSocketAsyncEventArgs);
}
}
private void SendMessage(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
if (clientSocketAsyncEventArgs.Status == SocketStatus.Idle)
{
byte[] msg;
if (clientSocketAsyncEventArgs.SendQueue.TryDequeue(out msg))
{
var lengthOfCurrentOutgoingMessage = msg.Length;
clientSocketAsyncEventArgs.DataToSend = msg;
clientSocketAsyncEventArgs.SendBytesRemainingCount = lengthOfCurrentOutgoingMessage;
clientSocketAsyncEventArgs.BytesSentAlreadyCount = 0;
StartSend(clientSocketAsyncEventArgs);
}
}
else
{
}
}
private void ProcessReceive(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
if (clientSocketAsyncEventArgs.SocketError != SocketError.Success || clientSocketAsyncEventArgs.BytesTransferred == 0)
{
CloseClientSocket(clientSocketAsyncEventArgs);
return;
}
var remainingBytesToProcess = clientSocketAsyncEventArgs.BytesTransferred;
foreach (var decodedMessageLength in RequestHandler.ProcessRequest(clientSocketAsyncEventArgs, remainingBytesToProcess))
{
if (decodedMessageLength != 0)
{
}
}
clientSocketAsyncEventArgs.Status = SocketStatus.Idle;
clientSocketAsyncEventArgs.IOEvent.Set();
for (int i = 0; i < clientSocketAsyncEventArgs.Data.DecodedPacketCount; i++)
{
ClientMessageReceived(new ClientAction()
{
ActionType = ServerEventTypes.ClientMessageReceived,
Saea = clientSocketAsyncEventArgs,
Message = clientSocketAsyncEventArgs.Data.DecodedPacketBuffer,
MessageStartIndex = clientSocketAsyncEventArgs.Data.DecodedPacketStartIndex[i],
MessageLength = clientSocketAsyncEventArgs.Data.DecodedPacketLength[i]
});
}
SendMessage(clientSocketAsyncEventArgs);
StartReceive(clientSocketAsyncEventArgs);
}
private void ProcessAccept(ClientSocketAsyncEventArgs acceptClientSocketAsyncEventArgs)
{
if (acceptClientSocketAsyncEventArgs.SocketError != SocketError.Success)
{
StartAccept();
HandleBadAccept(acceptClientSocketAsyncEventArgs);
return;
}
StartAccept();
var clientSocketAsyncEventArgs = this._poolOfReceiveSendEventArgs.Pop();
clientSocketAsyncEventArgs.IsClosed = false;
clientSocketAsyncEventArgs.AcceptSocket = acceptClientSocketAsyncEventArgs.AcceptSocket;
ClientConnected(new ClientAction() { ActionType = ServerEventTypes.ClientConnected, Saea = clientSocketAsyncEventArgs });
acceptClientSocketAsyncEventArgs.AcceptSocket = null;
this._poolOfAcceptEventArgs.Push(acceptClientSocketAsyncEventArgs);
StartReceive(clientSocketAsyncEventArgs);
}
private void HandleBadAccept(ClientSocketAsyncEventArgs acceptEventArgs)
{
acceptEventArgs.AcceptSocket.Close();
_poolOfAcceptEventArgs.Push(acceptEventArgs);
}
public override byte[] CreateResponse(ClientSocketAsyncEventArgs client, byte[] packet)
{
return EncodeMessage(packet);
}
private void StartSend(ClientSocketAsyncEventArgs clientSocketAsyncEventArgs)
{
clientSocketAsyncEventArgs.IOEvent.WaitOne();
clientSocketAsyncEventArgs.Status = SocketStatus.Sending;
if (clientSocketAsyncEventArgs.SendBytesRemainingCount <= this.Settings.BufferSize)
{
clientSocketAsyncEventArgs.SetBuffer(clientSocketAsyncEventArgs.BufferOffsetSend, clientSocketAsyncEventArgs.SendBytesRemainingCount);
Buffer.BlockCopy(clientSocketAsyncEventArgs.DataToSend, clientSocketAsyncEventArgs.BytesSentAlreadyCount, clientSocketAsyncEventArgs.Buffer, clientSocketAsyncEventArgs.BufferOffsetSend, clientSocketAsyncEventArgs.SendBytesRemainingCount);
}
else
{
clientSocketAsyncEventArgs.SetBuffer(clientSocketAsyncEventArgs.BufferOffsetSend, this.Settings.BufferSize);
Buffer.BlockCopy(clientSocketAsyncEventArgs.DataToSend, clientSocketAsyncEventArgs.BytesSentAlreadyCount, clientSocketAsyncEventArgs.Buffer, clientSocketAsyncEventArgs.BufferOffsetSend, this.Settings.BufferSize);
}
if (!clientSocketAsyncEventArgs.AcceptSocket.Connected || clientSocketAsyncEventArgs.IsClosed)
{
clientSocketAsyncEventArgs.Status = SocketStatus.Idle;
clientSocketAsyncEventArgs.IOEvent.Set();
return;
}
bool willRaiseEvent = clientSocketAsyncEventArgs.AcceptSocket.SendAsync(clientSocketAsyncEventArgs);
if (!willRaiseEvent)
{
ProcessSend(clientSocketAsyncEventArgs);
}
}
public override IEnumerable<int> ProcessRequest(ClientSocketAsyncEventArgs client, int remainingBytesToProcess)
{
if (!client.IsReadyToReceive)
{
var data = Encoding.UTF8.GetString(client.Buffer, client.BufferOffsetReceive,
remainingBytesToProcess);
if (new Regex("^GET").IsMatch(data))
{
var upgradeResponse = CreateUpgradeResponse(data);
Server.SendMessageToSocket(client, upgradeResponse);
client.IsReadyToReceive = true;
}
yield return 0;
}
else
{
bool isFin;
bool isRSVNull;
WebSocketOpCode opCode;
bool isMasked;
int maskBegin;
int length = 0;
var processedBytes = 0;
var decodedLengthSum = 0;
client.Data.ClearDecodedPacketInfos();
while (remainingBytesToProcess - processedBytes >= 2 &&
GetFrameInfo(client.Buffer, client.BufferOffsetReceive + processedBytes,
remainingBytesToProcess - processedBytes, out isFin, out isRSVNull, out opCode,
out isMasked, out maskBegin, out length))
{
if (opCode == WebSocketOpCode.ConnectionClose || !isRSVNull)
{
Server.DisconnectClient(client);
break;
}
var decodedLength = DecodeMessage(client.Buffer, client.BufferOffsetReceive + processedBytes,
maskBegin, length, client.Data.DecodedPacketBuffer);
var stringDecodedMessage = Encoding.UTF8.GetString(client.Data.DecodedPacketBuffer, 0,
decodedLength);
Console.WriteLine(stringDecodedMessage);
client.Data.DecodedPacketStartIndex[client.Data.DecodedPacketCount] = decodedLengthSum;
client.Data.DecodedPacketLength[client.Data.DecodedPacketCount] = decodedLength;
processedBytes += length;
decodedLengthSum += decodedLength;
client.Data.DecodedPacketCount++;
yield return decodedLength;
}
if (length > 0 && length < remainingBytesToProcess - processedBytes)
{
Buffer.BlockCopy(client.Buffer, client.BufferOffsetReceive + processedBytes, client.Buffer, client.BufferOffsetReceive, remainingBytesToProcess - processedBytes);
}
yield return 0;
}
}
private ClientSocketAsyncEventArgs CreateNewSaeaForAccept(SocketAsyncEventArgsPool pool)
{
var acceptEventArg = new ClientSocketAsyncEventArgs();
acceptEventArg.Completed += AcceptEventArg_Completed;
pool.Push(acceptEventArg);
return acceptEventArg;
}
