Implementation of the Reliable Udp protocol for .Net

Internet on juba ammu muutunud. Üks peamisi Interneti protokolle – UDP, mida kasutatakse rakendustes mitte ainult andmegrammide ja levitamisringide edastamiseks, vaid ka „peer-to-peer“ ühenduste tagamiseks võrgus. Oma lihtsa struktuuri tõttu on sellel protokollil ilmunud palju mitteplaneeritud kasutusvõimalusi, kuid protokolli puudused, nagu garantii puudumine andmete edastamisel, ei ole kuhugi kadunud. Selles artiklis käsitletakse garantii tagamise protokolli rakendamist UDP üle.
Sisukord:Sissejuhatus
Protokolli nõuded
Reliable UDP pealkiri
Protokolli üldpõhimõtted
Protokolli ajutised katkestused ja taimerid
Reliable UDP edastuse olekute diagramm
Süveneme koodi. Edastuse juhtimisplokk
Süveneme koodi. Oleku jälgimine

• Meetod DisposeByTimeout
• Meetod ProcessPackets
• Meetod ReceivePacket
• Meetod SendPacket

Süveneme koodi. Ühenduste loomine ja seadistamine
Süveneme koodi. Ühenduse sulgemine ajutise katkestuse tõttu
Süveneme koodi. Andmeedastuse taastamine
Reliable UDP API
Kokkuvõte
Kasulikud lingid ja artiklid

Sissejuhatus

Algne Interneti arhitektuur eeldas ühtlast aadressiruumi, kus igal sõlmel oli globaalne ja ainulaadne IP-aadress ning ta sai otse suhelda teiste sõlmede vahel. Praegu on Internetil tegelikult erinev arhitektuur – üks globaalne IP-aadresside ruum ja palju privaatsete aadressidega piirkondi, mis on NAT-seadmete tagant peidetud.Selles arhitektuuris saavad globaalses aadressiruumis olevad seadmed hõlpsasti suhelda kellegagi Internetis, kuna neil on ainulaadne, globaalne marsruutitav IP-aadress. Erasektoris asuv sõlm saab ühendada teiste sõlmedega samas võrgus, samuti olla ühenduses teiste hästi tuntud sõlmedega globaalses aadressiruumis. Selline interaktsioon on võimalik suuresti tänu võrguaadresside konversioonimehhanismile. NAT-seadmed, näiteks Wi-Fi marsruuterid, loovad spetsiaalsed kirjed edastamislaudadesse väljaminevate ühenduste jaoks ja muudavad IP-aadresse ja sadamate numbreid paketis. See võimaldab moodustada erasektorist väljamineva ühenduse globaalses aadressiruumis olevate sõlmedega. Samas blokeerivad NAT-seadmed tavaliselt kogu sissetuleva liikluse, välja arvatud juhul, kui sissetulevatele ühendustele on kehtestatud erireeglid.

Selline Interneti arhitektuur on üsna õige kliendi-serveri interaktsioonide jaoks, kus kliendid võivad asuda erasektorites, samas kui serveritel on globaalne aadress. Kuid see tekitab raskusi kahe sõlme otseseks ühendamiseks erinevate erasektorite vahel. Kahe sõlme vaheline otsene ühendus on oluline „peer-to-peer” rakenduste jaoks, nagu häälkõne edastamine (Skype), kaugarvutile ligipääsemine (TeamViewer) või veebimängud.

Üks tõhusamaid meetodeid peer-to-peer ühenduse loomisel erinevates erasektorites asuvate seadmete vahel nimetatakse „hole punching”. Seda tehnikat kasutatakse kõige sagedamini UDP-protokolliga rakendustes.

Kuid kui teie rakendus nõuab andmete garanteeritud kohaletoimetamist, näiteks kui edastate faile arvutite vahel, siis esinevad UDP kasutamisel mitmed raskused, kuna UDP ei ole garanteeritud kohaletoimetamise protokoll ega tagada pakettide kohaletoimetamist järjekorras, erinevalt TCP protokollist.

Sellisel juhul, et tagada pakettide garanteeritud kohaletoimetamine, on vajalik rakendada rakendustaseme protokoll, mis tagab vajaliku funktsionaalsuse ja töötab UDP peal.

Esimene asi, mida ma tahan märkida, on see, et eksisteerib TCP hole punching tehnik, et luua TCP ühendusi erinevates privaatvõrkudes, kuid paljude NAT-seadmete toetuse puudumise tõttu ei käsitleta seda tavaliselt peamise ühendusviisina nende sõlmede vahel.

Käesolevas artiklis käsitlen ainult garantii edastusprotokolli rakendust. UDP hole punching tehnika rakendamine käsitletakse järgmistes artiklites.

Protokolli nõuded

1. Usaldusväärne pakettide edastus, mis on ellu viidud positiivse tagasiside mehhanismi kaudu (nn positiivne kinnitamine)
2. On vajalik suuri andmeid tõhusalt edastada, st protokoll peab vältima liigseid pakettide edastamisi.
3. Peab olema võimalus tühistada edastuse kinnitamise mehhanism (võimalus funktsioneerida kui „puhas” UDP protokoll)
4. Võime rakendada käskude režiimi, kinnitades iga sõnumi.
5. Protokolli andmete peamiseks edastamise üksuseks peab olema sõnum.

Need nõudmised kattuvad suuresti Reliable Data Protocoli nõudmistega, mis on kirjeldatud rfc 908 ja rfc 1151, ja ma tuginesin nende standardite kohaselt selle protokolli arendamisel.

Nende nõudmiste mõistmiseks vaatame ajajooni andmete edastamise vahel kahe võrgu sõlme vahel TCP ja UDP protokollide kaudu. Oletame, et mõlemas olukorras kaotatakse üks pakett.
Eksitamatute andmete edastamine TCP kaudu:

Nagu diagrammist näha, tuvastab TCP pakettide kaotuse korral kaotatud paketi ja teavitab sellest saatjat, paludes kaotatud segmentide numbrit.
Andmete edastamine UDP protokolli kaudu:

UDP ei tee kaotuse tuvastamiseks mingeid samme. Veakontroll edastamisel UDP protokollis lasub täielikult rakendusel.

TCP protokolli veateave saavutatakse ühenduse loomise kaudu lõpp-punktiga, selle ühenduse oleku hoidmise kaudu, iga paketi päises saadetud baitide numbri näitamisega ja vastuvõtmise teavitamisega kinnitamise numbri "kinnitada number" abil.

Lisaks kasutab TCP protokoll liikluse tõhususe suurendamiseks (st rohkem kui ühe segmendi saatmiseks ilma kinnituse vastuvõtmiseta) nn edastamisaken - andmete baitide arv, mida segmentide saatja ootab vastu võtmiseks.

TCP protokolliga saab lähemalt tutvuda rfc 793, UDP-ga rfc 768, kus need tõepoolest määratakse.

Kuna eelnevalt kirjeldatud, on selge, et usaldusväärse sõnumi saatmise protokolli loomine UDP-i üle (edaspidi nimetame seda Reliable UDP), nõuab TCP-sarnaste andmeedastusmehhanismide rakendamist. Nimelt:

• säilitada ühenduse olek
• kasutada segmentide nummerdamist
• kasutada spetsiaalseid kinnituspakette
• kasutada lihtsustatud aknamehhanismi protokolli läbilaskevõime suurendamiseks

Lisaks on vajalik:

• anda märku sõnumite algusest, et eraldada ressursid ühenduse jaoks
• anda märku sõnumite lõpetamisest, et edastada saadud sõnum kõrgemale rakendusele ja vabastada protokolli ressursid
• lubada protokollil konkreetsetes ühendustes kinnitusmehhanismi välja lülitada, et toimida nagu "puhtam" UDP

Reliable UDP pealkiri

Tuletame meelde, et UDP datagramm kapseldatakse IP datagrammi. Vastav Reliable UDP pakett "ümber pakitakse" UDP datagrammi.
Reliable UDP päise kapseldamine:

Reliable UDP päis on piisavalt lihtne:

• Flags – paketi juhtimislipud
• MessageType – sõnumi tüüp, mida kasutatakse kõrgemates rakendustes teatud sõnumite tellimiseks
• TransmissionId – edastuse number, mis koos adressaadi ja sadamaga määratleb ühenduse unikaalselt
• PacketNumber – paketi number
• Options – protokolli lisavalikud. Esimese paketi puhul kasutatakse sõnumi suuruse näitamiseks

Flags võivad olla järgmised:

• FirstPacket — sõnumi esimene pakett
• NoAsk — sõnum ei vaja kinnitusmehhanismi kasutuselevõttu
• LastPacket — sõnumi viimane pakett
• RequestForPacket — kinnituspakett või kaotatud paketi nõue

Protokolli üldpõhimõtted

Kuna Reliable UDP on suunatud sõnumi garantii andmisele kahe sõlme vahel, peab see suutma luua ühenduse teise poolega. Ühenduse loomiseks saadab saatja paketi, millel on FirstPacket lipp, millele vastamine tähendab ühenduse loomist. Kõik vastuspaketid või teisisõnu, kinnituspaketid, määravad alati PacketNumber väljale väärtuse, mis on üks suurem kui suurim PacketNumber edukalt saabunud pakettidel. Esimese saadetud paketi Options väljale kirjutatakse sõnumi suurus.

Selle ühenduse lõpetamiseks kasutatakse sarnast mehhanismi. Viimases sõnumipakendis on seatud lipp LastPacket. Vastupakendis on näidatud viimase pakendi number + 1, mis tähendab vastuvõtva poole jaoks sõnumi edukat kohaletoimetamist.
Diagramm ühenduse loomise ja lõpetamise kohta:

Kui ühendus on loodud, algab andmete edastamine. Andmed edastatakse pakettide plokkidena. Igas plokis, välja arvatud viimane, on fikseeritud arv pakette. See on võrdne vastuvõtu/edastuse akna suurusega. Viimasel andmeplokil võib olla vähem pakette. Iga ploki saatmise järel ootab saatja teate kohalejõudmise kinnitust või nõuet kaotatud paketide uuesti edastamiseks, jättes vastuste vastuvõtmiseks vastuvõtu/edastuse akna avatuks. Pärast edastusploki kohaletoimetamise kinnituse saamist nihkub vastuvõtu/edastuse aken ja saadetakse järgmine andmeplokk.

Vastuvõtja pool saab pakette. Iga pakett kontrollitakse, kas see kuulub edastamise aknasse. Akna välja langenud paketid ja kopeeritud paketid tõrjutakse. Kuna akna suurus on rangelt fikseeritud ja sama nii vastuvõtja kui saatja jaoks, siis juhul, kui pakettide plokk on edastatud kaotusteta, nihkub aken järgmise andmeploki pakettide vastuvõtmiseks ning saadetakse kohaletoimetamise kinnitus. Kui aken ei täitu kindlaksmääratud tööajast, siis käivitatakse kontroll, millised paketid pole kohale jõudnud, ja saadetakse taotlused nende uuesti edastamiseks.
Diagramm uuesti edastamiseks:

Protokolli ajutised katkestused ja taimerid

On mitmeid põhjuseid, miks ühendust ei pruugi luua. Näiteks kui vastuvõtva poole võrk on maas. Sellisel juhul, kui proovitakse luua ühendust, suletakse see ajapiirangust tingituna. Reliable UDP teostuses kasutatakse ajapiirangute seadmiseks kahte taimerit. Esimene, töötaimer, teenib vastuse ootamiseks eemalolevalt hostilt. Kui see aktiveeritakse saatja poolel, saadetakse viimane saadetud pakett uuesti. Kui aga taimer aktiveeritakse vastuvõtja poolel, kontrollitakse kadunud pakette ja saadetakse taotlused nende uuesti edastamiseks.

Teine taimer on vajalik ühenduse lõpetamiseks juhul, kui sõlmede vahel pole ühendust. Saatja poolel käivitub see kohe pärast töötaimeri aktiveerimist ning ootab vastust eemalolevalt sõlmelt. Kui vastust ei tule ettenähtud aja jooksul, lõpetatakse ühendus ja vabastatakse ressursid. Vastuvõtja poolel käivitub ühenduse lõpetamise taimer pärast töötaimeri kahekordset aktiveerimist. See on vajalik, et kaitsta kinnituse paketi kadumise eest. Taimeri aktiveerumisel lõpetatakse samuti ühendus ja vabastatakse ressursid.

Reliable UDP edastuse olekute diagramm

Protokolli tööpõhimõtted on rakendatud lõppautomaatides, mille iga olek vastutab teatud pakettide töötlemise loogika eest.
Reliable UDP olekudiagramm:

Suletud – ei ole tegelikult olek, see on automaadi algus- ja lõpp-punkt. Oleku Suletud võtab juhtimisplokk, mis, rakendades asünkroonset UDP serverit, suunab paketid vastavatesse ühendustesse ja käivitab olekute töötlemise.

EsimesePaketiSaatmine – algolek, kus asub väljuv ühendus, kui saadetakse sõnum.

Selles olekus saadetakse esimene pakett tavaliste sõnumite jaoks. Kinnituse saatmist mittesisaldavate sõnumite puhul on see ainus olek – selles toimib kogu sõnumi saatmine.

SaatmisTsükkel – peamine olek sõnumi pakettide edastamiseks.

Üleminek sellesse olekusse toimub seisundist EsimesePaketiSaatmine pärast esimese paketiga sõnumi saatmist. Just sellesse olekusse jõuavad kõik kinnitused ja taotlused edasiste edastuste kohta. Sellest olekust võib välja minna kahes olukorras – sõnumi edukal kohaletoimetamisel või ajautuse tõttu.

EsimesePaketiSaamine – algolek sõnumi saajale.

Selles kontrollitakse edastamise alguse õigust, luuakse vajalikud struktuurid ja saadetakse kinnitamine esimese paketi vastuvõtmise kohta.

Üheainsa paketiga sõnumi puhul, mis saadeti ilma kohaletoimetamise kinnituse kasutamiseta – see on ainus olek. Pärast sellise sõnumi töötlemist lõpetatakse ühendus.

KokkuPanemine – peamine olek sõnumi pakettide vastuvõtmiseks.

Selle salvestatakse pakette ajutisse mällu, kontrollitakse kaotsimineku puudumist, saadetakse kinnitused pakettide bloki ja sõnumi edastamise kohta ning saadetakse taotlused kaotatud pakettide uuesti edastamiseks. Kui kogu sõnum on edukalt saadud, läheb ühendus olekusse Completed, vastasel juhul toimub ajapiirangust väljumine.

Completed – ühenduse lõpetamine kogu sõnumi edukal saamisel.

See olek on vajalik sõnumi koostamiseks ja juhul, kui sõnumi edastamise kinnitus on saatjale teel kaduma läinud. Selle oleku lõpetamine toimub ajapiirangust, kuid ühendust peetakse edukalt suletuks.

Süveneme koodi. Edastuse juhtimisplokk

Üks olulisemaid elemente Reliable UDP-s on edastuskontrolli plokk. Selle ploki ülesanne on säilitada praeguseid ühendusi ja abielemente, jagada saabunud pakette vastavatesse ühendustesse, anda liidese pakettide saatmiseks ning rakendada protokolli API-d. Edastuskontrolli plokk võtab pakette UDP tasemelt ja suunab need töötlemiseks lõpuma automaadile. Pakettide vastuvõtmiseks on seal rakendatud asünkroonne UDP server.
Mõned ReliableUdpConnectionControlBlocki klassi liikmed:

internal class ReliableUdpConnectionControlBlock : IDisposable
{
  // baidi massiiv spetsifitseeritud võtme jaoks. Kasutatakse sisenevate sõnumite koostamiseks
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> IncomingStreams { get; private set;}
  // baidi massiiv spetsifitseeritud võtme jaoks. Kasutatakse väliste sõnumite saatmiseks.
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> OutcomingStreams { get; private set; }
  // ühenduse kirje spetsifitseeritud võtme jaoks.
  private readonly ConcurrentDictionary<Tuple<EndPoint, Int32>, ReliableUdpConnectionRecord> m_listOfHandlers;
  // sõnumite tellijate loend.
  private readonly List<ReliableUdpSubscribeObject> m_subscribers;
  // kohalik soket
  private Socket m_socketIn;
  // port sisenevate sõnumite jaoks
  private int m_port;
  // kohalik IP-aadress
  private IPAddress m_ipAddress;
  // kohalik lõpp-punkt
  public IPEndPoint LocalEndpoint { get; private set; }
  // eelnevalt initsialiseeritud
  // automaadi olekute kogu
  public StatesCollection States { get; private set; }
  // juhuslike numbrite generaator. Kasutatakse TransmissionId loomisel
  private readonly RNGCryptoServiceProvider m_randomCrypto;
  	//...
}

Asünkroonse UDP serveri rakendamine:

private void Receive()
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  // Loome uus puhver iga socket.BeginReceiveFrom jaoks 
  byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length];
  // Edastame puhversisendi anonüümse meetodi parameetrina
  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);
  // Paket on saadud, valmis järgmist vastu võtma        
  Receive();
  // Kuna lihtsaim viis puhversisendi küsimuse lahendamiseks - saada sellele viide 
  // IAsyncResult.AsyncState kaudu        
  byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead);
  // Saame paketi päise        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // Saime vale paketi - loobume sellest
    return;
  }
  // Konstruktsioon võtme jaoks, et määrata paketi jaoks connection record
  Tuple key = new Tuple(connectedClient, header.TransmissionId);
  // Saame olemasoleva connection recordi või loome uue
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // Käivitame paketi töötlemise lõppautomaatis
  record.State.ReceivePacket(record, header, bytes);
}

Iga sõnumi edastamiseks luuakse struktuur, mis sisaldab teavet ühenduse kohta. Seda struktuuri nimetatakse connection record.
Mõned ReliableUdpConnectionRecord klassi liikmed:

internal class ReliableUdpConnectionRecord : IDisposable
{    
  // baitide massiiv sõnumiga    
  public byte[] IncomingStream { get; set; }
  // viide lõppautomaatide olekule    
  public ReliableUdpState State { get; set; }    
  // paar, mis määratleb ühenduse kirje üheselt
  // edastamise juhtimise plokis     
  public Tuple Key { get; private set;}
  // vastuvõtva akna alumine piir    
  public int WindowLowerBound;
  // edastusakna suurus
  public readonly int WindowSize;     
  // edastatav paketi number
  public int SndNext;
  // edastatavate paketide arv
  public int NumberOfPackets;
  // edastamise number (see on teine osa Tuple'st)
  // iga sõnumi jaoks oma	
  public readonly Int32 TransmissionId;
  // kaugklient – sõnumi saaja
  public readonly IPEndPoint RemoteClient;
  // paketi suurus, et vältida tükkideks minekut IP tasemel
  // ei tohi ületada MTU – (IP.Header + UDP.Header + RelaibleUDP.Header)
  public readonly int BufferSize;
  // edastamise juhtimise plokk
  public readonly ReliableUdpConnectionControlBlock Tcb;
  // kapseldab asünkroonse toimingu tulemusi BeginSendMessage/EndSendMessage jaoks
  public readonly AsyncResultSendMessage AsyncResult;
  // mitte saata kinnituse pakette
  public bool IsNoAnswerNeeded;
  // viimane õigesti saadud pakett (alati seadistatakse suurim number)
  public int RcvCurrent;
  // massiiv kadunud pakettide numbritega
  public int[] LostPackets { get; private set; }
  // kas viimane pakett on saabunud. Kasutatakse nagu bool.
  public int IsLastPacketReceived = 0;
  //...
}

Süveneme koodi. Oleku jälgimine

Olekud rakendavad Reliable UDP protokolli lõppautomaatide, kus toimub pakettide põhitöötlemine. Abstraktne klass ReliableUdpState pakub liidest oleku jaoks:

Protokolli kogu loogika töötab ülaltoodud klasside kaudu, koos abiklassiga, mis pakub staatilisi meetodeid, nagu näiteks ReliableUdp pealkirja koostamine ühenduse kirjest.

Edasi arutatakse liidese meetodite rakendusi, mis määratlevad protokolli põhialgoritmid.

Meetod DisposeByTimeout

Meetod DisposeByTimeout vastutab ühenduse ressursside vabastamise eest pärast ajutöö lõppemist ning edastamise edukuse/ebaõnnestumise signalisimise eest.
ReliableUdpState.DisposeByTimeout:

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

See on üle määratud ainult olekus Completed.
Completed.DisposeByTimeout:

protection void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
  // teavitame, et sõnum on edukalt vastuvõetud
  SetAsCompleted(connectionRecord);
}

Meetod ProcessPackets

Meetod ProcessPackets vastutab üksiku paketi või paketihulga täiendava töötlemise eest. Kutsutakse välja otse või paketide ooteaja kaudu.

olekus KokkuPanemine meetod on üle määratud ja vastutab kaotatud paketide kontrollimise ning olekusse ülemineku eest Completed, juhul kui viimane pakett on vastu võetud ja edukas kontroll on läbitud
Assembling.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // kaotatud paketid olemas, saadame nende kohta päringud
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // seadistame taimeri teist korda edastamise kordamiseks
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // kui kahe WaitForPacketTimer aktiveerimise katse järel
    // ei õnnestunud pakette kätte saada - käivitame ühenduse sulgemise taimeri
    StartCloseWaitTimer(connectionRecord);
  }
  else if (connectionRecord.IsLastPacketReceived != 0)
  // edukas kontroll
  {
    // saadame andmepaketi kätte saamise kinnituse
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.State = connectionRecord.Tcb.States.Completed;
    connectionRecord.State.ProcessPackets(connectionRecord);
    // asemel kohese ressursside elluviimisega
    // käivitame taimeri, juhuks kui
    // kui viimane kinnitamine ei jõua saatjani ja see küsib seda uuesti.
    // taimeri aktiveerimisel - ellu viime ressursid
    // olekus Completed on taimeri meetod üle määratud
    StartCloseWaitTimer(connectionRecord);
  }
  // see on olukord, kus kinnitamine mitme paketiga kadus
  else
  {
    if (!connectionRecord.TimerSecondTry)
    {
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // käivitame ühenduse sulgemise taimeri
    StartCloseWaitTimer(connectionRecord);
  }
}

olekus SaatmisTsükkel see meetod kutsutakse välja ainult taimeri kaudu ja vastutab viimase sõnumi uuesti saatmise ning ühenduse sulgemise taimeri käivitamise eest.
SendingCycle.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;
  
  // saatke uuesti viimane pakett 
  // (ühenduse taastamisel saadab vastuvõtja uuesti küsitlused, mis temani ei jõudnud) 
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1));
  // aktiveerime CloseWait taimeri – ühenduse taastamise või lõpetamise ootamiseks
  StartCloseWaitTimer(connectionRecord);
}

olekus Completed meetod peatab töötaimeri ja edastab sõnumi tellijatele.
Completed.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.WaitForPacketsTimer != null)
    connectionRecord.WaitForPacketsTimer.Dispose();
  // kogume sõnumi ja edastame selle tellijatele
  ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord);
}

Meetod ReceivePacket

olekus EsimesePaketiSaamine meetodi põhieesmärk on määrata, kas tõeliselt esimene sõnumi pakett jõudis liidesesse, samuti koguda sõnum, mis koosneb ainusest paketist.
FirstPacketReceived.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // viska pakett
    return;
  // kahe lipu kombinatsioon - FirstPacket ja LastPacket - ütleb, et meil on ainus sõnum
  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))
    {
      // saadame kinnituspaketi          
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    }
    SetAsCompleted(connectionRecord);
    return;
  }
  // disaini tõttu algavad kõik paketinumbrid 0-st;
  if (header.PacketNumber != 0)          
    return;
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // loeme kokku pakettide arvu, mis peavad saabuma
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
  // salvestame viimase saadud paketi numbri (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // seejärel liigutame vastuvõtu akna 1 võrra edasi
  connectionRecord.WindowLowerBound++;
  // vahetame olekut
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  // kui pole vaja kinnitusmehhanismi
  // käivitame taimeri, mis vabastab kõik struktuurid         
  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);
  }
}

olekus SaatmisTsükkel See meetod on üle kirjutatud kohaletoimetamise kinnituste ja kordusnõuete vastuvõtmiseks.
SendingCycle.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket))
    return;
  // lõpp-aken piiri arvutamine
  // akna piir + 1, et saada vastuvõtmise kinnitusi
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets));
  // kontrollimine aknasse mahtumise osas
  if (header.PacketNumber  windowHighestBound)
    return;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // viimane pakett kontrollimine:
  if (header.PacketNumber == connectionRecord.NumberOfPackets)
  {
    // edastus on lõpetatud
    Interlocked.Increment(ref connectionRecord.IsDone);
    SetAsCompleted(connectionRecord);
    return;
  }
  // see on esimese paketi vastus koos kinnitusega
  if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1))
  {
    // ilma akna nihketa
    SendPacket(connectionRecord);
  }
  // kinnituse saamine andmeploki vastuvõtmise kohta
  else if (header.PacketNumber == windowHighestBound)
  {
    // nihutame vastuvõtu/edastuse akent
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // nullime edastuse kontrolli massiivi
    connectionRecord.WindowControlArray.Nullify();
    // saadame pakettide ploki
    SendPacket(connectionRecord);
  }
  // see on taotlus korduvaks edastamiseks – saadame vajaliku paketi
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

olekus KokkuPanemine Meetodis ReceivePacket toimub peamine töö, kogum sõnumit saabuvate pakettide põhjal.
Assembling.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  // pakettide töötlemine ilma kinnitusmehhanismi
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    // taastame taimeri
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
    // salvestame andmed
    ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
    // kui saime paketi viimase lipuga - lõpetame
    if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
    {
      connectionRecord.State = connectionRecord.Tcb.States.Completed;
      connectionRecord.State.ProcessPackets(connectionRecord);
    }
    return;
  }
  // akna lõpppiiri arvutamine
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1));
  // kõrvaldame aknasse mitte kuuluvad paketid
  if (header.PacketNumber  (windowHighestBound))
    return;
  // eemaldame dubleeritud paketid
  if (connectionRecord.WindowControlArray.Contains(header.PacketNumber))
    return;
  // salvestame andmed 
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // suurendame paketihulka
  connectionRecord.PacketCounter++;
  // salvestame akna juhtimise massiivi praeguse paketi numbri
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // seadistame suurima saabunud paketi
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // taastame taimerid
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // kui viimane pakett on saabunud
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    Interlocked.Increment(ref connectionRecord.IsLastPacketReceived);
  }
  // kui saime kõik akna paketid, siis taastame loenduri
  // ja saadame kinnituspaketi
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // taastame loenduri.
    connectionRecord.PacketCounter = 0;
    // nihutasime ülekande akent
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // nulime edastamise juhtimise massiivi
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // kui viimane pakett on juba olemas
  if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0)
  {
    // kontrollime pakette
    ProcessPackets(connectionRecord);
  }
}

olekus Completed meetodi ainus ülesanne on saata korduv kinnitus sõnumi eduka kohaletoimetamise kohta.
Completed.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // viimase paketi uuesti saatmine, kuna
  // viimane ack ei jõudnud saatjasse
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
}

Meetod SendPacket

olekus EsimesePaketiSaatmine see meetod saadab esimese andmepaketi või, kui sõnum ei vaja kohaletoimetamise kinnitust, siis kogu sõnumi.
FirstPacketSending.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;
  // kui kinnitust ei nõuta - saadame kõik paketid
  // ja vabastame ressursid
  if (connectionRecord.IsNoAnswerNeeded)
  {
    // Siin toimub saatmine As Is
    do
    {
      ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord)));
      connectionRecord.SndNext++;
    } while (connectionRecord.SndNext < connectionRecord.NumberOfPackets);
    SetAsCompleted(connectionRecord);
    return;
  }
  // loome paketi pealkirja ja saadame selle
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // suurendame loenduri
  connectionRecord.SndNext++;
  // nihutame akent
  connectionRecord.WindowLowerBound++;
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Käivitame taimeri
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

olekus SaatmisTsükkel selles meetodis toimub pakettide bloki saatmine.
SendingCycle.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // saadame pakettide ploki      
  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++;
  }
  // suure edastusakna korral taaskäivitame taimeri pärast saatmist
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
  {
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  }
}

Süveneme koodi. Ühenduste loomine ja seadistamine

Nüüd, kui me oleme tuttavad põhiseisundite ja meetoditega, mida kasutatakse seisundite töötlemiseks, saame natuke põhjalikumalt analüüsida mõnda protokolli töö näidet.
Andmete edastamise diagramm normaalses keskkonnas:

Vaatame lähemalt loomist connection record ühendamiseks ja esimese paketi saatmiseks. Algatajana tegutseb alati rakendus, mis kutsub API meetodit sõnumi saatmiseks. Seejärel rakendatakse edastamise juhtimisploki meetodit StartTransmission, mis käivitab uue sõnumi andmete edastamise.
Välise ühenduse loomine:

private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult)
{
  if (m_isListenerStarted == 0)
  {
    if (this.LocalEndpoint == null)
    {
      throw new ArgumentNullException( "", "Peate kasutama parameetritega konstruktori või käivitama kuulamise enne sõnumi saatmist" );
    }
    // käivitame sissetulevate paketide töötlemise
    StartListener(LocalEndpoint);
  }
  // loome võti sõnastikule, põhinedes EndPoint ja ReliableUdpHeader.TransmissionId
  byte[] transmissionId = new byte[4];
  // loome juhusliku numbri transmissionId
  m_randomCrypto.GetBytes(transmissionId);
  Tuple key = new Tuple(endPoint, BitConverter.ToInt32(transmissionId, 0));
  // loome uue kirje ühenduse jaoks ja kontrollime, 
  // kas selline number juba eksisteerib meie sõnastikes
  if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
  {
    // kui eksisteerib – genereerime juhusliku numbri uuesti
    m_randomCrypto.GetBytes(transmissionId);
    key = new Tuple(endPoint, BitConverter.ToInt32(transmissionId, 0));
    if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
      // kui uuesti ei õnnestunud – genereerime erandi
      throw new ArgumentException("Paari TransmissionId & EndPoint eksisteerib juba sõnastikus");
  }
  // oleme käivitanud oleku töötlemiseks
  m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]);
}

Esimese paketi saatmine (olek FirstPacketSending):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // ... 
  // loome paketi päise ja saadame selle
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // suurendame loendurit
  connectionRecord.SndNext++;
  // nihutame akent
  connectionRecord.WindowLowerBound++;
  // liigutame olekusse SendingCycle
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Käivitame taimeri
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

Pärast esimese paketi saatmist liigub saatja olekusse SaatmisTsükkel – oodake paketi kohaletoimetamise kinnitust.
Saajapoolne osapool, kasutades meetodit EndReceive, võtab vastu saadetud paketi, loob uue connection record ja edastab selle paketi, eelnevalt parsitud päisega, ReceivePacket meetodi töötlemiseks. EsimesePaketiSaamine
Ühenduse loomine vastuvõtvas osas:

private void EndReceive(IAsyncResult ar)
{
  // ...
  // pakett on saadud
  // parsim paketipea
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // saabus ebakorrekne pakett - loobume sellest
    return;
  }
  // koostame võtme, et määrata paketi ühenduse rekord
  Tuple key = new Tuple(connectedClient, header.TransmissionId);
  // saame olemasoleva ühenduse rekordi või loome uue
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // käivitame paketi töötlemise lõpliku automaadi
  record.State.ReceivePacket(record, header, bytes);
}

Esimese paketi vastuvõtt ja kinnituse saatmine (olek FirstPacketReceived):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // loobume paketist
    return;
  // ...
  // disainist tulenevalt kõik paketide numbrid algavad 0-st;
  if (header.PacketNumber != 0)
    return;
  // initsialiseerime massiivi sõnumi osade hoidmiseks
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  // salvestame andmed paketisse massiivi
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // arvutame, kui palju pakette peab saabuma
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double)((double)connectionRecord.IncomingStream.Length / (double)connectionRecord.BufferSize));
  // salvestame viimase saadud paketi numbri (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // nihutame vastuvõtuaken 1 võrra
  connectionRecord.WindowLowerBound++;
  // lülitame oleku
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  if (/* kui kinnituse mehhanismi ei nõuta */)
  // ...
  else
  {
    // saadame kinnituse
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

Süveneme koodi. Ühenduse sulgemine ajutise katkestuse tõttu

Ajaületuste käsitlemine on oluline osa Reliable UDP-st. Vaatame näidet, kus vahepealses sõlmes juhtus rike ja andmete edastamine mõlemas suunas muutus võimatuks.
Ajastumise põhjal ühenduse sulgemise diagramm:

Nagu diagrammist näha, aktiveeritakse saatjal tööaeg pärast pakettide ploki saatmist. See toimub SendPacket meetodis. SaatmisTsükkel.
Tööaja aktiveerimine (olek SendingCycle):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // saadame pakettide ploki
  // ...
  // taaskäivitame taimeri pärast saatmist
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
}

Ajaintervalli määratakse yhteyden luontivaiheessa. Oletuksena ShortTimerPeriod on 5 sekuntia. Esimerkissä se on asetettu 1,5 sekuntiin.

Sisäisessä yhteydessä ajastin käynnistyy, kun viimeinen saapunut datapaketti on vastaanotettu, tämä tapahtuu ReceivePacket- menetelmässä. KokkuPanemine
Työajastimen aktivointi (tila Assembling):

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

Sisäisessä yhteydessä työajastimen odotusaikana ei tullut lisää paketteja. Ajastin aktivoitui ja kutsui menetelmää ProcessPackets, jossa havaittiin kadonneita paketteja ja ensimmäistä kertaa lähetettiin pyyntöjä niiden uudelleenlähettämiseksi.
Uudelleenlähetyspyyntöjen lähettäminen (tila Assembling):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...
  if (/*tarkistus kadonneista paketeista */)
  {
    // lähetetään uudelleenlähetyspyyntöjä
    // asetetaan ajastin toista kertaa, lähetysyrittäjälle
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // jos kahden WaitForPacketTimer -yrityksen jälkeen
    // paketteja ei saatu - käynnistetään yhteyden sulkemisajastin
    StartCloseWaitTimer(connectionRecord);
  }
  else if (/*viimeinen paketti saapui ja tarkistus onnistui */)
  {
    // ...
    StartCloseWaitTimer(connectionRecord);
  }
  // jos ack pakettijoukolle menetettiin
  else
  {
    if (!connectionRecord.TimerSecondTry)
    {
      // uudelleen lähetetään ack
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // käynnistetään yhteyden sulkemisajastin
    StartCloseWaitTimer(connectionRecord);
  }
}

Muuttuja TimerSecondTry asetettiin true. Tämä muuttuja vastaa työajastimen uudelleen käynnistämisestä.

Lähettäjän puolella aktivoituu myös työajastin ja viimeinen lähetetty paketti lähetetään uudelleen.
Yhteyden sulkemisajastimen aktivointi (tila SendingCycle):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  // uudelleen lähetetään viimeinen paketti 
  // ...        
  // käynnistetään CloseWait-ajastin - odotetaan yhteyden uudelleen muodostamista tai sen sulkemista
  StartCloseWaitTimer(connectionRecord);
}

Pärast seda käivitub lähteühenduses ühenduse sulgemise taimer.
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);
}

Ühenduse sulgemise taimeri ooteaeg on vaikimisi 30 sekundit.

Peagi käivitub vastuvõtja poolel uuesti töötaimer, saadetakse uuesti päringud ning seejärel käivitub sissetuleva ühenduse sulgemise taimer.

Taimerite sulgemisel vabastatakse kõigi ühenduse recordide ressursid. Saaja teatab edutuks jäämisest ülempoolsele rakendusele (vt API Reliable UDP).
Ühenduse recordi ressursside vabastamine:

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

Süveneme koodi. Andmeedastuse taastamine

Paketikaotuse taastamise diagramm:

Nagu juba arutatud ühenduse sulgemisel ajaülesande järgi, toimub vastuvõtja poolel töötaimeri lõppemisel kaotatud pakettide kontroll. Kui pakette on kadunud, koostatakse nimekiri numbritest, mis ei ole vastuvõtjani jõudnud. Need numbrid kantakse konkreetse ühenduse LostPackets massiivi ja saadetakse taotlused kordusete saatmiseks.
Kordusete saatmise taotluste saatmine (olek Assembling):

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

Saaja võtab vastu kordusetaotuse ja saadab puuduolevad paketid. Oluline on märkida, et sel hetkel on saatjal juba käivitatud ühenduse sulgemise taimer, mis taotluse saabumisel nullitakse.
Kaotatud pakettide kordus saatmine (olek SendingCycle):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  // lähtestatud ühenduse sulgemise taimer 
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // see on taotlus paketiretranspordiks – saadame vajaliku paketi
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

Ümber saadetud pakett (packet#3 diagrammil) võetakse vastu sissetuleva ühenduse poolt. Kontrollitakse vastuvõtuakna täituvust ja tavapärane andmete edastus taastatakse.
Kontroll vastuvõtuakna kohta (seisund Assembling):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  // suurendame paketisarvu        
  connectionRecord.PacketCounter++;
  // salvestame juhtimisse nn akna praeguse pakettnumbri        
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // määrame suurima vastuvõetud paketi        
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // taimerite taaskäivitamine        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // kui kõik akna paketid on vastuvõetud, siis lähtestame arvu
  // ja saadame kinnituse paketi
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // lähtestame arvu.
    connectionRecord.PacketCounter = 0;
    // edastusakna nihutamine
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // edastamise juhtimisse arvu nullimist
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // ...
}

Reliable UDP API

Andmeedastusprotokolli kasutamiseks on olemas avatud klass Reliable Udp, mis on juhtimisploki ümbris. Siin on klassi kõige olulisemad liikmed:

public sealed class ReliableUdp : IDisposable
{
  // saadab kohalik lõpp-punkt
  public IPEndPoint LocalEndpoint    
  // loob ReliableUdp eksemplari ja käivitab
  // sissetulevate pakettide kuulamise määratud IP-aadressil
  // ja pordil. Port 0 tähistab dünaamiliselt
  // jaotatud pordi kasutamist
  public ReliableUdp(IPAddress localAddress, int port = 0) 
  // registreerimine sissetulevate sõnumite saamiseks
  public ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null)    
  // registreerimise tühistamine
  public void Unsubscribe(ReliableUdpSubscribeObject subscribeObject)
  // asünkroonne sõnumi saatmine 
  // Tähelepanu: xp ja Server 2003 ühilduvus säilib, kuna kasutatakse .NET Framework 4.0
  public Task SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken)
  // alustada asünkroonset sõnumi saatmist
  public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
  // saada asünkroonse saatmise tulemus
  public bool EndSendMessage(IAsyncResult asyncResult)  
  // vabastada ressursid
  public void Dispose()    
}

Sõnumi saamine toimub registreerimise kaudu. Tagasi kutsumise meetodi delegeeritud allkiri:

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

Sõnum:

public class ReliableUdpMessage
{
  // sõnumi tüüp, lihtne loetelu
  public ReliableUdpMessageTypes Type { get; private set; }
  // sõnumi andmed
  public byte[] Body { get; private set; }
  // kui seatud tõeks - siis kätkeb kättesaamise kinnitamise mehhanism
  // konkreetse sõnumi edastamiseks
  public bool NoAsk { get; private set; }
}

Konkreetse sõnumitüübi ja/või konkreetse saatja jaoks registreerimiseks kasutatakse kahte valikulist parameetrit: ReliableUdpMessageTypes messageType ja IPEndPoint ipEndPoint.

Sõnumitüübid:

public enum ReliableUdpMessageTypes : short
{ 
  // Iga
  Any = 0,
  // Päring STUN serverile 
  StunRequest = 1,
  // Vastus STUN serverilt
  StunResponse = 2,
  // Failiülekanne
  FileTransfer =3,
  // ...
}

Sõnumi saatmine toimub asünkroonselt, selleks on protokollis rakendatud asünkroonne programmeerimismudel:

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

Sõnumi saatmise tulemus on true – kui sõnum on edukalt jõudnud saajani ja false – kui ühendus on aegunud:

public bool EndSendMessage(IAsyncResult asyncResult)

Kokkuvõte

Palju ei ole selle artikli raamides kirjeldatud. Voogude kokkuleppe mehhanismid, erandite ja vigade töötlemine, asünkroonsete sõnumi saatmise meetodite rakendamine. Kuid protokolli tuum, pakettide töötlemise loogika, ühenduse loomine ja ajaületuste käsitlemine peavad Teile selgeks saama.

Käideldud protokolli usaldusväärse edastamise versioon on piisavalt stabiilne ja paindlik ning vastab eelnevalt kindlaksmääratud nõuetele. Kuid soovin lisada, et kirjeldatud rakendust saab täiustada. Näiteks edastamise mahutavuse suurendamiseks ja protokolli aja perioodide dünaamiliseks muutmiseks saab lisada selliseid mehhanisme nagu uksed ja RTT, samuti oleks kasulik rakendada MTU määramise mehhanismi ühenduspunktide vahel (kuid ainult suurte sõnumite saatmise korral).

Aitäh tähelepanu eest, ootan Teie kommentaare ja märkusi.

P.S. Neile, kes huvituvad üksikasjadest või soovivad lihtsalt protokolli testida, siin on link projektile GitHubis:
Usaldusväärne UDP projekt

Kasulikud lingid ja artiklid

1. TCP protokolli spetsifikatsioon: inglise keeles ja eesti keeles
2. UDP protokolli spetsifikatsioon: inglise keeles ja eesti keeles
3. RUDP protokolli arutelu: draft-ietf-sigtran-reliable-udp-00
4. Usaldusväärne andmeprotokoll: rfc 908 ja rfc 1151
5. Lihtne UDP kohaletoimetamise kinnituse rakendamine: Võtke oma võrgu täielik kontroll .NET ja UDP abil
6. Artikkel, mis kirjeldab NAT-ide ületamise mehhanisme: Peer-to-Peer suhtlemine võrgu aadressi tõlkijate kaudu
7. Asünkroonse programmeerimismudeli rakendamine: CLR asünkroonse programmeerimismudeli rakendamine ja Kuidas rakendada IAsyncResult disainimustrit
8. Asünkroonse programmeerimismudeli üleviimine ülesannete põhisele mallile (APM-st TAP-ks):
   TPL ja traditsiooniline .NET asünkroonne programmeerimine
   Üksikasjad teiste asünkroonsete mustrite ja tüüpide vahel

Uuendus: Aitäh mayorovp ja sidristij idee lisada ülesanne liidesele. Raamatukogu ühilduvus vanade opsüsteemidega ei kannata, kuna 4. raamistik toetab nii XP-d kui ka 2003 serverit.

Allikas: habr.com