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); }