public override bool Send(Paket paket)
{
// TODO: So geht das nicht. Send kann werfen aber hier gehts mit bool weiter.
// Bugs -> weiterwerfen / SocketExceptions entsprechend Railroad
Channel.Send(paket.Array, 0, paket.Count);
return(true);
}
internal void MessageReceived(Paket paket)
{
Monitor.Enter(_lock);
Connection connection;
if (!_connectionDictionary.TryGetValue(paket.Array[0], out connection))
{
try
{
var typeId = (paket.Array[0] >> 3) & 3;
var connectionId = (byte)((paket.Array[0] >> 5) & 7);
_trace.Info("Unknown connection. Remote: {0} Type: {1} ConnectionId: {2}", _ipEndpoint, (ServiceTypes)typeId, connectionId);
connection = ConnectionFactory.Create((ServiceTypes)typeId, connectionId, _udpSend, _trace);
_connectionDictionary.Add(paket.Array[0], connection);
}
finally
{
Monitor.Exit(_lock);
}
OnNewConnection(this, connection);
}
else
{
Monitor.Exit(_lock);
}
connection.MessageReceived(paket);
}
public override void MessageReceived(Paket paket)
{
var sequenceId = (ushort)(paket.Array[2] + (paket.Array[3] << 8));
paket.SeqId = sequenceId;
#if UID
paket.Offset = 8;
paket.Uid = (uint)SimpleTypeReader.ReadInt(paket);
#else
paket.Offset = 8;
#endif
// TODO: playoutBuffer calls Playout into user code while having this lock. High deadlock danger when user calls back into send while the lock is held here
lock (_lock)
{
Trace.Debug(">>> Received: {0}", paket);
var sendAck = (paket.Array[1] & RequireAck) != 0;
if ((paket.Array[1] & Empty) == 0)
{
_messageReceivedCounter++;
var ackResult = _receivedOrderedAcknowledgePlayoutBuffers.Add(paket.SeqId, paket);
// not sure whether lateAck is a reason to send acks. Following scenario:
// 001
// 101 early ack
// 111 late ack
var ack = ackResult == AckResult.AlreadyAcked || ackResult == AckResult.EarlyAck || ackResult == AckResult.OutOfWindow;
if (_messageReceivedCounter++ == 4)
{
_messageReceivedCounter = 0;
_lastAckResult = AckResult.Unknown;
}
// Avoid flooding with empty packages. This could happen when for example a paket is missing but pakets
// keep on arriving they all would come back here with "EarlyAck". However after 4 pakets we reset.
if (ackResult != _lastAckResult)
{
sendAck |= ack;
}
_lastAckResult = ackResult;
if (sendAck)
{
Trace.Debug("SendingAck because AckResult: {0}", ackResult);
}
}
else
{
Trace.Debug("Received empty paket. Not adding to acks");
}
if (ResendUnconfirmed(paket))
{
sendAck = false;
}
if (sendAck)
{
SendEmptyPaket(Empty);
}
Trace.Debug("<<< Received: {0}", paket);
Monitor.Pulse(_lock);
}
}
public override bool Send(Paket paket)
{
lock (_lock)
{
paket.Array[1] = (byte)(_sequenceCounter & 255);
paket.Array[2] = (byte)(_sequenceCounter >> 8);
_sequenceCounter++;
Channel.Send(paket.Array, 0, paket.Count);
}
return(true);
}
public override Paket CreatePaket()
{
var paket = new Paket
{
Offset = 1,
Count = 1,
Array = { [0] = GetByte0() }
};
return(paket);
}
private void SetAcksInPaket(Paket paket)
{
lock (_lock)
{
paket.Array[4] = (byte)(_receivedOrderedAcknowledgePlayoutBuffers.AckBase & 255);
paket.Array[5] = (byte)(_receivedOrderedAcknowledgePlayoutBuffers.AckBase >> 8);
paket.Array[6] = (byte)(_receivedOrderedAcknowledgePlayoutBuffers.AckField & 255);
paket.Array[7] = (byte)(_receivedOrderedAcknowledgePlayoutBuffers.AckField >> 8);
}
}
private void Operation(UdpListener obj)
{
var paket = new Paket();
var count = _listener.Receive(paket.Array, 0, paket.Array.Length, out var ipEndpoint);
if (_stopped)
{
return;
}
paket.Count = count;
MessageReceived?.Invoke(paket, ipEndpoint);
}
private void Operation(UdpClient obj)
{
var dataAvailable = _udpClient.Pool(78 * 1000); // 78ms
if (!dataAvailable)
{
return;
}
var paket = new Paket();
var count = _udpClient.Receive(paket.Array, 0, paket.Array.Length);
paket.Count = count;
MessageReceived(paket);
}
public override Paket CreatePaket()
{
var paket = new Paket
{
Offset = 8,
Count = 8,
Array = { [0] = GetByte0() }
};
#if UID
SetUid(paket);
#endif
SetAcksInPaket(paket);
return(paket);
}
public override void MessageReceived(Paket paket)
{
var receivedSequenceId = (ushort)(paket.Array[1] + (paket.Array[2] << 8));
paket.SeqId = receivedSequenceId;
ushort delta = (ushort)(65536 + receivedSequenceId - _highestSequenceIdReceived);
if ((delta & 32768) != 0) // means "delta > 32768" which means negative value
{
return;
}
_highestSequenceIdReceived = receivedSequenceId;
paket.Offset = 3;
OnNewPaket(this, paket);
}
private bool ResendUnconfirmed(Paket paket)
{
var ackSent = true;
_acknowledgeSendBuffer.Ack(GetReceivedAckField(paket), GetReceivedAckBase(paket));
_unconfirmed.Clear();
_acknowledgeSendBuffer.GetAllUnconfirmed(_unconfirmed);
if (_unconfirmed.Count == 0)
{
ackSent = false;
}
for (var i = 0; i < _unconfirmed.Count; i++)
{
SetAcksInPaket(_unconfirmed[i]);
#if UID
SetUid(_unconfirmed[i]);
#endif
Trace.Debug("Resending paket: {0}", _unconfirmed[i]);
Channel.Send(_unconfirmed[i].Array, 0, _unconfirmed[i].Count);
}
return(ackSent);
}
private void MessageReceived(Paket paket)
{
paket.Offset = 7;
if (paket.Count < 6)
{
_trace.Error("Received datagram with invalid count: {0}", new object[] { paket.Count });
return;
}
if ((paket.Array[0] & 7) != Connection.ProtocolVersion)
{
return;
}
Connection connection;
if (!_connections.TryGetValue(paket.Array[0], out connection))
{
byte connectionId = (byte)((paket.Array[0] >> 5) & 7);
_trace.Error($"Incoming data for unknown connection id: {connectionId}");
}
else
{
connection.MessageReceived(paket);
}
}
public override bool Send(Paket paket)
{
lock (_lock)
{
int delta;
int result;
result = _acknowledgeSendBuffer.Add(paket, out delta);
if (result == -1)
{
// No space left in ack buffer. Remote side still there? We are not waiting, we are not buffering. Leave it to the user to decide what to do.
return(false);
}
paket.SeqId = (ushort)result;
if (delta == 3 || delta == 7 || delta == 11 || delta == 15)
{
paket.Array[1] = RequireAck;
}
paket.Array[2] = (byte)(result & 255);
paket.Array[3] = (byte)(result >> 8);
Trace.Debug("Sending paket: {0}", paket);
Channel.Send(paket.Array, 0, paket.Count);
return(true);
}
}
private void MessageReceived(Paket paket, IpEndpoint ipEndpoint)
{
if (paket.Count < 2 || paket.Count > 1024)
{
_trace.Error("Received datagram with invalid count: {0}", paket.Count);
return;
}
var protocolVersion = paket.Array[0] & 7;
if (protocolVersion != Connection.ProtocolVersion)
{
_trace.Error("Discarding Message with different protocol version. Was: {0} Expected: {1}", protocolVersion, Connection.ProtocolVersion);
return;
}
ServerPeer serverPeer;
if (!_serverPeers.TryGetValue(ipEndpoint, out serverPeer))
{
serverPeer = new ServerPeer(ipEndpoint, _listenerBase.Listener.ForkSendTo(ipEndpoint), _trace);
_serverPeers.Add(ipEndpoint, serverPeer);
OnNewServerPeer(this, serverPeer);
}
serverPeer.MessageReceived(paket);
}
public abstract bool Send(Paket paket);
private void PlayOut(Paket obj)
{
OnNewPaket(this, obj);
}
protected void OnNewPaket(Connection arg1, Paket arg2)
{
NewPaket?.Invoke(arg1, arg2);
}
private static ushort GetReceivedAckBase(Paket paket)
{
return((ushort)(paket.Array[4] + (paket.Array[5] << 8)));
}
private static ushort GetReceivedAckField(Paket paket)
{
return((ushort)(paket.Array[6] + (paket.Array[7] << 8)));
}
private void SetUid(Paket paket)
{
paket.Offset = 8;
paket.Uid = GetUid();
SimpleTypeWriter.Write((int)paket.Uid, paket);
}
private void MessageReceived(Paket paket, IpEndpoint ipEndpoint)
{
CurrentEndpoint = ipEndpoint;
Connection.MessageReceived(paket);
}
public override void MessageReceived(Paket paket)
{
paket.SeqId = 0;
paket.Offset = 1;
OnNewPaket(this, paket);
}
public abstract void MessageReceived(Paket paket);
private void _innnerConnection_NewPaket(Connection arg1, Paket arg2)
{
var item = _serializer.Deserialize(arg2);
NewMessage?.Invoke(this, item, arg2.SeqId);
}
