Implementering av Reliable UDP-protokollet för .Net

Internet har förändrats mycket. En av de grundläggande protokollen för Internet – UDP, används av applikationer inte bara för att leverera datagram och sända till flera mottagare, utan också för att möjliggöra "peer-to-peer"-anslutningar mellan nätverksnoder. På grund av sin enkla struktur har detta protokoll fått många oanade användningsområden, även om protokollets nackdelar, såsom bristen på garanterad leverans, fortfarande kvarstår. Denna artikel beskriver implementeringen av ett protokoll för garanterad leverans ovanpå UDP.
Innehåll:Inledning
Krav på protokollet
Rubrik för Reliable UDP
Allmänna principer för protokollets funktion
Timeouts och protokolltimer
Tillståndsdiagram för Reliable UDP-överföring
Djupare in i koden. Kontrollblock för överföring
Djupare in i koden. Tillstånd

• Metod DisposeByTimeout
• Metod ProcessPackets
• Metod ReceivePacket
• Metod SendPacket

Djupare in i koden. Skapande och upprättande av anslutningar
Djupare in i koden. Stängning av anslutningen vid timeout
Djupare in i koden. Återställning av datatransmission
API för Reliable UDP
Slutsats
Nyttiga länkar och artiklar

Inledning

Den ursprungliga arkitekturen för Internet förutsatte en homogen adresseringsstruktur, där varje nod hade en global och unik IP-adress, och kunde kommunicera direkt med andra noder. Idag har Internet i praktiken en annan arkitektur – ett område för globala IP-adresser och många områden med privata adresser, dolda bakom NAT-enheter.I en sådan arkitektur kan endast enheter som finns i det globala adressutrymmet enkelt interagera med andra i nätverket, eftersom de har en unik, globalt routbar IP-adress. En nod som befinner sig i ett privat nätverk kan ansluta till andra noder i samma nätverk samt ansluta till andra, välkända noder i det globala adressutrymmet. Denna interaktion uppnås delvis genom mekanismen för översättning av nätverksadresser. NAT-enheter, till exempel Wi-Fi-routrar, skapar speciella poster i översättningstabeller för utgående anslutningar och modifierar IP-adresserna och portnumren i paketen. Detta möjliggör att upprätta en utgående anslutning från ett privat nätverk till noder i det globala adressutrymmet. Men samtidigt blockerar NAT-enheter vanligtvis all inkommande trafik om det inte finns speciella regler för inkommande anslutningar.

Den här arkitekturen för Internet är ganska korrekt för klient-server-interaktion, där klienterna kan befinna sig i privata nätverk medan servrar har globala adresser. Men den skapar svårigheter för direktanslutning mellan två noder i olika privata nätverk. olika privata nätverk. Direktanslutning mellan två noder är viktigt för "peer-to-peer"-applikationer, såsom röstsnack (Skype), fjärråtkomst till datorer (TeamViewer) eller onlinespel.

En av de mest effektiva metoderna för att etablera en peer-to-peer-anslutning mellan enheter i olika privata nätverk kallas "hole punching". Denna teknik används oftast med applikationer baserade på UDP-protokollet.

Men om din applikation kräver garanterad dataleverans, till exempel om du överför filer mellan datorer, kommer det att uppstå många problem med att använda UDP, eftersom UDP inte är ett protokoll för garanterad leverans och inte säkerställer leverans av paket i ordning, till skillnad från TCP-protokollet.

I sådana fall, för att säkerställa garanterad paketsleverans, krävs det att implementera ett protokoll på applikationsnivå som tillhandahåller den nödvändiga funktionaliteten och går ovanpå UDP.

Först och främst vill jag påpeka att det finns en teknik för TCP hole punching, för att etablera TCP-anslutningar mellan noder i olika privata nätverk, men på grund av bristen på stöd från många NAT-enheter betraktas den vanligtvis inte som det primära sättet att ansluta sådana noder.

I denna artikel kommer jag att fokusera enbart på implementeringen av protokollet för pålitlig leverans. Implementeringen av tekniken för UDP hole punching kommer att beskrivas i kommande artiklar.

Krav på protokollet

1. Pålitlig leverans av paket genom en mekanism för positiv bekräftelse (så kallad positive acknowledgment)
2. Behovet av effektiv överföring av stora datamängder, dvs. protokollet måste undvika onödiga retransmissioner av paket
3. Det ska finnas möjlighet att avbryta bekräftelsemekanismen (möjlighet att fungera som ett "rent" UDP-protokoll)
4. Möjlighet till implementering av kommandoläge, med bekräftelse av varje meddelande
5. Den grundläggande enheten för datatransfer genom protokollet ska vara ett meddelande

Dessa krav överensstämmer till stor del med kraven för Reliable Data Protocol, som beskrivs i rfc 908 och rfc 1151, och jag har baserat mig på dessa standarder vid utvecklingen av detta protokoll.

För att förstå dessa krav, låt oss titta på tidsdiagram över datatransfer mellan två nätverksnoder enligt protokollen TCP och UDP. Låt oss anta att vi i båda fallen har förlorat ett paket.
Överföring av icke-interaktiva data via TCP:

Som framgår av diagrammet, vid paketförlust, kommer TCP att upptäcka den förlorade paketet och informera avsändaren, och begära numret på det förlorade segmentet.
Överföring av data med UDP-protokollet:

UDP vidtar inga åtgärder för att upptäcka förluster. Felkontroll av överföringen i UDP-protokollet är helt upp till applikationen.

Felupptäckning i TCP-protokollet uppnås genom att etablera en anslutning med den slutliga noden, bevara tillståndet för denna anslutning, ange nummer av skickade byte i varje pakets rubrik, samt meddelanden om mottagande med hjälp av bekräftelsenummer "acknowledge number".

Dessutom, för att öka prestandan (dvs. skicka mer än ett segment utan att få bekräftelse) använder TCP-protokollet så kallat överföringsfönster — antalet byte data som avsändaren av segmentet förväntar sig att ta emot.

Mer information om TCP-protokollet kan hittas i rfc 793, med UDP i rfc 768, där de faktiskt definieras.

Från det ovanstående är det tydligt att för att skapa ett pålitligt meddelandeleveransprotokoll över UDP (hädanefter kallat Reliable UDP), är det nödvändigt att implementera liknande mekanismer för dataöverföring som TCP. Det handlar om att:

• bevara anslutningstillstånd
• använda segmentnumrering
• använda speciella bekräftelsepaket
• använda en förenklad fönstermekanism för att öka protokollets genomströmning

Dessutom krävs:

• att signalera början av meddelandet för att avsätta resurser för anslutningen
• att signalera slutet av meddelandet för att överföra det mottagna meddelandet till applikationen ovanför och frigöra protokollets resurser
• att proktollet för specifika anslutningar ska kunna stänga av bekräftelsemekanismen för leverans så att det fungerar som "rent" UDP

Rubrik för Reliable UDP

Kom ihåg att en UDP-datagram kapslas i en IP-datagram. Reliable UDP-paketet 'slås' därmed in i en UDP-datagram.
Kapsling av Reliable UDP-headern:

Strukturen på Reliable UDP-headern är ganska enkel:

• Flags – kontrollerande flaggor för paketet
• MessageType – meddelandetyp, används av applikationer ovanför, för att prenumerera på specifika meddelanden
• TransmissionId — överföringsnummer, tillsammans med adress och port för mottagaren, unikt identifierar anslutningen
• PacketNumber – paketsnummer
• Options – ytterligare alternativ för protokollet. I fallet med det första paketet används den för att ange meddelandestorleken

Flaggor kan vara följande:

• FirstPacket — det första paketet av meddelandet
• NoAsk — meddelandet kräver inte att bekräftelsemekanismen aktiveras
• LastPacket — det sista paketet av meddelandet
• RequestForPacket — bekräftelsepaket eller begäran om förlorat paket

Allmänna principer för protokollets funktion

Eftersom Reliable UDP är inriktad på garanterad överföring av meddelandet mellan två noder, måste det kunna etablera en anslutning med den andra sidan. För att etablera en anslutning skickar avsändarsidan ett paket med flaggan FirstPacket, svaret på detta kommer att indikera att anslutningen har upprättats. Alla svarspaket, eller å sin sida, bekräftelsepaket, sätter alltid värdet på PacketNumber-fältet till ett mer än det största värdet av PacketNumber för framgångsrikt mottagna paket. I Options-fältet för det första skickade paketet skrivs meddelandestorleken.

För att slutföra anslutningen används en liknande mekanism. I det sista datablocket sätts flaggan LastPacket. I det svarande paketet anges numret på det sista paketet + 1, vilket för mottagarsidan innebär att meddelandet har levererats framgångsrikt.
Diagram för att etablera och avsluta anslutning:

När anslutningen har etablerats börjar dataöverföringen. Data överförs i paketblock. Varje block, förutom det sista, innehåller ett fast antal paket. Detta antal motsvarar storleken på mottagning/överföringens fönster. Det sista datablocket kan innehålla ett mindre antal paket. Efter att varje block har skickats väntar avsändarsidan på en bekräftelse på leverans eller en begäran om att skicka om förlorade paket, medan fönstret för mottagning/överföring hålls öppet för att ta emot svar. Efter att bekräftelsen på leverans av blocket har mottagits, flyttas fönstret för mottagning/överföring och nästa datablok skickas.

Mottagarsidan tar emot paketen. Varje paket kontrolleras för att se om det passar in i överföringsfönstret. Paket som inte passar in i fönstret och dubbletter sorteras bort. Eftersom storleken på fönstret är strikt fast och identisk för både mottagaren och avsändaren, flyttas fönstret för att ta emot paketen från nästa datablok och ett bekräftelsepaket skickas. Om fönstret inte är fyllt inom den tid som har ställts in av arbetstimeren, påbörjas en kontroll av vilka paket som inte har levererats och begärningar om att skicka om de förlorade paketen skickas.
Diagram för omöverföring:

Timeouts och protokolltimer

Det finns flera anledningar till varför en anslutning kanske inte kan upprättas. Till exempel, om mottagarsidan är offline. I så fall kommer anslutningen att stängas på grund av timeout vid försök att upprätta anslutningen. I implementeringen av Reliable UDP används två timers för att ställa in tidsgränser. Den första, arbets timern, används för att vänta på svar från den fjärranslutna värden. Om den aktiveras på avsändarsidan, skickas det senaste skickade paketet om. Om timern aktiveras på mottagarens sida, kontrolleras det för förlorade paket och begärningar om att skicka om dem skickas.

Den andra timern är nödvändig för att stänga anslutningen om det inte finns någon kommunikation mellan noderna. För avsändarens sida startar den omedelbart efter att arbets-timern aktiverats och väntar på svar från den avlägsna noden. Om inget svar ges inom den angivna perioden stängs anslutningen och resurserna frigörs. För mottagarens sida aktiveras stängnings-timern efter dubbel aktivering av arbets-timern. Detta är nödvändigt för att skydda mot förlust av bekräftelsepaket. När timern aktiveras avslutas också anslutningen och resurserna frigörs.

Tillståndsdiagram för Reliable UDP-överföring

Protokollets arbetsprinciper är implementerade i en ändlig automat, där varje tillstånd ansvarar för en viss logik för paketbearbetning.
Tillståndsdiagram för Reliable UDP:

Stängd är faktiskt inte ett tillstånd, det är start- och slutpunkten för automaten. Tillståndet Stängd betraktas som styrblock för överföringen, som genom att implementera en asynkron UDP-server vidarebefordrar paket till motsvarande anslutningar och startar tillståndshanteringen.

FirstPacketSending är det initiala tillståndet för den utgående anslutningen när meddelandet skickas.

I detta tillstånd skickas det första paketet för vanliga meddelanden. För meddelanden utan bekräftelse på leverans är detta det enda tillståndet – i det sker hela meddelandets utskick.

SendingCycle är det huvudsakliga tillståndet för överföring av meddelandepaket.

Övergången till detta tillstånd från tillståndet FirstPacketSending sker efter att det första meddelandepaketet har skickats. Det är i detta tillstånd som alla bekräftelser och begärningar om omöverföringar kommer. Utgången från detta tillstånd är möjlig i två fall – vid framgångsrik leverans av meddelandet eller vid tidsgräns.

FirstPacketReceived är det initiala tillståndet för mottagaren av meddelandet.

I detta tillstånd kontrolleras korrektheten av överföringsstarten, nödvändiga strukturer skapas och en bekräftelse på mottagandet av det första paketet skickas.

För ett meddelande som består av ett enda paket och skickas utan att använda leveransbekräftelse – är detta det enda tillståndet. Efter att detta meddelande har hanterats stängs anslutningen.

Assembling är det huvudsakliga tillståndet för mottagning av meddelandepaket.

I den registreras paket i ett temporärt lac, kontrolleras för att säkerställa att det inte finns några paketförluster, bekräftelser om leverans av paketblock och hela meddelanden skickas, samt förfrågningar om att skicka om förlorade paket. Vid framgångsrik mottagning av hela meddelandet går anslutningen till staten Slutförd, annars görs en timeout-utgång.

Slutförd – stängning av anslutningen vid framgångsrik mottagning av hela meddelandet.

Detta tillstånd är nödvändigt för att samla meddelandet och för situationen när bekräftelsen av meddelandets leverans har gått förlorad på väg till avsändaren. Utgång från detta tillstånd sker via timeout, men anslutningen anses vara framgångsrikt stängd.

Djupare in i koden. Kontrollblock för överföring

En av de viktigaste komponenterna i Reliable UDP är överföringskontrollblocket. Uppgiften för detta block är att lagra aktuella anslutningar och hjälpelement, fördela inkommande paket till motsvarande anslutningar, tillhandahålla gränssnitt för att skicka paket till anslutningen och implementera protokollets API. Överföringskontrollblocket tar emot paket från UDP-nivån och vidarebefordrar dem för behandling till en ändlig automat. För att ta emot paket har den en asynkron UDP-server implementerad.
Några medlemmar i klassen ReliableUdpConnectionControlBlock:

internal class ReliableUdpConnectionControlBlock : IDisposable
{
  // bytearray för angiven nyckel. Används för att sammanställa inkommande meddelanden
  public ConcurrentDictionary<Tuple, byte[]> IncomingStreams { get; private set;}
  // bytearray för angiven nyckel. Används för att skicka utgående meddelanden.
  public ConcurrentDictionary<Tuple, byte[]> OutcomingStreams { get; private set; }
  // anslutningspost för angiven nyckel.
  private readonly ConcurrentDictionary<Tuple, ReliableUdpConnectionRecord> m_listOfHandlers;
  // lista över prenumeranter på meddelanden.
  private readonly List m_subscribers;
  // lokal socket
  private Socket m_socketIn;
  // port för inkommande meddelanden
  private int m_port;
  // lokal IP-adress
  private IPAddress m_ipAddress;
  // lokal slutpunkt
  public IPEndPoint LocalEndpoint { get; private set; }
  // samling av förhandsinitialiserade
  // tillstånd för den ändliga automaten
  public StatesCollection States { get; private set; }
  // slumptalsgenerator. Används för att skapa TransmissionId
  private readonly RNGCryptoServiceProvider m_randomCrypto;
  	//...
}

Implementering av en asynkron UDP-server:

private void Receive()
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  // skapar en ny buffer för varje socket.BeginReceiveFrom 
  byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length];
  // överför bufferten som parameter till den asynkrona metoden
  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);
  // paketet har mottagits, redo att ta emot nästa        
  Receive();
  // eftersom det enklaste sättet att hantera bufferten är att få en referens till den 
  // från IAsyncResult.AsyncState        
  byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead);
  // hämta paketets header        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // felaktigt paket mottaget - avvisar det
    return;
  }
  // konstruera nyckeln för att identifiera connection record för paketet
  Tuple key = new Tuple(connectedClient, header.TransmissionId);
  // hämta befintlig connection record eller skapa en ny
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // starta paketet i automatens behandling
  record.State.ReceivePacket(record, header, bytes);
}

För varje meddelandetransfer skapas en struktur som innehåller information om anslutningen. Sådan struktur kallas connection record.
Några medlemmar av klassen ReliableUdpConnectionRecord:

intern klass ReliableUdpConnectionRecord : IDisposable
{    
  // byte-array med meddelande    
  public byte[] IncomingStream { get; set; }
  // referens till tillståndet för den slutna automaten    
  public ReliableUdpState State { get; set; }    
  // par som entydigt identifierar connection record
  // i överföringskontrollblocket     
  public Tuple Key { get; private set;}
  // nedre gräns för mottagningsfönstret    
  public int WindowLowerBound;
  // storlek på överföringsfönstret
  public readonly int WindowSize;     
  // paketnummer för att skicka
  public int SndNext;
  // antal paket som ska skickas
  public int NumberOfPackets;
  // överföringsnummer (detta är den andra delen av Tuple)
  // för varje meddelande sin	
  public readonly Int32 TransmissionId;
  // avlägsen IP-endpoint – själva mottagaren av meddelandet
  public readonly IPEndPoint RemoteClient;
  // storlek på paketet för att undvika fragmentering på IP-nivå
  // får inte överskrida MTU – (IP.Header + UDP.Header + RelaibleUDP.Header)
  public readonly int BufferSize;
  // block för överföringskontroll
  public readonly ReliableUdpConnectionControlBlock Tcb;
  // inkapslar resultaten av den asynkrona operationen för BeginSendMessage/EndSendMessage
  public readonly AsyncResultSendMessage AsyncResult;
  // inte skicka bekräftelsepaket
  public bool IsNoAnswerNeeded;
  // senaste korrekt mottagna paket (alltid inställt på det största numret)
  public int RcvCurrent;
  // array med nummer för förlorade paket
  public int[] LostPackets { get; private set; }
  // kom det senaste paketet? Används som bool.
  public int IsLastPacketReceived = 0;
  //...
}

Djupare in i koden. Tillstånd

Tillstånd implementerar den slutna automaten för protokollet Reliable UDP, där huvudarbetet med paketen sker. Den abstrakta klassen ReliableUdpState tillhandahåller ett gränssnitt för tillståndet:

All logik för protokollets funktionalitet implementeras av de ovan presenterade klasserna, tillsammans med en hjälparklass som tillhandahåller statiska metoder, såsom exempelvis konstruktion av ReliableUdp-huvudet från connection record.

Nedan kommer vi att gå igenom detaljerna i implementeringen av gränssnittets metoder som definierar protokollets huvudalgoritmer.

Metod DisposeByTimeout

Metoden DisposeByTimeout ansvarar för att frigöra anslutningsresurser vid timeout och för att signalera om ett meddelande har levererats framgångsrikt/inte framgångsrikt.
ReliableUdpState.DisposeByTimeout:

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

Det är åsidosatt endast i tillståndet Slutförd.
Completed.DisposeByTimeout:

protected override void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
  // meddelar om framgångsrik mottagning av meddelande
  SetAsCompleted(connectionRecord);        
}

Metod ProcessPackets

Metoden ProcessPackets ansvarar för ytterligare behandling av ett eller flera paket. Den anropas direkt eller via en paketfördröjningstimer.

I tillstånd Assembling metoden är överskriven och ansvarar för att kontrollera förlorade paket och byta till tillstånd Slutförd, vid mottagandet av det sista paketet och framgångsrik verifiering
Assembling.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // det finns förlorade paket, begär dem
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // ställer in en timer för andra försöket att skicka
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // om efter två försök med WaitForPacketTimer 
    // inte kan få paketen - startar stängningstimer
    StartCloseWaitTimer(connectionRecord);
  }
  else if (connectionRecord.IsLastPacketReceived != 0)
  // framgångsrik verifiering 
  {
    // skickar bekräftelse på mottagande av datablok
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.State = connectionRecord.Tcb.States.Completed;
    connectionRecord.State.ProcessPackets(connectionRecord);
    // istället för omedelbar implementering av resurser
    // startar vi en timer, ifall
    // ifall sista ack inte når avsändaren och denne begär det igen.
    // på timerutlösning - implementerar vi resurser
    // i staten Completed är timer metoden överskriven
    StartCloseWaitTimer(connectionRecord);
  }
  // detta är fallet när ack för databloken har förlorats
  else
  {
    if (!connectionRecord.TimerSecondTry)
    {
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // startar stängningstimer
    StartCloseWaitTimer(connectionRecord);
  }
}

I tillstånd SendingCycle denna metod anropas endast via timern och ansvarar för att åter skicka det senaste meddelandet samt aktivera stängningstimern.
SendingCycle.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;        
  // skickar om sista paketet 
  // (vid återställande av anslutning kommer mottagarens nod att skicka nya förfrågningar för de som inte nått fram)        
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1));
  // aktiverar CloseWait-timern – för att vänta på återställande av anslutning eller dess avslutande
  StartCloseWaitTimer(connectionRecord);
}

I tillstånd Slutförd metoden stoppar arbets timern och skickar ett meddelande till prenumeranter.
Completed.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.WaitForPacketsTimer != null)
    connectionRecord.WaitForPacketsTimer.Dispose();
  // samlar meddelandet och skickar det till prenumeranter
  ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord);
}

Metod ReceivePacket

I tillstånd FirstPacketReceived den huvudsakliga uppgiften för metoden är att avgöra om det första paketet av meddelandet verkligen kom till gränssnittet, samt att samla ett meddelande bestående av ett enda paket.
FirstPacketReceived.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // ignorera paketet
    return;
  // kombinationen av två flaggor - FirstPacket och LastPacket - indikerar att vi har ett enda meddelande
  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))
    {
      // skickar bekräftelsepaket
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    }
    SetAsCompleted(connectionRecord);
    return;
  }
  // enligt design börjar alla paketnummer med 0;
  if (header.PacketNumber != 0)
    return;
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // räknar antalet paket som förväntas komma
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double)((double)connectionRecord.IncomingStream.Length / (double)connectionRecord.BufferSize));
  // registrera det senaste mottagna paketnumret (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // flyttar sedan mottagningens fönster med 1
  connectionRecord.WindowLowerBound++;
  // växlar tillståndet
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  // om ingen bekräftelsemekanism krävs
  // starta en timer som frigör alla strukturer
  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);
  }
}

I tillstånd SendingCycle denna metod är överskriven för att ta emot bekräftelser om leverans och begärningar om omöverföring.
SendingCycle.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket))
    return;
  // beräkning av slutgränsen för fönstret
  // gränsen för fönstret + 1, för att få leveransbekräftelse
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets));
  // kontrollera om det ligger inom fönstret        
  if (header.PacketNumber  windowHighestBound)
    return;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // kontrollera sista paketet:
  if (header.PacketNumber == connectionRecord.NumberOfPackets)
  {
    // överföringen är klar
    Interlocked.Increment(ref connectionRecord.IsDone);
    SetAsCompleted(connectionRecord);
    return;
  }
  // detta är svar på första paketet med bekräftelse         
  if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1))
  {
    // utan skiftning av fönstret
    SendPacket(connectionRecord);
  }
  // bekräftelse på mottagning av datablok
  else if (header.PacketNumber == windowHighestBound)
  {
    // skiftar fönstret för mottagning/överföring
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // återställ kontrollarrayen för överföring
    connectionRecord.WindowControlArray.Nullify();
    // skicka paketblock
    SendPacket(connectionRecord);
  }
  // detta är en begäran om återöverföring – skickar det begärda paketet          
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

I tillstånd Assembling I metoden ReceivePacket sker det huvudsakliga arbetet med att sammanställa meddelandet från de inkommande paketen.
Sammanställning.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  // behandling av paket med inaktiv bekräftelsemekanism
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    // återställ timer
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
    // skriv data
    ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
    // om vi har fått paket med sista flaggan - avsluta
    if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
    {
      connectionRecord.State = connectionRecord.Tcb.States.Completed;
      connectionRecord.State.ProcessPackets(connectionRecord);
    }
    return;
  }
  // beräkna övre gräns för fönstret
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1));
  // filtrera bort paket som inte finns i fönstret
  if (header.PacketNumber  (windowHighestBound))
    return;
  // filtrera bort dubbletter
  if (connectionRecord.WindowControlArray.Contains(header.PacketNumber))
    return;
  // skriv data
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // öka paketräknaren
  connectionRecord.PacketCounter++;
  // skriv in det aktuella paketnumret i kontrollarrayen
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // ställ in det största mottagna paketnumret
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // återställ timers
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // om sista paket kommit
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    Interlocked.Increment(ref connectionRecord.IsLastPacketReceived);
  }
  // om vi har fått alla paket i fönstret, återställ räknaren
  // och skicka bekräftelsepaket
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // återställ räknaren.
    connectionRecord.PacketCounter = 0;
    // flytta överföringsfönstret
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // nollställ överföringskontrollarrayen
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // om sista paket redan är mottaget
  if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0)
  {
    // kontrollera paketen
    ProcessPackets(connectionRecord);
  }
}

I tillstånd Slutförd den enda uppgiften för metoden är att skicka en ny bekräftelse om framgångsrik leverans av meddelandet.
Completed.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  	// om sända om den senaste packet igen på grund av,
  	// att den senaste ack inte nådde avsändaren
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
}

Metod SendPacket

I tillstånd FirstPacketSending denna metod skickar det första datapakets, eller, om meddelandet inte kräver leveransbekräftelse - hela meddelandet.
FirstPacketSending.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  	// om ingen bekräftelse behövs - skicka alla paket
  	// och frigör resurser
  if (connectionRecord.IsNoAnswerNeeded)
  {
    	// Här sker sändningen As Is
    do
    {
      ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord)));
      connectionRecord.SndNext++;
    } while (connectionRecord.SndNext < connectionRecord.NumberOfPackets);
    SetAsCompleted(connectionRecord);
    return;
  }
  	// skapa paketets header och skicka den
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  	// öka räknaren
  connectionRecord.SndNext++;
  	// flytta fönstret
  connectionRecord.WindowLowerBound++;
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  	// Starta timern
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

I tillstånd SendingCycle i den här metoden sker sändningen av en paketblock.
SendingCycle.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  	// skicka en paketblock      
  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++;
  }
  	// vid en stor sändningsfönster, återstarta timern efter sändningen
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
  {
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  }
}

Djupare in i koden. Skapande och upprättande av anslutningar

Nu när vi har bekantat oss med de grundläggande tillstånden och metoderna som används för att hantera tillstånd, kan vi gå lite mer på djupet med några exempel på protokollets arbete.
Diagram över datalämning under normala förhållanden:

Låt oss ta en närmare titt på skapandet connection record för att etablera en koppling och skicka den första datapaketet. Initiativtagaren till överföringen är alltid applikationen som anropar API-metoden för att skicka meddelandet. Därefter används metoden StartTransmission från kontrollblocket för överföring, som påbörjar dataöverföringen för det nya meddelandet.
Skapande av en utgående koppling:

private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult)
{
  if (m_isListenerStarted == 0)
  {
    if (this.LocalEndpoint == null)
    {
      throw new ArgumentNullException( "", "Du måste använda konstruktör med parametrar eller starta lyssnaren innan du skickar meddelande" );
    }
    // startar bearbetningen av inkommande paket
    StartListener(LocalEndpoint);
  }
  // skapar nyckel för ordboken baserat på EndPoint och ReliableUdpHeader.TransmissionId
  byte[] transmissionId = new byte[4];
  // skapar ett slumpmässigt nummer transmissionId
  m_randomCrypto.GetBytes(transmissionId);
  Tuple key = new Tuple(endPoint, BitConverter.ToInt32(transmissionId, 0));
  // skapar en ny post för kopplingen och kontrollerar om det finns redan ett sådant nummer i våra ordböcker
  if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
  {
    // om det finns – generera ett nytt slumpmässigt nummer
    m_randomCrypto.GetBytes(transmissionId);
    key = new Tuple(endPoint, BitConverter.ToInt32(transmissionId, 0));
    if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
      // om det fortfarande misslyckas – generera ett undantag
      throw new ArgumentException("Par TransmissionId & EndPoint finns redan i ordboken");
  }
  // har startat tillståndet för behandling
  m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]);
}

Skickar det första paketet (tillstånd FirstPacketSending):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // ... 
  // skapar paketets header och skickar den
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // ökar räknaren
  connectionRecord.SndNext++;
  // justerar fönstret
  connectionRecord.WindowLowerBound++;
  // går in i tillståndet SendingCycle
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // startar timern
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

Efter att det första paketet har skickats övergår avsändaren till tillstånd SendingCycle – väntar på bekräftelse av paketets leverans.
Mottagarsidan, med hjälp av metoden EndReceive, tar emot det skickade paketet, skapar en ny connection record och vidarebefordrar detta paket, med en förhandsparserad header, för behandling till metoden ReceivePacket i tillståndet FirstPacketReceived
Skapa anslutning på mottagarsidan:

private void EndReceive(IAsyncResult ar)
{
  // ...
  // paket mottaget
  // parsar paketets rubrik
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // ett ogiltigt paket har kommit - avvisar det
    return;
  }
  // bygger nyckel för att identifiera anslutningsposten för paketet
  Tuple key = new Tuple(connectedClient, header.TransmissionId);
  // hämtar befintlig anslutningspost eller skapar en ny
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // startar paketet för behandling i tillståndsmaskinen
  record.State.ReceivePacket(record, header, bytes);
}

Mottagning av första paketet och skickar bekräftelse (tillstånd FirstPacketReceived):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // avvisar paketet
    return;
  // ...
  // designat så att alla paketnummer börjar från 0;
  if (header.PacketNumber != 0)          
    return;
  // initierar array för att lagra meddelandets delar
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  // skriver data på paketet i arrayen
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // beräknar antalet paket som ska komma
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double)((double)connectionRecord.IncomingStream.Length/(double)connectionRecord.BufferSize));
  // registrerar numret på det sista mottagna paketet (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // efter detta flyttas mottagningsfönstret fram med 1
  connectionRecord.WindowLowerBound++;
  // byter tillstånd
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  if (/*om bekräftelsemekanismen inte krävs*/)
  // ...
  else
  {
    // skickar bekräftelse
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

Djupare in i koden. Stängning av anslutningen vid timeout

Hantering av tidsgränser är en viktig del av Reliable UDP. Låt oss se på ett exempel där det har uppstått ett fel vid en mellanliggande nod och dataleveransen i båda riktningarna blivit omöjlig.
Diagram över stängning av anslutning på grund av tidsgräns:

Som kan ses i diagrammet aktiveras arbetstimer hos avsändaren omedelbart efter avsändning av paketblock. Detta sker i metoden SendPacket i tillståndet SendingCycle.
Aktivering av arbetstimer (tillstånd SendingCycle):

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

Tidsperioderna för timern anges vid skapandet av anslutningen. Som standard är ShortTimerPeriod 5 sekunder. I exemplet är den satt till 1,5 sekunder.

För en inkommande anslutning börjar timern efter att den senaste mottagna datapaketet har kommit, detta sker i metoden ReceivePacket i tillståndet Assembling
Aktivering av arbets timern (tillstånd Assembling):

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

I den inkommande anslutningen har det under väntetiden för arbets timern inte kommit fler paket. Timern har utlösts och kallat metoden ProcessPackets, där förlorade paket har upptäckts och för första gången har begärningar om omleverans skickats.
Skickande av förfrågningar om omleverans (tillstånd Assembling):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  if (/*kontroll av förlorade paket*/) 
  {
    // skickar förfrågningar om omleverans
    // ställer in timern för andra gången, för återförsök av överföring
    if (!connectionRecord.TimerSecondTry) 
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // om efter två försök av WaitForPacketTimer
    // har det inte gått att få paketen - starta stängningstimer för anslutningen
    StartCloseWaitTimer(connectionRecord);
  }
  else if (/*det sista paketet kom och kontrolleringen lyckades*/) 
  {
    // ...
    StartCloseWaitTimer(connectionRecord);
  }
  // om ack för paketblocket har gått förlorat
  else 
  { 
    if (!connectionRecord.TimerSecondTry) 
    {
      // skickar ack på nytt
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // startar stängningstimer för anslutningen
    StartCloseWaitTimer(connectionRecord);
  }
}

Variabeln TimerSecondTry ställdes in på true. Denna variabel ansvarar för omstart av arbets timern.

Även avsändaren utlöser arbets timern och skickar på nytt det senaste skickade paketet.
Aktivering av stängningstimer för anslutningen (tillstånd SendingCycle):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  // skickar på nytt det senaste paketet 
  // ...        
  // aktiverar CloseWait-timern – för att vänta på återställning av anslutningen eller dess avslutning
  StartCloseWaitTimer(connectionRecord);
}

Efter detta startas en stängningstimer för den utgående anslutningen.
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);
}

Stängningstimern för anslutningen har en standard väntetid på 30 sekunder.

Efter en kort stund aktiveras arbetsstimern på mottagarsidan igen, förfrågningar skickas på nytt och stängningstimern för den inkommande anslutningen startas.

Vid aktivering av stängningstimrarna frigörs alla resurser för båda anslutningarna. Avsändaren rapporterar om misslyckad leverans till överordnat applikation (se API Reliable UDP).
Frigöring av resurser för anslutningspost:

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

Djupare in i koden. Återställning av datatransmission

Diagram över återställning av datapaket vid paketförlust:

Som redan diskuterats, vid timeout av stängningen av anslutningen kommer mottagaren att kontrollera för paketförlust efter arbetsstimern har löpt ut. Vid paketförlust kommer en lista att sammanställas över paketnummer som inte nått mottagaren. Dessa nummer läggs till i arrayen LostPackets för den specifika anslutningen och förfrågningar om omleverans skickas.
Skickar förfrågningar om omleverans av paket (tillstånd Assembling):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  //...
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // det finns förlorade paket, skicka förfrågningar om dem
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // ...
  }
}

Avsändaren kommer att ta emot en begäran om omleverans och skicka de saknade paketen. Det är värt att notera att avsändarens stängningstimer redan är aktiverad vid detta tillfälle och kommer att återställas vid mottagning av begäran.
Omleverans av förlorade paket (tillstånd SendingCycle):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  // återställning av nedstängningstimer
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // detta är en begäran om retransmission – skicka den begärda paketet
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

Det omdetonerade paketet (packet#3 i diagrammet) tas emot av den ingående anslutningen. En kontroll för fyllning av mottagningsfönster genomförs och normal dataöverföring återställs.
Kontroll av om det ligger inom mottagningsfönstret (tillstånd Assembling):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  // öka paketräknaren
  connectionRecord.PacketCounter++;
  // skriv det aktuella paketnumret till fönsterhanteringsarrayen
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // ställ in det största mottagna paketet
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // starta om timrarna
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // om vi har fått alla paket i fönstret, nollställ räknaren
  // och skicka bekräftelsepaketet
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // nollställ räknaren.
    connectionRecord.PacketCounter = 0;
    // flyttade överföringsfönstret
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // nollställ överföringshanteringsarrayen
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // ...
}

API för Reliable UDP

För interaktion med dataöverföringsprotokollet finns en öppen klass Reliable Udp, som är en omslag kring överföringskontrollblocket. Här är de viktigaste medlemmarna i klassen:

offentlig förseglad klass ReliableUdp : IDisposable
{
  // får den lokala ändpunkten
  offentlig IPEndPoint LocalEndpoint    
  // skapar en instans av ReliableUdp och startar
  // lyssnar på inkommande paket på angiven IP-adress
  // och port. Värde 0 för port innebär användning
  // av en dynamiskt tilldelad port
  offentlig ReliableUdp(IPAddress localAddress, int port = 0) 
  // prenumeration på inkommande meddelanden
  offentlig ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null)    
  // avprenumerera från att ta emot meddelanden
  offentlig void Unsubscribe(ReliableUdpSubscribeObject subscribeObject)
  // asynkront skicka meddelande 
  // Obs: kompatibilitet med XP och Server 2003 går inte förlorad, eftersom .NET Framework 4.0 används
  offentlig Task SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken)
  // starta asynkron skickning av meddelande
  offentlig IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
  // få resultatet av den asynkrona sändningen
  offentlig bool EndSendMessage(IAsyncResult asyncResult)  
  // rensa resurser
  offentlig void Dispose()    
}

Mottagande av meddelande sker genom prenumeration. Signaturen för delegeringen till återanropmetoden:

offentlig delegerad void ReliableUdpMessageCallback(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient);

Meddelande:

offentlig klass ReliableUdpMessage
{
  // meddelandetyp, enkel uppräkning
  offentlig ReliableUdpMessageTypes Type { få; privat sätt; }
  // meddelandets data
  offentlig byte[] Body { få; privat sätt; }
  // om inställt på true - bekräftelsemekanismen för leverans kommer att inaktiveras
  // för att skicka ett specifikt meddelande
  offentlig bool NoAsk { få; privat sätt; }
}

För att prenumerera på en specifik typ av meddelanden och/eller en specifik avsändare används två valfria parametrar: ReliableUdpMessageTypes messageType och IPEndPoint ipEndPoint.

Meddelandetyper:

offentlig enum ReliableUdpMessageTypes : kort
{ 
  // Vilken som helst
  Any = 0,
  // Förfrågan till STUN-server
  StunRequest = 1,
  // Svar från STUN-server
  StunResponse = 2,
  // Filöverföring
  FileTransfer = 3,
  // ...
}

Skickandet av meddelande sker asynkront, för detta har protokollet implementerat en asynkron programmeringsmodell:

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

Resultatet av meddelandesändning kommer att vara true - om meddelandet framgångsrikt nått mottagaren och false - om anslutningen stängdes på grund av tidsgräns:

offentlig bool EndSendMessage(IAsyncResult asyncResult)

Slutsats

Mycket har inte beskrivits i denna artikel. Mekanismer för strömöverenskommelse, hantering av undantag och fel samt implementering av asynkrona meddelandesändningsmetoder. Men kärnan i protokollet, beskrivningen av logiken för paketbehandling, anslutningsinställningar och timeouthantering, bör klargöras för dig.

Den demonstrerade versionen av det pålitliga leveransprotokollet är tillräckligt stabil och flexibel och motsvarar vissa tidigare krav. Men jag vill tillägga att den beskrivna implementeringen kan förbättras. Till exempel, för att öka kapaciteten och dynamiskt justera timerintervall kan mekanismer som sliding window och RTT läggas till protokollet, och det skulle även vara användbart att implementera en mekanism för att bestämma MTU mellan anslutningsnoderna (men endast vid sändning av stora meddelanden).

Tack för uppmärksamheten, jag ser fram emot dina kommentarer och anmärkningar.

P.S. För den som är intresserad av detaljer eller bara vill testa protokollet, här är länken till projektet på GitHub:
Projektet Reliable UDP

Nyttiga länkar och artiklar

1. Specifikation för TCP-protokollet: på engelska och på ryska
2. Specifikation för UDP-protokollet: på engelska och på ryska
3. Diskussion om RUDP-protokollet: draft-ietf-sigtran-reliable-udp-00
4. Reliable Data Protocol: rfc 908 och rfc 1151
5. En enkel implementering av leveransbekräftelse över UDP: Ta full kontroll över ditt nätverk med .NET och UDP
6. Artikel som beskriver mekanismer för att övervinna NAT:er: Peer-to-Peer-kommunikation över nätverksadressöversättare
7. Implementering av asynkron programmeringsmodell: Implementing the CLR Asynchronous Programming Model och Hur man implementerar designmönstret IAsyncResult
8. Överföring av den asynkrona programmeringsmodellen till ett asynkront mönster baserat på uppgifter (APM till TAP):
   TPL och traditionell .NET asynkron programmering
   Interop med andra asynkrona mönster och typer

Uppdatering: Tack mayorovp och sidristij för idén om att lägga till en uppgift till gränsnittet. Kompatibiliteten för biblioteket med äldre OS påverkas inte, eftersom den fjärde ramen stöder både XP och 2003-server.

Källa: habr.com