TCP Tillförlitlighet

TCP (Transmission Control Protocol) är ett tillförlitligt transportprotokoll som säkerställer att data skickas, tas emot och återställs i rätt ordning. Till skillnad från UDP, som skickar datapaket utan kontroll på leveransen, övervakar TCP hela kommunikations flödet mellan avsändare och mottagare.

Med hjälp av sekvensnummer, kvittenser (ACK) och återöverföring av förlorade segment kan TCP garantera att ingen data går förlorad och att allt kommer fram i rätt ordning. Protokollet har dessutom mekanismer för flödeskontroll och överbelastnings hantering som skyddar nätverket och mottagande enheter från att överväldigas av för mycket data.

I detta avsnitt fokuserar vi på hur TCP uppnår tillförlitlighet – genom att numrera segment, hantera bekräftelser, återställa saknade data och styra flödet mellan sändare och mottagare. Du får också se hur TCP bygger upp en stabil förbindelse och ser till att kommunikationen avslutas på ett kontrollerat sätt.

Sekvensnummer och ordning

Ibland händer det att TCP-segment inte når fram till sin destination, eller att de anländer i fel ordning. För att mottagaren ska kunna återskapa det ursprungliga meddelandet måste alla segment tas emot och återsättas i rätt ordning. För att möjliggöra detta används sekvensnummer i TCP-huvudet. Sekvensnumret representerar den första databyten i segmentet.

Vid upprättandet av en TCP-session tilldelas ett initialt sekvensnummer (ISN). Detta värde anger startpunkten för de bytes som kommer att skickas. När data skickas ökar sekvensnumret med antalet överförda bytes.
Genom denna numrering kan varje segment identifieras unikt och bekräftas av mottagaren. Om något segment saknas kan sändaren identifiera och återställa det.

ISN startar inte på 1 utan väljs som ett slumpmässigt tal för att skydda mot vissa typer av attacker. (I exemplen i detta kapitel används dock 1 för enkelhetens skull.)

Mottagande TCP-process placerar data i en mottagnings buffert, sorterar segmenten i rätt ordning och överlämnar sedan datan till Applikationsskiktet. Segment som anländer utanför ordning sparas tills de saknade segmenten kommer fram, och först därefter bearbetas hela datamängden i rätt sekvens.

TCP tillförlitlighet – dataförlust och återöverföring

Även i välbyggda nätverk kan data ibland gå förlorad. TCP har därför inbyggda mekanismer för att hantera förlorade segment, bland annat genom att återsända data som inte kvitteras (unacknowledged data).

TCP använder två nummer för detta:

  • SEQ (Sequence number) – identifierar första byten i segmentet som skickas.
  • ACK (Acknowledgment number) – visar nästa byte som mottagaren förväntar sig att få.

Detta kallas för expectational acknowledgment.

Tidigare kunde TCP endast kvittera nästa byte som förväntades. Till exempel:

  • om host A skickar segment 1–10 till host B, men segment 3 och 4 förloras, svarar B med ACK 3 (”jag väntar på segment 3”).
  • Host A vet då inte vilka andra segment som faktiskt har kommit fram, och skickar därför om segment 3–10. Segment 5–10 blir då dubbletter, vilket skapar fördröjningar, nätverksbelastning och ineffektivitet.

För att förbättra detta infördes funktionen Selective Acknowledgment (SACK), som förhandlas under Three-Way Handshake.
Om båda hostar stöder SACK kan mottagaren uttryckligen ange vilka segment som mottagits korrekt och därmed låta sändaren endast återöverföra de saknade delarna. I vårt exempel skulle host B då skicka ACK 3 (för segment 1–2) och SACK 5–10. Host A behöver bara skicka om segment 3 och 4.

Observera: TCP skickar normalt en ACK för vartannat segment, men beteendet kan påverkas av andra faktorer. TCP använder timers för att avgöra hur länge den ska vänta på en ACK innan ett segment skickas om.

TCP flödeskontroll – fönsterstorlek och kvittenser

För att hålla överföringen tillförlitlig använder TCP även flödeskontroll, som styr hur mycket data mottagaren kan ta emot och bearbeta utan att bli överbelastad. Detta hanteras med hjälp av fönsterstorlek (window size), ett 16-bitars fält i TCP-huvudet.

Observera: Moderna system använder Sliding Window protokollet. Vanligtvis skickar mottagaren en ACK för varannan mottagen segment, men antalet kan variera.

Fönsterstorleken anger hur många byte mottagaren i en TCP-session kan ta emot och bearbeta vid ett givet tillfälle. Fönsterstorleken skickas med i varje TCP-segment, vilket gör att mottagaren när som helst kan ändra fönstrets storlek beroende på hur mycket ledigt utrymme den har i sin buffert.

Den initiala fönsterstorleken bestäms när TCP-sessionen etableras, under den så kallade Three-Way Handshake. Efter detta måste sändaren hela tiden anpassa hur mycket data som skickas utifrån mottagarens aktuella fönsterstorlek. Avsändaren får alltså inte skicka fler byte än vad mottagarens fönster tillåter. Först när en ACK har mottagits, som kvitterar att vissa byte tagits emot, kan sändaren fortsätta att skicka fler.

I praktiken väntar inte mottagaren tills hela sitt fönster fyllts innan den skickar en kvittens. I stället skickas löpande ACK-meddelanden allt eftersom data tas emot och bearbetas. På så sätt hålls kommunikationen igång och överföringen blir både effektiv och tillförlitlig.

TCP flödeskontroll – Maximum Segment Size (MSS)

MSS (Maximum Segment Size) anger hur mycket data (i bytes) en enhet kan ta emot i ett enda TCP-segment. MSS-fältet ingår i TCP-headerns Options-fält och förhandlas under Three-Way Handshake.

Ett vanligt värde för MSS är 1 460 bytes i IPv4-nätverk. Det beräknas genom att subtrahera IP- och TCP-huvudenas storlek (20 bytes vardera) från Ethernet-ramens MTU på 1 500 bytes:

1500 – (20 + 20) = 1460 bytes.

Sliding Window i praktiken

I detta exempel används en fönsterstorlek på 10 000 byte och en MSS (Maximum Segment Size) på 1 460 byte. Det innebär att mottagaren (PC B) kan ta emot upp till 10 000 byte innan den måste skicka en ny bekräftelse, och att varje segment som sänds får innehålla upp till 1 460 byte data.

  1. PC B meddelar i sitt initiala TCP-segment att den kan ta emot 10 000 byte (Window size = 10 000) och att varje segment får vara 1 460 byte (MSS = 1460).
  2. PC A börjar sända det första segmentet:
    • Sekvensnummer: 1
    • Datamängd: byte 1–1460
    • PC B tar emot dessa byte utan problem.
  3. PC A sänder nästa segment:
    • Sekvensnummer: 1461
    • Datamängd: byte 1461–2920
    • PC B tar emot även dessa.
  4. PC B skickar nu en kvittens (ACK = 2921) och anger fortfarande ett fönster på 10 000 byte.
    • Detta betyder att PC B har tagit emot alla byte upp till 2 920 och nu väntar på nästa byte, nummer 2 921.
  5. PC A fortsätter sända:
    • Sekvensnummer: 2921
    • Datamängd: byte 2921–4380
    • PC B tar emot segmentet och skickar tillbaka ACK = 4381, med fönsterstorlek 10 000.
  6. PC B skickar nu en kvitens (ACK = 4381) och anger fortfarande ett fönster på 10000 byte.

TCP-flödeskontroll – hantering av nätverksträngsel

När nätverk blir överbelastade kan routrar börja släppa paket, vilket gör att vissa TCP-segment inte når fram till mottagaren. TCP märker detta när kvittenser (ACK) uteblir eller fördröjs. Om istället sändaren skulle försöka skicka om för många segment samtidigt, skulle det bara förvärra trängseln – eftersom även de återöverförda segmenten ökar belastningen i nätet.

För att undvika detta använder TCP olika trängselhanteringsalgoritmer och timers som automatiskt reglerar hur snabbt data får skickas. När sändaren upptäcker att vissa segment inte kvitteras i tid, minskar den antalet obekräftade byte som får vara ”ute” samtidigt – det vill säga den minskar sitt fönsterstorlek. Det är alltså sändaren, inte mottagaren, som aktivt anpassar överföring för att minska trängseln och hjälpa nätverket att återhämta sig.

Observera: De exakta detaljerna om TCP:s trängselhanteringsalgoritmer (som Slow Start, Congestion Avoidance och Fast Recovery) behandlas inte i denna kurs.

Skillnaden mellan flödeskontroll och trängselkontroll

Det är viktigt att skilja mellan flödeskontroll (flow control) och trängselkontroll (congestion control) – två mekanismer som ofta blandas ihop men som löser olika problem:

  • Flödeskontroll handlar om kommunikationen mellan sändare och mottagare.
    Syftet är att förhindra att mottagarens buffert blir överfull. Mottagaren anger därför en fönsterstorlek som talar om hur mycket data den kan ta emot åt gången.
    Sändaren måste anpassa sin överföring efter denna gräns.
  • Trängselkontroll handlar däremot om hela nätverket.
    Syftet är att minska belastningen när nätet blir överfullt, till exempel när routrar börjar tappa paket.
    Här är det sändaren själv som märker av problemet (genom uteblivna kvittenser) och sänker överföringshastigheten för att hjälpa nätet återgå till ett stabilt läge.

Kort sagt:

  • Flödeskontroll skyddar mottagaren.
  • Trängselkontroll skyddar nätverket.