public bool Receive(ref ReceivedSmartPacket receivedPacket)
{
bool haveResult = false;
var packet = new ReceivedPacket();
while (true)
{
if (SubSock.Receive(ref packet))
{
try
{
haveResult = OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint,
ref receivedPacket);
}
catch (Exception)
{
haveResult = false;
_buffersPool.Put(packet.Buffer);
}
}
else
{
break;
}
if (haveResult)
{
break;
}
}
return(haveResult);
}
public void AddFragment(byte[] buffer, int offset, int length, PacketHeader header)
{
var fragBuffer = new FragmentBuffer
{
Buffer = buffer,
Offset = offset + header.HeaderLength, // payload offset
Length = length - header.HeaderLength, // payload length
FragNum = header.FragNum,
};
var frag = GetFragmentedPacket(header);
frag.LastActive = Environment.TickCount;
// add fragment buffer to it
frag.Buffers.Add(fragBuffer);
// sort fragments
var fragIdx = frag.Buffers.Count - 1;
while (fragIdx > 0 &&
frag.Buffers[fragIdx].FragNum < frag.Buffers[fragIdx - 1].FragNum)
{
Exch(frag, fragIdx - 1, fragIdx);
fragIdx--;
}
// remove if duplicate
if (fragIdx > 0 && frag.Buffers[fragIdx].FragNum == frag.Buffers[fragIdx - 1].FragNum)
{
frag.Buffers.RemoveAt(fragIdx);
_buffersPool.Put(buffer);
}
}
public override void Send(IPEndPoint endPoint, byte[] buffer, int offset, int length, bool putBufferToPool)
{
ValidateLength(length);
var packet = new PacketToSend();
packet.EndPoint = endPoint;
packet.Buffer = buffer;
packet.Offset = offset;
packet.Length = length;
packet.PutBufferToPool = putBufferToPool;
_sendQueue.Add(packet);
if (_sendQueue.Count > SendQueueLimit)
{
// Trash oldest
if (_sendQueue.TryTake(out packet))
{
if (packet.PutBufferToPool)
{
_buffersPool.Put(packet.Buffer);
}
}
}
}
public override void Send(IPEndPoint endPoint, byte[] buffer, int offset, int length, bool putBufferToPool)
{
ValidateLength(length);
try
{
// Some implementations throw exception if sendto is called on a connected SOCK_DGRAM socket.
if (!_connectedMode)
{
SysSock.SendTo(buffer, offset, length, SocketFlags.None, endPoint);
}
else
{
SysSock.Send(buffer, offset, length, SocketFlags.None);
}
}
catch (SocketException se)
{
// Ignore harmless errors
if (!HarmlessErrors.Contains(se.SocketErrorCode))
{
_logger.Exception(se);
throw;
}
}
finally
{
if (putBufferToPool)
{
_buffersPool.Put(buffer);
}
}
}
public void Tick()
{
_servSock.Tick();
var packet = new ReceivedSmartPacket();
while (true)
{
if (_servSock.Receive(ref packet))
{
OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint, packet.InOrder);
_bufferPool.Put(packet.Buffer);
}
else
{
break;
}
}
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes(_clients.Count), 0, 4);
foreach (var client in _clients)
{
ms.Write(BitConverter.GetBytes(client.Value), 0, 4);
}
var sendBuffer = ms.ToArray();
Broadcast(sendBuffer, 0, sendBuffer.Length);
}
public bool Receive(ref ReceivedSmartPacket receivedPacket)
{
bool haveResult = false;
var packet = new ReceivedPacket();
while (true)
{
try
{
packet.EndPoint = null;
if (SubSock.Receive(ref packet))
{
try
{
haveResult = OnReceive(packet.Buffer, packet.Offset, packet.Length, packet.EndPoint,
ref receivedPacket);
}
catch (SocketException)
{
haveResult = false;
_buffersPool.Put(packet.Buffer);
if (packet.EndPoint != null && _seqStates.ContainsKey(packet.EndPoint))
{
Close(packet.EndPoint, _seqStates[packet.EndPoint]);
}
}
}
else
{
break;
}
}
catch (SocketException)
{
Close();
}
if (haveResult)
{
break;
}
}
return(haveResult);
}
public override void Send(IPEndPoint endPoint, byte[] buffer, int offset, int length, bool putBufferToPool)
{
ValidateLength(length);
try
{
// Make sure socket is live
if (!Begin())
{
return;
}
SysSock.SendTo(buffer, offset, length, SocketFlags.None, endPoint);
}
catch (SocketException sx)
{
var err = sx.SocketErrorCode;
// Ignore harmless errors
if (!HarmlessErrors.Contains(err))
{
_logger.Exception(sx);
End();
// Our socket might be killed by iOS
// Make sure we'll create a new one on our next call
if (err != SocketError.NotConnected)
{
throw sx;
}
}
}
finally
{
if (putBufferToPool)
{
_buffersPool.Put(buffer);
}
}
}
private void IOLoop()
{
bool active = false;
while (!_closing)
{
lock (_syncObject)
{
_socket.Tick();
}
SmartPacketToSend packetToSend = new SmartPacketToSend();
if (_sendQueue.Count > 0)
{
active = true;
packetToSend = _sendQueue.Take();
lock (_syncObject)
{
_socket.Send(packetToSend.EndPoint, packetToSend.Buffer, packetToSend.Offset, packetToSend.Length, packetToSend.Reliable);
}
if (packetToSend.PutBufferToPool)
{
_buffersPool.Put(packetToSend.Buffer);
}
}
ReceivedSmartPacket receivedPacket = new ReceivedSmartPacket();
bool received;
lock (_syncObject)
{
received = _socket.Receive(ref receivedPacket);
}
if (received)
{
active = true;
_recvQueue.Add(receivedPacket);
}
if (!active)
{
Thread.Sleep(10);
}
}
}
private void IOLoop()
{
while (!_closing)
{
try
{
bool active = false;
_socket.Tick();
State = _socket.State;
SmartPacketToSend packetToSend = new SmartPacketToSend();
if (_sendQueue.Count > 0)
{
active = true;
packetToSend = _sendQueue.Take();
_socket.Send(packetToSend.EndPoint, packetToSend.Buffer, packetToSend.Offset, packetToSend.Length, packetToSend.Reliable);
if (packetToSend.PutBufferToPool)
{
_buffersPool.Put(packetToSend.Buffer);
}
}
ReceivedSmartPacket receivedPacket = new ReceivedSmartPacket();
if (_socket.Receive(ref receivedPacket))
{
active = true;
_recvQueue.Add(receivedPacket);
}
if (!active)
{
Thread.Sleep(10);
}
}
catch (Exception)
{
_closing = true;
}
}
_socket.Close();
State = PixocketState.NotConnected;
}
