public bool HandleData(SocketAsyncEventArgs receiveSendEventArgs, P2PPortClientConnectionHandler clientHandler, Int32 remainingBytesToProcess)
{
bool incomingTcpMessageIsReady = false;
if (clientHandler.receivedMessageBytesDoneCount == 0)
{
clientHandler.CreateNewDataReceivedBuffer(clientHandler.lengthOfCurrentIncomingMessage);
}
if (remainingBytesToProcess + clientHandler.receivedMessageBytesDoneCount == clientHandler.lengthOfCurrentIncomingMessage)
{
Buffer.BlockCopy(receiveSendEventArgs.Buffer, clientHandler.receiveMessageOffset, clientHandler.DataReceivedBuffer, clientHandler.receivedMessageBytesDoneCount, remainingBytesToProcess);
incomingTcpMessageIsReady = true;
}
else
{
try
{
Buffer.BlockCopy(receiveSendEventArgs.Buffer, clientHandler.receiveMessageOffset, clientHandler.DataReceivedBuffer, clientHandler.receivedMessageBytesDoneCount, remainingBytesToProcess);
clientHandler.receiveMessageOffset = clientHandler.receiveMessageOffset - clientHandler.recPrefixBytesDoneThisOp;
clientHandler.receivedMessageBytesDoneCount += remainingBytesToProcess;
}
catch (Exception ex)
{
string error = ex.Message;
}
}
return(incomingTcpMessageIsReady);
}
private void CreateAndStartPort(object portOwner, int listeningPort)
{
if (!(portOwner is IUseP2PCommunicationsScheme))
{
throw (new Exception("The port owner object must implement the interface \'IUseP2PCommunicationsScheme\'"));
}
this._portOwnerComponent = portOwner;
this._ConnectedClientsTable = new Hashtable();
this._startDateTime = DateTime.Now;
this._statisticsHandler = new P2PPortStatisticsHandler();
this._listeningPort = listeningPort;
string host = System.Net.Dns.GetHostName();
this._IPAddress = CommunicationsLibrary.Utilities.CommunicationsUtilities.GetActiveIPAddress();
this._connectionendpoint = new IPEndPoint(this._IPAddress, this._listeningPort);
this._prefixHandler = new PrefixHandler();
this._messageHandler = new DataReceptionHandler();
Int32 totalBytes = P2PNetworkingDefinitions.DATABUFFER_SIZE * NUMBER_OF_SAEA_OBJECTS_FOR_REC_AND_SEND * NUMBER_OF_OPERATIONS_TO_ALLOCATE;
Int32 totalBufferBytesInEachSaeaObject = P2PNetworkingDefinitions.DATABUFFER_SIZE * NUMBER_OF_OPERATIONS_TO_ALLOCATE;
this._bufferManager = new BufferManager(totalBytes, totalBufferBytesInEachSaeaObject);
this._poolOfRecSendEventArgs = new SocketAsyncEventArgsPool(NUMBER_OF_SAEA_OBJECTS_FOR_REC_AND_SEND);
this._poolOfAcceptEventArgs = new SocketAsyncEventArgsPool(NUMBER_OF_OPERATIONS_TO_ALLOCATE);
this._maxConnectionsEnforcer = new Semaphore(MAX_CONNECTIONS, MAX_CONNECTIONS);
//creation of the pool of SEAE Object used to handle incomming connections
for (Int32 i = 0; i < MAX_SIMULTANEOUS_ACCEPT_OPS; i++)
{
SocketAsyncEventArgs SAEA = CreateNewSaeaForAccept(_poolOfAcceptEventArgs);
this._poolOfAcceptEventArgs.Push(SAEA);
}
//creation of the pool of SEAE objects used for send and receive data operations
SocketAsyncEventArgs eventArgObjectForPool;
for (Int32 i = 0; i < NUMBER_OF_SAEA_OBJECTS_FOR_REC_AND_SEND; i++)
{
eventArgObjectForPool = new SocketAsyncEventArgs();
this._bufferManager.SetBuffer(eventArgObjectForPool);
eventArgObjectForPool.Completed += new EventHandler <SocketAsyncEventArgs>(EventHandling_IO_Completed);
P2PPortClientConnectionHandler _P2PClientCnnHandler = new P2PPortClientConnectionHandler(eventArgObjectForPool, eventArgObjectForPool.Offset, eventArgObjectForPool.Offset + P2PNetworkingDefinitions.DATABUFFER_SIZE, P2PNetworkingDefinitions.DATA_SEND_RECEIVE_PREFIX_LENGHT, P2PNetworkingDefinitions.DATA_SEND_RECEIVE_PREFIX_LENGHT);
_P2PClientCnnHandler.CreateNewDataReceivedBuffer(P2PNetworkingDefinitions.DATABUFFER_SIZE);
eventArgObjectForPool.UserToken = _P2PClientCnnHandler;
this._poolOfRecSendEventArgs.Push(eventArgObjectForPool);
}
//creation of the socker and binging to a listening port
_listenSocket = new Socket(this._connectionendpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_listenSocket.Bind(this._connectionendpoint);
_listenSocket.Listen(BACK_LOG);
StartAccept();
}
private void ProcessReceive(SocketAsyncEventArgs receiveSendEventArgs)
{
P2PPortClientConnectionHandler clientHandler = (P2PPortClientConnectionHandler)receiveSendEventArgs.UserToken;
if (receiveSendEventArgs.SocketError != SocketError.Success)
{
//---------------------------------------------------------
// at this point the client has disconnected unexpectedly
clientHandler.Reset();
CloseClientSocket(receiveSendEventArgs);
return;
}
if (receiveSendEventArgs.BytesTransferred == 0)
{
clientHandler.Reset();
CloseClientSocket(receiveSendEventArgs);
return;
}
Int32 remainingBytesToProcess = receiveSendEventArgs.BytesTransferred;
if (clientHandler.receivedPrefixBytesDoneCount < P2PNetworkingDefinitions.DATA_SEND_RECEIVE_PREFIX_LENGHT)
{
remainingBytesToProcess = _prefixHandler.HandlePrefix(receiveSendEventArgs, clientHandler, remainingBytesToProcess);
if (remainingBytesToProcess == 0)
{
StartReceive(receiveSendEventArgs);
return;
}
}
bool incomingTcpMessageIsReady;
incomingTcpMessageIsReady = this._messageHandler.HandleData(receiveSendEventArgs, clientHandler, remainingBytesToProcess);
if (incomingTcpMessageIsReady != true)
{
clientHandler.receiveMessageOffset = clientHandler.BufferOffsetReceive;
clientHandler.recPrefixBytesDoneThisOp = 0;
StartReceive(receiveSendEventArgs);
}
else
{
//the data transmission is finished
//the data is treated
this.ProcessReceivedData(clientHandler);
clientHandler.CreateNewDataReceivedBuffer(P2PNetworkingDefinitions.DATABUFFER_SIZE);
clientHandler.Reset();
}
}
