👩🏾‍🚀 👨🏿‍🏭 ♋️ .Net用の信頼性の高いUdpプロトコルの実装 😷 👨🏾‍⚖️ 👐🏽

インターネットは昔から変わっています。主なインターネットプロトコルの1つであるUDPは、データグラムとブロードキャストの配信だけでなく、ネットワークノード間のピアツーピア接続の提供にもアプリケーションで使用されます。シンプルなデバイスのため、このプロトコルには以前に計画されていなかった多くの適用方法がありますが、配信の保証がないなどのプロトコルの欠陥は消えていません。この記事では、UDPを介した保証付き配信プロトコルの実装について説明します。

エントリー

インターネットの元のアーキテクチャは、各ノードがグローバルで一意のIPアドレスを持ち、他のノードと直接通信できる均一なアドレス空間を暗示していました。実際、インターネットのアーキテクチャは異なります。グローバルIPアドレスの1つの領域と、 NATデバイスの背後に隠されたプライベートアドレスを持つ多くの領域です。このようなアーキテクチャでは、グローバルアドレス空間にあるデバイスのみが一意のグローバルルーティング可能なIPアドレスを持っているため、ネットワーク上の誰とでも簡単にやり取りできます。プライベートネットワークにあるノードは、同じネットワーク内の他のノードに接続できるだけでなく、グローバルアドレス空間内の他の既知のノードにも接続できます。この相互作用はネットワークアドレス翻訳のメカニズムのために主に達成されます。 Wi-FiルーターなどのNATデバイスは、発信接続用の変換テーブルに特別なエントリを作成し、パケットのIPアドレスとポート番号を変更します。これにより、グローバルネットワークのノードからグローバルアドレス空間のノードへの発信接続を確立できます。ただし、同時に、NATデバイスは通常、着信接続用の個別のルールが設定されていない限り、すべての着信トラフィックをブロックします。

このようなインターネットのアーキテクチャは、クライアントがプライベートネットワークにあり、サーバーがグローバルアドレスを持っている場合に、クライアントとサーバーの相互作用に十分に適しています。ただし、 異なるプライベートネットワーク間で2つのノードを直接接続するのは困難です。 2つのノードの直接接続は、音声伝送（Skype）、コンピューターへのリモートアクセス（TeamViewer）、オンラインゲームなどのピアツーピアアプリケーションにとって重要です。

さまざまなプライベートネットワーク上にあるデバイス間でピアツーピア接続を確立するための最も効果的な方法の1つは、ホールパンチと呼ばれます。この手法は、UDPプロトコルに基づくアプリケーションで最もよく使用されます。

ただし、アプリケーションでデータ配信の保証が必要な場合、たとえば、コンピューター間でファイルを転送する場合、UDPを使用すると、UDPは保証された配信プロトコルではなく、TCPプロトコルとは異なり、パケット配信を順番に提供しないという事実に関連する多くの問題が発生します。

この場合、保証されたパケット配信を保証するには、必要な機能を提供し、UDP上で動作するアプリケーション層プロトコルを実装する必要があります。

すぐに注意したいのは、異なるプライベートネットワークのノード間にTCP接続を確立するためのTCPホールパンチテクニックがあることですが、多くのNATデバイスがサポートされていないため、通常、そのようなノードを接続する主な方法とは見なされていません。

この記事の後半では、保証付き配信プロトコルの実装のみを検討します。 UDPホールパンチング手法の実装については、以下の記事で説明します。

プロトコル要件

ポジティブフィードバックメカニズム（いわゆるポジティブアクノリッジメント）によって実装された信頼性の高いパケット配信
効率的なビッグデータ転送の必要性、つまりプロトコルは不必要なパケットリレーを避けるべきです
配信確認メカニズム（「クリーンな」UDPプロトコルとして機能する機能）をキャンセルすることが可能です。
各メッセージの確認を伴うコマンドモードを実装する機能
プロトコルを介してデータを送信するための基本単位はメッセージです。

これらの要件は、 rfc 908およびrfc 1151で説明されているReliable Data Protocolの要件とほぼ一致しており、このプロトコルを開発する際にこれらの標準に依存していました。

これらの要件を理解するために、TCPおよびUDPプロトコルを使用した2つのネットワークノード間のデータ転送のタイミング図を見てみましょう。どちらの場合でも、1つのパケットが失われると仮定します。

TCPを介した非対話型データの送信：

図からわかるように、パケットが失われた場合、TCPは失われたパケットを検出し、これを送信者に報告し、失われたセグメントの数を要求します。

UDPデータ転送：

UDPは、損失を検出するための手順を実行しません。 UDPプロトコルでの伝送エラーの制御は、アプリケーションに完全にかかっています。

TCPプロトコルでのエラー検出は、エンドノードとの接続を確立し、この接続の状態を維持し、各パケットヘッダーで送信されたバイト数を示し、「確認番号」確認番号を使用して通知を受信します。

さらに、パフォーマンスを改善する（つまり、確認を受信せずに複数のセグメントを送信する）ために、TCPプロトコルは、いわゆる送信ウィンドウ（セグメントの送信者が受信することを期待するデータのバイト数）を使用します。

TCPプロトコルの詳細については、 rfc 793を参照してください。UDPはrfc 768で、実際に定義されています。

上記から、UDP経由でメッセージを配信するための信頼性の高いプロトコル（以下、 Reliable UDPと呼びます）を作成するには、TCP通信メカニズムと同様の実装が必要であることは明らかです。すなわち：

接続状態を保存する
セグメント番号を使用する
特別な確認パッケージを使用する
簡素化されたウィンドウメカニズムを使用して、プロトコルスループットを向上させる

さらに必要：

接続のリソースを割り当てるために、メッセージの開始を通知します
受信したメッセージを上位アプリケーションに送信し、プロトコルリソースを解放するために、メッセージの終了を通知します
「クリーンな」UDPとして機能するために、特定の接続のプロトコルが配信確認メカニズムを無効にすることを許可する

信頼できるUDPヘッダー

UDPデータグラムはIPデータグラムにカプセル化されていることを思い出してください。したがって、Reliable UDPパケットはUDPデータグラムに「ラップ」されます。

信頼できるUDPヘッダーのカプセル化：

Reliable UDPヘッダーの構造は非常に単純です。

フラグ-パッケージ制御フラグ
MessageType-特定のメッセージをサブスクライブするためにアップストリームアプリケーションによって使用されるメッセージのタイプ
TransmissionId-接続を一意に識別する送信番号と受信者のアドレスおよびポート
PacketNumber-パケット番号
オプション-追加のプロトコルオプション。最初のパケットの場合、メッセージのサイズを示すために使用されます。

フラグは次のとおりです。

FirstPacket-最初のメッセージパケット
NoAsk-メッセージには確認メカニズムを含める必要はありません
LastPacket-最後のメッセージパケット
RequestForPacket-確認パケットまたは失われたパケットの要求

プロトコルの一般原則

Reliable UDPは2つのノード間のメッセージ送信の保証に重点を置いているため、反対側との接続を確立できるはずです。接続を確立するために、送信側はFirstPacketフラグ付きのパケットを送信します。これに対する答えは、接続が確立されたことを意味します。すべての応答パケット、つまり肯定応答パケットは、PacketNumberフィールドの値を、正常に受信したパケットの最大のPacketNumber値よりも常に1大きい値に設定します。最初に送信されたパケットの[オプション]フィールドに、メッセージサイズが書き込まれます。

同様のメカニズムを使用して接続を完了します。最後のメッセージパケットでは、LastPacketフラグが設定されています。応答パケットは、最後のパケットの番号+ 1を示します。これは、受信側にとって、メッセージの配信が成功したことを意味します。

接続の確立と終了の図：

接続が確立されると、データ転送が開始されます。データはパケットのブロックで送信されます。最後を除く各ブロックには、固定数のパケットが含まれています。これは、送信/受信ウィンドウのサイズと同じです。データの最後のブロックのパケットが少なくなる場合があります。各ブロックを送信した後、送信側は配信の確認、または失われたパケットの再配信の要求を期待し、応答を受信するための受信/送信ウィンドウを開いたままにします。ブロックの配信の確認を受信した後、送信/受信ウィンドウがシフトされ、次のデータブロックが送信されます。

受信側はパケットを受け入れます。各パケットは、送信ウィンドウに入るためにチェックされます。ウィンドウに入らないパッケージおよび重複は削除されます。なぜならウィンドウサイズは固定されており、受信側と送信側で同じです。パケットブロックを損失なしで配信する場合、ウィンドウは次のデータブロックのパケットを受信するようにシフトされ、配信の確認が送信されます。作業タイマーで設定された期間内にウィンドウがいっぱいにならない場合、パケットが配信されなかったチェックが開始され、再配信のリクエストが送信されます。

再送信チャート：

プロトコルのタイムアウトとタイマー

接続を確立できない理由はいくつかあります。たとえば、受信側がオフラインの場合。この場合、接続を確立しようとすると、タイムアウトによって接続が閉じられます。 Reliable UDP実装では、2つのタイマーを使用してタイムアウトを設定します。最初のタイマーは、リモートホストからの応答を待つために使用されます。送信側でトリガーされた場合、最後に送信されたパケットが再度送信されます。レシーバーが起動すると、レシーバーは失われたパケットをチェックし、再配信のリクエストを送信します。

2番目のタイマー-ノード間の通信がない場合に接続を閉じるために必要です。送信側では、ワーキングタイマーがトリガーされた直後に起動し、リモートノードからの応答を待ちます。指定した期間に応答がない場合、接続は終了し、リソースは解放されます。受信側では、クローズタイマーはダブルオペレーションタイマーの後に開始されます。これは、確認パッケージの紛失に対する保険に必要です。タイマーがトリガーされると、接続も終了し、リソースが解放されます。

信頼性の高いUDP送信状態図

プロトコルの原理はステートマシンに実装され、各ステートはパケット処理の特定のロジックを担当します。
信頼できるUDP状態図：

クローズ -実際には、それは状態ではなく、マシンの開始点と終了点です。 Closed状態は、非同期UDPサーバーを実装する伝送制御ユニットによって取得され、パケットを適切な接続にリダイレクトして、状態処理を開始します。

FirstPacketSending-メッセージを送信するときに発信接続が存在する初期状態。

この状態では、最初のパケットは通常のメッセージ用に送信されます。送信の確認がないメッセージの場合、これが唯一の状態です。メッセージ全体が送信されます。

SendingCycle-メッセージパケットを送信するための主要な状態。

状態FirstPacketSendingからそれへの遷移は、メッセージの最初のパケットを送信した後に実行されます。すべての確認と再送信の要求が来るのはこの状態です。解決方法は2つあります-メッセージの配信またはタイムアウトが成功した場合。

FirstPacketReceived-メッセージ受信者の初期状態。

送信開始の正確性をチェックし、必要な構造を作成し、最初のパケットの確認を送信します。

単一のパケットで構成され、配信確認を使用せずに送信されるメッセージの場合、これが唯一の状態です。そのようなメッセージを処理した後、接続は閉じられます。

組み立ては、メッセージパケットを受信するための基底状態です。

パケットを一時ストレージに書き込み、パケット損失がないかどうかを確認し、パケットのブロックとメッセージ全体の配信に関する確認を送信し、失われたパケットの再配信要求を送信します。メッセージ全体が正常に受信された場合、接続は完了状態になります。それ以外の場合、タイムアウトにより終了します。

完了 -メッセージ全体が正常に受信された場合、接続を閉じます。

この状態は、メッセージの組み立てと、メッセージ配信確認が送信者へのパスに沿って失われた場合に必要です。この状態からの出口はタイムアウトしますが、接続は正常に閉じられたと見なされます。

コードの詳細。トランスミッションコントロールユニット

Reliable UDPの重要な要素の1つは、伝送制御ユニットです。このブロックのタスクは、現在の接続と補助要素を保存し、対応する接続に着信パケットを配布し、接続にパケットを送信するためのインターフェイスを提供し、プロトコルAPIを実装することです。送信制御ユニットは、UDPレベルからパケットを受信し、処理のためにステートマシンにリダイレクトします。パケットを受信するために、非同期UDPサーバーが実装されています。

ReliableUdpConnectionControlBlockクラスの一部のメンバー：

internal class ReliableUdpConnectionControlBlock : IDisposable { //     .      public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> IncomingStreams { get; private set;} //     .     . public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> OutcomingStreams { get; private set; } // connection record   . private readonly ConcurrentDictionary<Tuple<EndPoint, Int32>, ReliableUdpConnectionRecord> m_listOfHandlers; //    . private readonly List<ReliableUdpSubscribeObject> m_subscribers; //   private Socket m_socketIn; //     private int m_port; //  IP  private IPAddress m_ipAddress; //    public IPEndPoint LocalEndpoint { get; private set; } //    //    public StatesCollection States { get; private set; } //   .    TransmissionId private readonly RNGCryptoServiceProvider m_randomCrypto; //... }

非同期UDPサーバーの実装：

 private void Receive() { EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0); //   ,   socket.BeginReceiveFrom byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length]; //         this.m_socketIn.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref connectedClient, EndReceive, buffer); } private void EndReceive(IAsyncResult ar) { EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0); int bytesRead = this.m_socketIn.EndReceiveFrom(ar, ref connectedClient); // ,    Receive(); // ..       -     //  IAsyncResult.AsyncState byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead); //    ReliableUdpHeader header; if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header)) { //    -   return; } //     connection record'   Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId); //   connection record    ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType)); //        record.State.ReceivePacket(record, header, bytes); }

メッセージ送信ごとに、接続情報を含む構造が作成されます。この構造は接続レコードと呼ばれます。

ReliableUdpConnectionRecordクラスの一部のメンバー：

 internal class ReliableUdpConnectionRecord : IDisposable { //     public byte[] IncomingStream { get; set; } //      public ReliableUdpState State { get; set; } // ,   connection record //     public Tuple<EndPoint, Int32> Key { get; private set;} //     public int WindowLowerBound; //    public readonly int WindowSize; //     public int SndNext; //     public int NumberOfPackets; //   (      Tuple) //     public readonly Int32 TransmissionId; //  IP endpoint –    public readonly IPEndPoint RemoteClient; //  ,     IP  //    MTU – (IP.Header + UDP.Header + RelaibleUDP.Header) public readonly int BufferSize; //    public readonly ReliableUdpConnectionControlBlock Tcb; //      BeginSendMessage/EndSendMessage public readonly AsyncResultSendMessage AsyncResult; //     public bool IsNoAnswerNeeded; //     (    ) public int RcvCurrent; //      public int[] LostPackets { get; private set; } //    .   bool. public int IsLastPacketReceived = 0; //... }

コードの詳細。州

状態は、パケットのメイン処理が行われるReliable UDPプロトコルの状態マシンを実装します。抽象クラスReliableUdpStateは、状態のインターフェイスを提供します。

プロトコルのロジック全体は、上記のクラスと、たとえば接続レコードからReliableUdpヘッダーを構築するなどの静的メソッドを提供するヘルパークラスによって実装されます。

次に、プロトコルの基本的なアルゴリズムを決定するインターフェイスメソッドの実装を詳細に検討します。

DisposeByTimeoutメソッド

DisposeByTimeoutメソッドは、タイムアウト後に接続リソースを解放し、メッセージ配信の成功/失敗を通知します。

ReliableUdpState.DisposeByTimeout：

 protected virtual void DisposeByTimeout(object record) { ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record; if (record.AsyncResult != null) { connectionRecord.AsyncResult.SetAsCompleted(false); } connectionRecord.Dispose(); }

完了状態でのみ再定義されます。

Completed.DisposeByTimeout：

 protected override void DisposeByTimeout(object record) { ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record; //      SetAsCompleted(connectionRecord); }

ProcessPacketsメソッド

ProcessPacketsメソッドは、1つまたは複数のパッケージの追加処理を担当します。直接、またはパケット待機タイマーを介して呼び出されます。

Assembling状態では、メソッドはオーバーライドされ、失われたパケットをチェックし、最後のパケットを受信して正常なチェックに合格した場合にCompleted状態に切り替えます。

Assembling.ProcessPackets：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { if (connectionRecord.IsDone != 0) return; if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0)) { //   ,     foreach (int seqNum in connectionRecord.LostPackets) { if (seqNum != 0) { ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum); } } //     ,     if (!connectionRecord.TimerSecondTry) { connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); connectionRecord.TimerSecondTry = true; return; } //      WaitForPacketTimer //     -     StartCloseWaitTimer(connectionRecord); } else if (connectionRecord.IsLastPacketReceived != 0) //   { //       ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); connectionRecord.State = connectionRecord.Tcb.States.Completed; connectionRecord.State.ProcessPackets(connectionRecord); //     //  ,  ,  //   ack         . //    -   //   Completed    StartCloseWaitTimer(connectionRecord); } //  ,  ack      else { if (!connectionRecord.TimerSecondTry) { ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); connectionRecord.TimerSecondTry = true; return; } //     StartCloseWaitTimer(connectionRecord); } }

SendingCycle状態では、このメソッドはタイマーによってのみ呼び出され、最後のメッセージを再送信すると同時に、閉じるタイマーをアクティブにします。

SendingCycle.ProcessPackets：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { if (connectionRecord.IsDone != 0) return; //     // (     -   ,     ) ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1)); //   CloseWait –        StartCloseWaitTimer(connectionRecord); }

Completed状態では、メソッドは作業タイマーを停止し、メッセージをサブスクライバーに渡します。

Completed.ProcessPackets：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { if (connectionRecord.WaitForPacketsTimer != null) connectionRecord.WaitForPacketsTimer.Dispose(); //       ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord); }

ReceivePacketメソッド

FirstPacketReceived状態では、メソッドの主なタスクは、最初のメッセージパケットが実際にインターフェイスに到着したかどうかを判断し、単一パケットで構成されるメッセージを収集することです。

FirstPacketReceived.ReceivePacket：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket)) //   return; //    - FirstPacket  LastPacket -       if (header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) & header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket)) { ReliableUdpStateTools.CreateMessageFromSinglePacket(connectionRecord, header, payload.Slice(ReliableUdpHeader.Length, payload.Length)); if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk)) { //    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); } SetAsCompleted(connectionRecord); return; } // by design  packet numbers   0; if (header.PacketNumber != 0) return; ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header); ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload); //  - ,    connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize)); //      (0) connectionRecord.RcvCurrent = header.PacketNumber; //      1 connectionRecord.WindowLowerBound++; //   connectionRecord.State = connectionRecord.Tcb.States.Assembling; //      //       if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk)) { connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.ShortTimerPeriod, -1); } else { ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1); } }

SendingCycle状態では、このメソッドは配信確認と再送信要求を受信するためにオーバーライドされます。

SendingCycle.ReceivePacket：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { if (connectionRecord.IsDone != 0) return; if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket)) return; //     //    + 1,     int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets)); //      if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > windowHighestBound) return; connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(-1, -1); //    : if (header.PacketNumber == connectionRecord.NumberOfPackets) { //   Interlocked.Increment(ref connectionRecord.IsDone); SetAsCompleted(connectionRecord); return; } //      c  if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1)) { //    SendPacket(connectionRecord); } //       else if (header.PacketNumber == windowHighestBound) { //   / connectionRecord.WindowLowerBound += connectionRecord.WindowSize; //     connectionRecord.WindowControlArray.Nullify(); //    SendPacket(connectionRecord); } //      –    else ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber)); }

ReceivePacketメソッドのAssembling状態では、着信パケットからメッセージを組み立てるための主な作業が行われます。

Assembling.ReceivePacket：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { if (connectionRecord.IsDone != 0) return; //        if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk)) { //   connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1); //   ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload); //       -   if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket)) { connectionRecord.State = connectionRecord.Tcb.States.Completed; connectionRecord.State.ProcessPackets(connectionRecord); } return; } //     int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1)); //       if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > (windowHighestBound)) return; //   if (connectionRecord.WindowControlArray.Contains(header.PacketNumber)) return; //   ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload); //    connectionRecord.PacketCounter++; //         connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber; //     if (header.PacketNumber > connectionRecord.RcvCurrent) connectionRecord.RcvCurrent = header.PacketNumber; //   connectionRecord.TimerSecondTry = false; connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(-1, -1); //     if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket)) { Interlocked.Increment(ref connectionRecord.IsLastPacketReceived); } //      ,    //     else if (connectionRecord.PacketCounter == connectionRecord.WindowSize) { //  . connectionRecord.PacketCounter = 0; //    connectionRecord.WindowLowerBound += connectionRecord.WindowSize; //     connectionRecord.WindowControlArray.Nullify(); ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); } //      if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0) { //   ProcessPackets(connectionRecord); } }

完了状態では、メソッドの唯一のタスクは、メッセージの正常な配信の再確認を送信することです。

Completed.ReceivePacket：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { //        , //   ack     if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket)) { ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); } }

SendPacketメソッド

FirstPacketSending状態では、このメソッドは最初のデータパケットを送信します。メッセージが配信確認を必要としない場合、メッセージ全体を送信します。

FirstPacketSending.SendPacket：

 public override void SendPacket(ReliableUdpConnectionRecord connectionRecord) { connectionRecord.PacketCounter = 0; connectionRecord.SndNext = 0; connectionRecord.WindowLowerBound = 0; //     -    //    if (connectionRecord.IsNoAnswerNeeded) { //    As Is do { ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools. CreateReliableUdpHeader(connectionRecord))); connectionRecord.SndNext++; } while (connectionRecord.SndNext < connectionRecord.NumberOfPackets); SetAsCompleted(connectionRecord); return; } //       ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord); ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header)); //   connectionRecord.SndNext++; //   connectionRecord.WindowLowerBound++; connectionRecord.State = connectionRecord.Tcb.States.SendingCycle; //   connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1); }

SendingCycle状態では、このメソッドはパケットのブロックを送信します。

SendingCycle.SendPacket：

 public override void SendPacket(ReliableUdpConnectionRecord connectionRecord) { //    for (connectionRecord.PacketCounter = 0; connectionRecord.PacketCounter < connectionRecord.WindowSize && connectionRecord.SndNext < connectionRecord.NumberOfPackets; connectionRecord.PacketCounter++) { ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord); ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header)); connectionRecord.SndNext++; } //     ,     connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 ); if ( connectionRecord.CloseWaitTimer != null ) { connectionRecord.CloseWaitTimer.Change( -1, -1 ); } }

コードの詳細。接続の作成と確立

基本的な状態と状態の処理に使用される方法に慣れたので、いくつかのプロトコル操作例の詳細を分析できます。

通常のデータ伝送図：

接続の接続レコードを作成し、最初のパケットを送信することを詳細に検討してください。転送の開始者は常に、メッセージを送信するためにAPIメソッドを呼び出すアプリケーションです。次に、送信制御ユニットのStartTransmissionメソッドがアクティブになり、新しいメッセージのデータ転送が開始されます。

アウトバウンド接続の作成：

 private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult) { if (m_isListenerStarted == 0) { if (this.LocalEndpoint == null) { throw new ArgumentNullException( "", "You must use constructor with parameters or start listener before sending message" ); } //     StartListener(LocalEndpoint); } //    ,   EndPoint  ReliableUdpHeader.TransmissionId byte[] transmissionId = new byte[4]; //    transmissionId m_randomCrypto.GetBytes(transmissionId); Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); //       , //         if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult))) { //   –      m_randomCrypto.GetBytes(transmissionId); key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult))) //     –   throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary"); } //     m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]); }

最初のパケットの送信（FirstPacketSending状態）：

 public override void SendPacket(ReliableUdpConnectionRecord connectionRecord) { connectionRecord.PacketCounter = 0; connectionRecord.SndNext = 0; connectionRecord.WindowLowerBound = 0; // ... //       ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord); ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header)); //   connectionRecord.SndNext++; //   connectionRecord.WindowLowerBound++; //    SendingCycle connectionRecord.State = connectionRecord.Tcb.States.SendingCycle; //   connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1); }

最初のパケットを送信した後、送信者はSendingCycle状態に入ります-パケットの配信の確認を待ちます。
受信側は、EndReceiveメソッドを使用して、送信されたパケットを受け入れ、新しい接続レコードを作成して、パケットを事前解析済みヘッダーとともにReceivePacketメソッドによるFirstPacketReceived状態の処理に渡します

受信側で接続を作成します。

 private void EndReceive(IAsyncResult ar) { // ... //   //    ReliableUdpHeader header; if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header)) { //    -   return; } //     connection record'   Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId); //   connection record    ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header. ReliableUdpMessageType)); //        record.State.ReceivePacket(record, header, bytes); }

最初のパケットを受信して送信確認（FirstPacketReceivedステータス）：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket)) //   return; // ... // by design  packet numbers   0; if (header.PacketNumber != 0) return; //       ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header); //      ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload); //  - ,    connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize)); //      (0) connectionRecord.RcvCurrent = header.PacketNumber; //      1 connectionRecord.WindowLowerBound++; //   connectionRecord.State = connectionRecord.Tcb.States.Assembling; if (/*    */) // ... else { //   ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1); } }

コードの詳細。接続タイムアウトを閉じる

タイムアウト処理は、Reliable UDPの重要な部分です。中間ノードで障害が発生し、両方向のデータ配信が不可能になった例を考えてみましょう。

タイムアウト接続閉鎖図：

図からわかるように、送信者の作業タイマーはパケットブロックを送信した直後に開始されます。これは、 SendingCycle状態のSendPacketメソッドで発生します。

ワーキングタイマーを有効にする（SendingCycle状態）：

 public override void SendPacket(ReliableUdpConnectionRecord connectionRecord) { //    // ... //     connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 ); if ( connectionRecord.CloseWaitTimer != null ) connectionRecord.CloseWaitTimer.Change( -1, -1 ); }

タイマー期間は、接続が作成されるときに設定されます。デフォルトでは、ShortTimerPeriodは5秒です。この例では、1.5秒に設定されています。

着信接続の場合、到着した最後のデータパケットを受信した後にタイマーが開始されます。これは、Assembling状態のReceivePacketメソッドで発生します

作業タイマーを有効にする（アセンブル状態）：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { // ... //   connectionRecord.TimerSecondTry = false; connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(-1, -1); // ... }

着信接続では、ワーキングタイマーが待機している間にパケットが受信されませんでした。タイマーは機能し、ProcessPacketsメソッドを呼び出しました。このメソッドでは、失われたパケットが検出され、再配信の要求が初めて送信されました。

再配信リクエストの送信（アセンブル状態）：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { // ... if (/*    */) { //      //     ,     if (!connectionRecord.TimerSecondTry) { connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); connectionRecord.TimerSecondTry = true; return; } //      WaitForPacketTimer //     -     StartCloseWaitTimer(connectionRecord); } else if (/*      */) { // ... StartCloseWaitTimer(connectionRecord); } //  ack      else { if (!connectionRecord.TimerSecondTry) { //   ack connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); connectionRecord.TimerSecondTry = true; return; } //     StartCloseWaitTimer(connectionRecord); } }

TimerSecondTry変数はtrueに設定されます。この変数は、作業タイマーを再起動します。

また、送信者は作業タイマーをトリガーし、最後に送信されたパケットを再送信します。

接続終了タイマーを有効にする（SendingCycle状態）：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { // ... //     // ... //   CloseWait –        StartCloseWaitTimer(connectionRecord); }

次に、発信接続で、接続を閉じるためのタイマーが開始されます。

ReliableUdpState.StartCloseWaitTimer：

 protected void StartCloseWaitTimer(ReliableUdpConnectionRecord connectionRecord) { if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1); else connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.LongTimerPeriod, -1); }

接続終了タイマーはデフォルトで30秒です。

しばらくすると、受信側の作業タイマーが再トリガーされ、リクエストが再度送信され、着信接続の接続

終了タイマーが開始されます。終了タイマーがトリガーされると、両方の接続レコードのすべてのリソースが解放されます。送信者は、アップストリームアプリケーションへの配信の失敗を報告します（API Reliable UDPを参照）。

接続レコードリソースの解放：

 public void Dispose() { try { System.Threading.Monitor.Enter(this.LockerReceive); } finally { Interlocked.Increment(ref this.IsDone); if (WaitForPacketsTimer != null) { WaitForPacketsTimer.Dispose(); } if (CloseWaitTimer != null) { CloseWaitTimer.Dispose(); } byte[] stream; Tcb.IncomingStreams.TryRemove(Key, out stream); stream = null; Tcb.OutcomingStreams.TryRemove(Key, out stream); stream = null; System.Threading.Monitor.Exit(this.LockerReceive); } }

コードの詳細。データ復旧

パケット損失の場合のデータ転送回復の図：

タイムアウトによる接続のクローズですでに説明したように、作業タイマーが切れると、受信者は失われたパケットをチェックします。パケットが失われた場合、受信者に到達しなかったパケットの数のリストが作成されます。これらの番号は、特定の接続のLostPackets配列に入力され、再配信のリクエストが送信されます。

再配信リクエストの送信（アセンブル状態）：

 public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord) { //... if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0)) { //   ,     foreach (int seqNum in connectionRecord.LostPackets) { if (seqNum != 0) { ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum); } } // ... } }

送信者は再配信リクエストを受け入れ、不足しているパッケージを送信します。この時点で、送信者はすでに接続を閉じるためのタイマーを開始しており、要求を受信するとリセットされます。

失われたパケットの再送信（SendingCycle状態）：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { // ... connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); //     if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(-1, -1); // ... //      –    else ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber)); }

再送信されたパケット（図のパケット＃3）は、着信接続によって受信されます。受信ウィンドウがいっぱいになるようにチェックが行われ、通常のデータ転送が復元されます。

受信ウィンドウに入っていることを確認します（アセンブル状態）：

 public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload) { // ... //    connectionRecord.PacketCounter++; //         connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber; //     if (header.PacketNumber > connectionRecord.RcvCurrent) connectionRecord.RcvCurrent = header.PacketNumber; //   connectionRecord.TimerSecondTry = false; connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1); if (connectionRecord.CloseWaitTimer != null) connectionRecord.CloseWaitTimer.Change(-1, -1); // ... //      ,    //     else if (connectionRecord.PacketCounter == connectionRecord.WindowSize) { //  . connectionRecord.PacketCounter = 0; //    connectionRecord.WindowLowerBound += connectionRecord.WindowSize; //     connectionRecord.WindowControlArray.Nullify(); ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord); } // ... }

信頼できるUDP API

データ転送プロトコルと対話するために、オープンクラスのReliable Udpがあります。これは、伝送制御ユニットのラッパーです。クラスの最も重要なメンバーは次のとおりです。

 public sealed class ReliableUdp : IDisposable { //     public IPEndPoint LocalEndpoint //   ReliableUdp   //      IP  //  .  0     //    public ReliableUdp(IPAddress localAddress, int port = 0) //      public ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null) //     public void Unsubscribe(ReliableUdpSubscribeObject subscribeObject) //    // :   XP  Server 2003  , ..  .NET Framework 4.0 public Task<bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken) //     public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state) //     public bool EndSendMessage(IAsyncResult asyncResult) //   public void Dispose() }

サブスクリプションによってメッセージが受信されます。コールバックメソッドの署名を委任します。

 public delegate void ReliableUdpMessageCallback( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient );

メッセージ：

 public class ReliableUdpMessage { //  ,   public ReliableUdpMessageTypes Type { get; private set; } //   public byte[] Body { get; private set; } //    true –      //     public bool NoAsk { get; private set; } }

特定のタイプのメッセージおよび/または特定の送信者をサブスクライブするには、2つのオプションパラメーターReliableUdpMessageTypes messageTypeおよびIPEndPoint ipEndPointが使用されます。

メッセージの種類：

 public enum ReliableUdpMessageTypes : short { //  Any = 0, //   STUN server StunRequest = 1, //   STUN server StunResponse = 2, //   FileTransfer =3, // ... }

メッセージは非同期的に送信されます;このため、プロトコルは非同期プログラミングモデルを実装します。

 public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)

メッセージの送信結果は、メッセージが受信者に正常に到達した場合はtrue、タイムアウトにより接続が閉じられた場合はfalseになります。

 public bool EndSendMessage(IAsyncResult asyncResult)

おわりに

この記事では多くのことは説明されていません。スレッドマッチングメカニズム、例外およびエラー処理、メッセージ送信用の非同期メソッドの実装。しかし、プロトコルの中核であるパケットの処理、接続の確立、タイムアウトの解決のロジックの説明は、あなたのために明確にされるべきです。

信頼できる配信プロトコルのデモ版は非常に安定しており、柔軟性があり、以前に定義された要件を満たしています。ただし、説明した実装を改善できることを付け加えます。たとえば、スループットを向上させ、タイマーの期間を動的に変更するには、スライディングウィンドウやRTTなどのメカニズムをプロトコルに追加できます。また、MTUを決定するメカニズムを実装すると便利です。接続のノード間（ただし、大きなメッセージを送信する場合のみ）。

ご意見、ご意見をお待ちしております。

PS詳細に興味がある場合、またはプロトコルをテストするだけの場合は、GitHubeのプロジェクトへのリンク：
Reliable UDP project

役立つリンクと記事

TCPプロトコル仕様：英語およびロシア語
UDPプロトコル仕様：英語とロシア語
RUDPプロトコルの説明：draft-ietf-sigtran-reliable-udp-00
信頼できるデータプロトコル：rfc 908およびrfc 1151
シンプルなUDP配信検証の実装：.NETおよびUDPを使用してネットワークを完全に制御
NATブリッジングメカニズムを説明する記事：ネットワークアドレス変換器を介したピアツーピア通信
非同期プログラミングモデルの実装：CLR非同期の実装モデルをプログラミングし、どのようにIAsyncResultインターデザインパターンを実装します
非同期プログラミングモデルからタスクベースの非同期テンプレート（TAPのAPM）への移行：
TPLおよび従来の.NET非同期プログラミング
 と他の非同期パターンおよびタイプとの相互運用

更新：インターフェイスにタスクを追加するアイデアについて、mayorovpとsidristijに感謝します。ライブラリと古いOSとの互換性は壊れていません。4番目のフレームワークは、XPサーバーと2003サーバーの両方をサポートしています。

.Net用の信頼性の高いUdpプロトコルの実装