Inhalt der Vorlesung
|
|
- Anneliese Lenz
- vor 7 Jahren
- Abrufe
Transkript
1 Einführung Anwendungsschicht Transportschicht Netzwerkschicht Sicherungsschicht Physikalische Schicht Inhalt der Vorlesung [RN] Sommer 2012 Transportschicht 1
2 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 2
3 Einführung Aufgabe der Transportschicht: Kommunikation zwischen Anwendungsprozessen = socket = process application P3 P1 P1 application P2 P4 application transport transport transport network network network link link link physical physical host 1 host 2 host 3 physical [RN] Sommer 2012 Transportschicht 3
4 Einführung mögliche Dienstmerkmale Fehlerkontrolle Bewahrung der Reihenfolge verbindungslos/verbindungsorientiert Fluss- und Überlastkontrolle Garantien für Dienstgüte (z.b. Bitrate, Verzögerung, Verlust) User Datagram Protocol (UDP) verbindungslos, keine Kontrollmechanismen, bewahrt nicht Reihenfolge Schnittstelle für einfache Paketvermittlung mittels IP, Verantwortung für Kontrollmechanismen bei Anwendung Transmission Control Protocol (TCP) verbindungsorientiert, Fehler-, Fluss-, Überlastkontrolle, keine Dienstgütegarantien bietet Abstraktion eines Bytestroms [RN] Sommer 2012 Transportschicht 4
5 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 5
6 Segment: source port: Quellportnummer (16 Bit) dest port: Zielportnummer (16 Bit) UDP length: Länge des gesamten Segments (16 Bit) checksum: Prüfsumme (16 Bit) für mögliche Fehlerkontrolle, Benutzung ist optional, bedeutet: ungenutzt Frage: wo befinden sich Quell- und Ziel-IP-Adresse? source port # dest port # length 32 bits Application data (message) checksum [RN] Sommer 2012 Transportschicht 6
7 UDP Multiplexen und Demultiplexen Multiplexen: Zusammenführen der Segmente verschiedener Anwendungsprozesse durch Transportschicht auf dem Quellhost Demultiplexen: Ausliefern der Segmente an die verschiedenen Anwendungsprozesse durch Transportschicht des Zielhosts Anwendungsprozess vereinbart mit Transportschicht auf Quellhost Quellportnummer (wird entweder durch Anwendung gewählt oder ein freier Port wird vom Betriebssystem geliefert) UDP auf dem Zielhost erkennt an Zielportnummer (und nur daran), zu welcher Anwendung das Segment geliefert werden soll ein Anwendungsprozess kann mehrere Sockets besitzen [RN] Sommer 2012 Transportschicht 7
8 UDP Multiplexen und Demultiplexen, Beispiel: P2 P3 P1 P1 SP: 6428 DP: 9157 SP: 6428 DP: 5775 SP: 9157 DP: 6428 SP: 5775 DP: 6428 [RN] Sommer 2012 Transportschicht 8
9 UDP Berechnung der Prüfsumme Segment wird als Folge von Dualzahlen der Länge 16 Bit aufgefaßt diese werden in Einerkomplementarithmetik addiert -x entsteht aus x durch Invertierung aller Bits entsteht ein Übertrag, wird das Ergebnis inkrementiert das Ergebnis wird invertiert, dies ist die Prüfsumme der Sender berechnet die Prüfsumme und schreibt sie in das Segment der Empfänger berechnet in gleicher Weise die Prüfsumme und addiert in Einerkomplementarithmetik die aus dem Segment gelesene Prüfsumme falls kein Bitfehler vorliegt, ergibt sich als Ergebnis , die Einerkomplement-Repräsentation von 0 einzelne Bitfehler werden erkannt, doppelte nicht es gibt bessere Fehlererkennungsmechanismen [RN] Sommer 2012 Transportschicht 9
10 UDP Berechnung der Prüfsumme, Beispiel: Übertrag Summe Prüfsumme [RN] Sommer 2012 Transportschicht 10
11 UDP Pseudo-Header es ist in Wirklichkeit noch ein bißchen komplizierter... Pseudo-Header enthält Quell- und Ziel-IP-Adresse, Protokollnummer (17 für UDP) und Segmentlänge UDP des Senders schreibt zunächst 0 in das Checksum-Feld, erstellt einen Pseudo-Header und berechnet die Prüfsumme zusammen für das UDP- Segment und den Pseudo-Header diese Prüfsumme wird in das Checksum-Feld geschrieben dann wird das Segment und der Pseudo-Header an IP weitergereicht UDP des Empfängers erhält von IP das UDP-Segment und den Pseudo- Header, schreibt 0 in das Checksum-Feld und berechnet die Prüfsumme für Segment und Pseudo-Header Vorteil: die Kontrolle der Prüfsumme erkennt auch Fehler in den IP- Adressen, z.b. fehlgeleitete Segmente Nachteil: Verletzung des Schichtenprinzips (aber nur auf Endsystem) [RN] Sommer 2012 Transportschicht 11
12 UDP Bitfehlerwahrscheinlichkeiten sei die Wahrscheinlichkeit eines einzelnen Bitfehlers p = 10-7 sei die Segmentlänge N = 10 4 Bits übliche vereinfachende Annahme (um überhaupt rechnen zu können): die Bitfehler der einzelnen Bits sind unabhängig voneinander Wahrscheinlichkeit für mindestens einen Bitfehler im Segment: 1-(1-p) N =0, = 10-3 Wahrscheinlichkeit für zwei Bitfehler im Segment: Anzahl Paare: N 1 i= 1 i = (N 1) N / 2 = 1) 10 / 2 10 Wahrscheinlichkeit, daß ein bestimmtes Paar fehlerhaft ist: Wahrscheinlichkeit, daß ein beliebiges Paar fehlerhaft ist: /2 = 10-6 /2 wie lange dauert es im Mittel, bis ein Segment mit zwei Bitfehlern auftritt bei a) 10 Mbps und b) 10 Gbps? ( / 2 [RN] Sommer 2012 Transportschicht 12
13 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 13
14 Fehlerkontrolle Host A Host B Sendeprozeß Empfangsprozeß unzuverlässiger Kanal Rauschen, Pufferüberläufe, Ausfälle von Komponenten verursachen Bitfehler und Paketverluste kann durch Protokoll mit Fehlererkennung, Bestätigungen und Sendewiederholungen ausgeglichen werden [RN] Sommer 2012 Transportschicht 14
15 Fehlerkontrolle Host A Host B Sendeprozeß Empfangsprozeß reliable data transfer protocol rdt_send(data) udt_send(pkt) udt_rcv(ack) rdt_rcv(data) reliable data transfer protocol udt_rcv(pkt) udt_send(ack) unzuverlässiger Kanal Bitfehler, Paketverlust [RN] Sommer 2012 Transportschicht 15
16 Fehlerkontrolle 3 grundlegende Protokolle für zuverlässigen Transport Stop-and-Wait Sender fügt zur Fehlererkennung Prüfsumme oder besser Cyclic Redundancy Check (CRC) zu Empfänger schickt Bestätigung (acknowledgment, ACK) wenn diese nach einem Timeout nicht eintrifft, wird das Paket erneut gesendet dadurch können evtl. Duplikate gesendet werden, um diese zu erkennen, benötigt man noch Sequenznummern (SQN) bei großem Bandbreiten-Verzögerungsprodukt: Sender ist die meiste Zeit blockiert, ineffizient Schiebefensterprotokolle (sliding window protocols) mehrere Pakete auf einmal senden, um Kanal zu füllen Go-Back-N und Selective Repeat unterscheiden sich bei Timeout, Bestätigungen, Sendewiederholung [RN] Sommer 2012 Transportschicht 16
17 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 17
18 Stop-and-Wait wie funktioniert nun Stop-and-Wait genau? zunächst eine informelle Beschreibung: Verhalten des Senders 1. sende Paket mit aktueller SQN und starte Timer 2. wenn ein ACK ohne Bitfehler und mit aktueller SQN vor Ablauf des Timeouts zurückkommt, inkrementiere SQN und gehe zu 1 3. wenn der Timeout abläuft, sende das Paket erneut, starte den Timer erneut und gehe zu 2 Verhalten des Empfängers wenn Paket ohne Bitfehler und mit aktueller SQN ankommt, sende ACK mit aktueller SQN und inkrementiere SQN, sonst sende das letzte ACK erneut [RN] Sommer 2012 Transportschicht 18
19 Stop-and-Wait Beschreibung durch UML-Statecharts ein Statechart befindet sich immer in einem Zustand, der schwarze Punkt kennzeichnet den initialen Zustand ein Zustandsübergang findet statt, wenn das Ereignis ausgelöst wurde und die Bedingung erfüllt ist wenn ein Zustandsübergang stattfindet, wird die Aktion durchgeführt zur Steigerung der Flexibilität gibt es auch Variablen Ereignis[Bedingung]/Aktion /Aktion Zustand 1 Zustand 2 [RN] Sommer 2012 Transportschicht 19
20 Stop-and-Wait Bemerkungen zu den Statecharts Statecharts stellen eine Variante von endlichen Automaten dar Ereignisse, Bedingungen und Aktionen werden oft durch Pseudocode beschrieben, man erhält eine halbformale Beschreibung das Verhalten von Protokollen wird oft durch solche oder ähnliche Automaten dargestellt es gibt auch Werkzeuge, die dies unterstützen: Protokolle können so spezifiziert werden und daraus der Code generiert werden sowie Analysen, Simulationen und Tests durchgeführt werden man kann daraus gut Implementierungen ableiten: eine große Fallunterscheidung für die möglichen Ereignisse in den verschiedenen Zuständen hier werden Statecharts einfach zur genauen Darstellung des Stop-and- Wait-Protokolls und später von weiteren Protokollen verwendet die Darstellung ist durch Kurose/Ross motiviert, unterscheidet sich aber von den Automaten in dem Buch [RN] Sommer 2012 Transportschicht 20
21 Stop-and-Wait Sender: /SQN=1 udt_rcv(ack)/ data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ ACK udt_rcv(ack) [biterror(ack) SQN(ACK) SQN]/ timeout/ udt_send(pkt); start_timer [RN] Sommer 2012 Transportschicht 21
22 Stop-and-Wait Empfänger: /SQN=1 packet udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ udt_rcv(pkt) [biterror(pkt) SQN(pkt) SQN]/ udt_send(ack) [RN] Sommer 2012 Transportschicht 22
23 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN =? SQN =? time [RN] Sommer 2012 Transportschicht 23
24 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 1 time [RN] Sommer 2012 Transportschicht 24
25 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 1 time [RN] Sommer 2012 Transportschicht 25
26 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 1 time [RN] Sommer 2012 Transportschicht 26
27 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 1 time [RN] Sommer 2012 Transportschicht 27
28 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 21 time [RN] Sommer 2012 Transportschicht 28
29 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 2 time [RN] Sommer 2012 Transportschicht 29
30 Stop-and-Wait: normaler Ablauf /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 12 SQN = 2 time [RN] Sommer 2012 Transportschicht 30
31 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 time [RN] Sommer 2012 Transportschicht 31
32 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 time [RN] Sommer 2012 Transportschicht 32
33 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 time [RN] Sommer 2012 Transportschicht 33
34 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 time [RN] Sommer 2012 Transportschicht 34
35 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 time [RN] Sommer 2012 Transportschicht 35
36 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 3 time [RN] Sommer 2012 Transportschicht 36
37 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 3 time [RN] Sommer 2012 Transportschicht 37
38 Stop-and-Wait: Paketverlust /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 3 time [RN] Sommer 2012 Transportschicht 38
39 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 3 time [RN] Sommer 2012 Transportschicht 39
40 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 3 time [RN] Sommer 2012 Transportschicht 40
41 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 3 time [RN] Sommer 2012 Transportschicht 41
42 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 42
43 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 43
44 Stop-and-Wait: Verlust eines ACKs /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 44
45 Stop-and-Wait: Verlust eines ACKs /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 Duplikat! SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 45
46 Stop-and-Wait: Verlust eines ACKs /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 46
47 Stop-and-Wait: Verlust eines ACKs /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 SQN = 3 SQN = 4 time [RN] Sommer 2012 Transportschicht 47
48 Stop-and-Wait: Verlust eines ACKs /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 4 time [RN] Sommer 2012 Transportschicht 48
49 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 4 time [RN] Sommer 2012 Transportschicht 49
50 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 4 time [RN] Sommer 2012 Transportschicht 50
51 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 4 time [RN] Sommer 2012 Transportschicht 51
52 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 time [RN] Sommer 2012 Transportschicht 52
53 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 time [RN] Sommer 2012 Transportschicht 53
54 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer time udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 [RN] Sommer 2012 Transportschicht 54
55 Stop-and-Wait: verzögertes ACK /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer time udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 [RN] Sommer 2012 Transportschicht 55 /SQN=1 Duplikat!
56 Stop-and-Wait: verzögertes ACK /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer time udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 [RN] Sommer 2012 Transportschicht 56 /SQN=1 Duplikat!
57 Stop-and-Wait: verzögertes ACK /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer time udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 [RN] Sommer 2012 Transportschicht 57 /SQN=1 Duplikat!
58 Stop-and-Wait: verzögertes ACK /SQN=1 data udt_rcv(ack)/ rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 Duplikat! SQN = 5 SQN = 5 time [RN] Sommer 2012 Transportschicht 58
59 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 5 SQN = 5 time [RN] Sommer 2012 Transportschicht 59
60 Stop-and-Wait: verzögertes ACK /SQN=1 data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer time udt_rcv(pkt) [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) Duplikat! SQN = 5 SQN = 5 [RN] Sommer 2012 Transportschicht 60
61 Sequenznummerraum Stop-and-Wait die Repräsentation der Sequenznummern ist endlich: ein Feld mit n Bits ermöglicht 2 n Sequenznummern Wiederverwendung durch zyklisches Durchlaufen für Stop-and-Wait ist ein Bit zur Darstellung von 2 Sequenznummern ausreichend: 0 und 1 Stop-and Wait mit 0 und 1 als Sequenznummern heißt auch Alternating-Bit-Protokoll [RN] Sommer 2012 Transportschicht 61
62 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 62
63 Go-Back-N und Selective Repeat Um die Ineffizienz von Stop-and-Wait zu vermeiden, senden Schiebefensterprotokolle mehrere Pakete, bevor die Bestätigung zurückkommt: Datenpakete Datenpakete ACKs Stop-and-Wait Schiebefensterprotokoll [RN] Sommer 2012 Transportschicht 63
64 Überblick über Go-Back-N Go-Back-N der Sender darf mehrere Pakete (bis zu einer Maximalzahl) vor Erhalt eines ACKs senden er startet beim Senden des ersten Pakets einen Timer er puffert die unbestätigten Pakete wenn der Timer abläuft, werden alle unbestätigten Paket erneut gesendet der Empfänger schickt kumulative ACKs: ein ACK mit einer SQN bedeutet, daß alle Pakete bis zu der SQN erfolgreich empfangen wurden der Empfänger akzeptiert nur Pakete in der richtigen Reihenfolge und benötigt keinen Puffer [RN] Sommer 2012 Transportschicht 64
65 Go-Back-N Sendepuffer nextsqn base base+w-1 base: SQN des ältesten unbestätigten Pakets nextsqn: SQN des nächsten zu verschickenden Pakets W: Fenstergröße, Anzahl der Pakete, die Sender vor Erhalt eines ACKs senden darf das Fenster [base, base+w-1] wird beim Ablauf des Protokolls von links nach rechts verschoben, wegen der kumulativen ACKs hat es immer folgende Struktur: [base, nextsqn-1]: versendete unbestätigte Pakete [nextsqn, base+w-1]: bisher ungesendete Pakete, die vor Erhalt eines ACKs noch gesendet werden dürfen [RN] Sommer 2012 Transportschicht 65
66 Go-Back-N Informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: sende Paket mit nextsqn und inkrementiere nextsqn; wenn es das erste Paket im Fenster ist, starte Timer 2. wenn ein ACK ohne Bitfehler und mit SQN im Fenster zurückkommt, schiebe das Fenster bis zu dieser SQN; wenn das Fenster leer ist, stoppe den Timer, sonst starte den Timer neu 3. wenn der Timeout abläuft, sende alle unbestätigten Pakete des Fensters erneut, starte den Timer erneut Verhalten des Empfängers wenn Paket ohne Bitfehler und mit aktueller SQN ankommt, sende ACK mit aktueller SQN und inkrementiere SQN, sonst sende das letzte ACK erneut (wie bei Stop-and-Wait) [RN] Sommer 2012 Transportschicht 66
67 Go-Back-N Beschreibung durch Statecharts neues Element: Verzweigung [Bedingung1]/Aktion1 [Bedingung2]/Aktion2 Zustand, in dem keine Zeit verbracht wird ( Pseudozustand ) abgehende Zustandsübergänge werden mittels Bedingungen gewählt, auslösende Ereignisse sind hier nicht möglich [RN] Sommer 2012 Transportschicht 67
68 Go-Back-N: Sender [nextsqn base+w]/ signal refusal to upper layer [nextsqn<base+w]/ pkt[nextsqn]=pkt(nextsqn,data,crc); udt_send(pkt[nextsqn]); if base=nextsqn start_timer; nextsqn++ /base=1; nextsqn=1 udt_rcv(ack) [biterror(ack) SQN(ACK))<base nextsqn SQN(ACK)]/ wait rdt_send(data) timeout/ udt_send(pkt[base]); udt_send(pkt[base+1]); udt_send(pkt[nextsqn-1]); start_timer udt_rcv(ack) [ biterror(ack) base SQN(ACK)<nextSQN]/ base=sqn(ack)+1; if base=nextsqn stop_timer else start_timer [RN] Sommer 2012 Transportschicht 68
69 Go-Back-N: Empfänger /expectedsqn=1; ACK=ACK(0,CRC) packet udt_rcv(pkt) [ biterror(pkt) SQN(pkt)=expectedSQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(expectedSQN,CRC); udt_send(ack); expectedsqn++ udt_rcv(pkt) [biterror(pkt) SQN(pkt) expectedsqn]/ udt_send(ack) [RN] Sommer 2012 Transportschicht 69
70 Go-Back-N: normaler Ablauf am Anfang Paket 1 gesendet Paket 2 gesendet Paket 3 gesendet, Sender blockiert ACK 1 empfangen ACK 2 empfangen Paket 1 übergeben Paket 2 übergeben Paket 3 übergeben Paket 4 gesendet [RN] Sommer 2012 Transportschicht 70
71 Go-Back-N: Paketverlust Paket 1 übergeben Timer neu starten Ablauf des Timers, alle unbestätigten Pakete erneut senden Paket 2 übergeben Paket 3 übergeben Paket 4 übergeben [RN] Sommer 2012 Transportschicht 71
72 Go-Back-N: Verlust und Verspätung von ACKs Paket 1 übergeben Paket 2 übergeben Paket 3 übergeben kumulatives ACK gleicht Verlust und Verspätung aus [RN] Sommer 2012 Transportschicht 72
73 Selective Repeat Überblick über Selective Repeat der Sender darf wieder mehrere Pakete (bis zu einer Maximalzahl) vor Erhalt eines ACKs senden er startet beim Senden jedes Pakets einen Timer er puffert die unbestätigten Pakete wenn der Timer für ein Paket abläuft, wird dieses Paket erneut gesendet der Empfänger schickt selektive ACKs: ein ACK mit einer SQN bedeutet nur, daß das Paket mit der SQN erfolgreich empfangen wurde der Empfänger benötigt einen Puffer zum Ausgleich von Lücken beim Empfang [RN] Sommer 2012 Transportschicht 73
74 Selective Repeat: Sende- und Empfängerpuffer nextsqn Sendeseite: Empfängerseite: base base+w-1 base base+w-1 base, nextsqn, W: wie bei Go-Back-N das Fenster auf Sendeseite enthält versendete unbestätigte, versendete bestätigte und ungesendete Pakete der Empfänger puffert die empfangenen Pakete das Fenster auf Empfängerseite enthält empfangene Pakete und Lücken und Platz für unempfangene Pakete [RN] Sommer 2012 Transportschicht 74
75 Selective Repeat Informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: sende Paket, starte Timer für dieses Paket und inkrementiere nextsqn 2. wenn ein ACK ohne Bitfehler und mit SQN im Fenster zurückkommt, markiere das Paket mit SQN als bestätigt, schiebe das Fenster bis zur nächsten Lücke 3. wenn der Timeout für das Paket mit SQN abläuft, sende dieses Paket erneut, starte den Timer für dieses Paket erneut Verhalten des Empfängers wenn Paket ohne Bitfehler und mit SQN im Fenster ankommt, sende ACK mit dieser SQN, puffere das Paket und schiebe das Fenster bis zur nächsten Lücke wenn Paket mit SQN aus vorigem Fenster ankommt, sende das ACK hierfür erneut [RN] Sommer 2012 Transportschicht 75
76 Selective Repeat: Sender [nextsqn base+w]/ signal refusal to upper layer [nextsqn<base+w]/ pkt[nextsqn]=pkt(nextsqn,data,crc); udt_send(pkt[nextsqn]); start_timer[nextsqn]; nextsqn++ /base=1; nextsqn=1 rdt_send(data) udt_rcv(ack) [biterror(ack) SQN(ACK)<base nextsqn SQN(ACK)]/ wait timeout[sqn]/ udt_send(pkt[sqn]); start_timer[sqn] udt_rcv(ack) [ biterror(ack) base SQN(ACK)<nextSQN]/ SQN=SQN(ACK); mark pkt[sqn] as received; if SQN=base move base to next unacked packet; stop_timer[sqn] [RN] Sommer 2012 Transportschicht 76
77 Selective Repeat: Empfänger /base=1 packet udt_rcv(pkt) [ biterror(pkt) SQN(pkt) in [base,base+w-1]]/ data=extractdata(pkt); buffer data; if SQN(pkt)=base base=lowest unrcvd sequence number; deliver all data until base-1; ACK=ACK(SQN(pkt),CRC); udt_send(ack) udt_rcv(pkt) [biterror(pkt) SQN(pkt) not in [base-w,base-1]/ udt_rcv(pkt) [ biterror(pkt) SQN(pkt) in [base-w,base-1]]/ ACK=ACK(SQN(pkt),CRC); udt_send(ack) [RN] Sommer 2012 Transportschicht 77
78 Selective Repeat: normaler Ablauf [RN] Sommer 2012 Transportschicht 78
79 Selective Repeat: Paketverlust [RN] Sommer 2012 Transportschicht 79
80 Selective Repeat: Verlust eines ACKs [RN] Sommer 2012 Transportschicht 80
81 Selective Repeat Sequenznummerraum bei Schiebefensterprotokollen endliches Sequenznummerfeld mit m Werten zyklisches Durchlaufen: Wiederverwendung von SQN unterschiedliche Pakete mit gleicher SQN müssen unterschieden werden hinreichende Bedingungen dafür: falls Empfangsfenstergröße = 1: W < m falls Sendefenstergröße = Empfangsfenstergröße = W > 1: W < (m+1)/2 Beispiel für zu kleinen Sequenznummerraum m = 4 Sequenznummern, Fenstergröße W = 3 W > (m+1)/2 Empfänger kann nicht unterscheiden, ob Paket 0 alt oder neu ist, siehe nächste Seite [RN] Sommer 2012 Transportschicht 81
82 Selective Repeat zwei mögliche Abläufe für m=4 und W=3, die für den Empfänger nicht unterscheidbar sind und zu unterschiedlichen Ergebnissen führen: hier wird altes Paket 0 fälschlicherweise für neu gehalten hier wird neues Paket 0 korrekterweise für neu gehalten [RN] Sommer 2012 Transportschicht 82
83 Vergleich von Go-Back-N und Selective Repeat Vorteile Go-Back-N kumulative ACKs gleichen ACK-Verluste und -Verspätungen schnell aus, ohne daß die Pakete erneut gesendet werden müssen der Sender benötigt nur einen Timer der Empfänger benötigt keinen Puffer Sender und Empfänger können einfacher realisiert werden, weil keine Lücken in den Fenstern beachtet werden müssen Vorteil Selective Repeat weniger Wiederholungen von Sendungen, weil nur wirklich fehlerhafte oder verlorengegangene Pakete erneut gesendet werden [RN] Sommer 2012 Transportschicht 83
84 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 84
85 Leistungsanalyse Fragen wann tritt bei Stop-and-Wait eine Senderblockade ein und wie stark wird der mögliche Durchsatz verkleinert? wie groß muß bei Schiebefensterprotokollen das Fenster sein, um den Kanal zu füllen? ist Go-Back-N oder Selective Repeat effizienter? im folgenden analytische Betrachtung aus W. Stallings: Computer Networking with Internet Protocols and Technology, Pearson Education, 2004 und W. Stallings: High-Speed Networks, TCP/IP and ATM Design Principles, Prentice Hall, 1998 Beispiel für typische Leistungsanalyse von Kommunikationssystemen einige vereinfachende Annahmen sind nötig, um rechnen zu können die mathematischen Ausdrücke sind gar nicht so schlimm bei Go-Back-N benötigen wir die meisten Vereinfachungen und schwierigsten Ausdrücke noch genauere Untersuchungen sind mit Simulation möglich [RN] Sommer 2012 Transportschicht 85
86 Produkt aus Bitrate und Verzögerung Eine Erinnerung (siehe Kapitel 1) Kanalpuffergröße in Paketen mit Paketgröße L: R D d / v a = = = L L /R Ausbreitungsverzögerung Paketsendezeit = Anzahl gesendeter Pakete während sich das erste Bit vom Sender zum Empfänger ausbreitet = Kanalpuffergröße in Paketen [RN] Sommer 2012 Transportschicht 86
87 Leistungsanalyse: Stop-and-Wait Stop-and-Wait ohne Fehler Vernachlässigung der ACK-Sendezeit und Bearbeitungszeiten (sinnvolle vereinfachende Annahme für diese Berechnungen) L/R 2D L/R 2D pro Zeit gesendete Bits: Durchsatz = L L /R + 2D normiert durch die Bitrate (gut für Vergleich bei verschiedenen Bitraten, vergleiche auch mit vorletzter Folie): normierter Durchsatz = S L = L /R + 2D 1 R 1 = 1 + 2RD /L 1 = 1 + 2a S = a schlechter Durchsatz für große a (Kanal kann nicht gefüllt werden) [RN] Sommer 2012 Transportschicht 87
88 Leistungsanalyse: Stop-and-Wait Stop-and-Wait mit Fehlern Sendewiederholung nach einem Fehler (Timeout oder fehlerhaftes ACK) Annahme: Fehler treten unabhängig voneinander mit Wahrscheinlichkeit p auf (schon wieder eine Vereinfachung!) Timeout = 2D N ist die mittlere Anzahl, mit der jedes Paket gesendet werden muß, dann: Durchsatz = L N (L /R + 2D) L /R S = N (L /R + 2D) = 1 N (1+ 2RD /L) = 1 N (1+ 2a) [RN] Sommer 2012 Transportschicht 88
89 Leistungsanalyse: Stop-and-Wait Berechnung von N: die Wahrscheinlichkeit, daß ein Paket i-mal gesendet werden muß, ist gleich der Wahrscheinlichkeit von i-1 fehlerhaften Sendungen gefolgt von einem fehlerfreien Senden Pr[i Sendeversuche] = p i-1 (1-p) dies ist die geometrische Verteilung, Erwartungswert: N = E[Sendeversuche] = = using i= 1 i p i= 1 ix i 1 i 1 (1 p) = (1 1 = (1 X ) i Pr[ i Sendeversuche] p) = (1 < 1) Einsetzen liefert den normalisierten Durchsatz: 2 i= 1 i= 1 i p for ( 1 < X i 1 1 p) (1 p) 2 1 = 1 p 1 p S = schlechter Durchsatz für große a und p 1+ 2a [RN] Sommer 2012 Transportschicht 89
90 Leistungsanalyse: Stop-and-Wait Normierter Durchsatz von Stop-and-Wait als Funktion von a: für große a fällt der Durchsatz ab, für größere p ist der Durchsatz ebenfalls kleiner [RN] Sommer 2012 Transportschicht 90
91 Leistungsanalyse: Schiebefensterprotokolle Schiebefensterprotokolle ohne Fehler für Fenstergröße mit W Paketen der Länge L Fall 1: das Fenster ist groß genug, um zu senden, bis ACK zurückkommt: L / R + 2D W = 1+ 2a L / R W L 1 S = = 1 W L /R R Fall 2: das Fenster ist nicht groß genug W < 1+ S 2a 1 S = W = 1+ 2a W L 1 W = L /R + 2D R 1+ 2a W W 1+ < 1+ 2a 2a [RN] Sommer 2012 Transportschicht 91
92 Leistungsanalyse: Schiebefensterprotokolle Zeitablauf beim Schiebefensterprotokoll t=0 A B 1 A pkt 1 B 2 a a+1 2a+1 A A pkt 2 pkt 1... pkt a pkt (a-1) pkt 2 pkt 1 A... A pkt (a+1) pkt a pkt 3 pkt 2... pkt (2a+1) pkt (2a) pkt (a+3) pkt (a+2) A W > 2a + 1 A B B B B [RN] Sommer 2012 Transportschicht 92
93 Leistungsanalyse: Schiebefensterprotokolle t=0 1 a a+1 W 2a+1 A A A pkt 1... pkt a pkt (a-1) pkt 2 pkt 1 pkt (a+1) pkt a pkt 3 pkt 2 A... A A A... pkt W pkt (W-1) pkt (W-a+2) pkt (W-a+1) A pkt W... pkt (a+2) A B B B B B B W < 2a + 1 [RN] Sommer 2012 Transportschicht 93
94 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von Schiebefensterprotokollen als Funktion von a: eine Fenstergröße W reicht bis zu einer maximalen Größe a = (W-1)/2, um den Kanal zu füllen, danach sinkt der Durchsatz [RN] Sommer 2012 Transportschicht 94
95 Leistungsanalyse: Schiebefensterprotokolle Selective Repeat mit Fehlern Annahme: unabhängige Fehler mit Wahrscheinlichkeit p N = E[Sendeversuche] = 1/(1-p) der Durchsatz im fehlerfreien Fall muß durch N geteilt werden: S = 1 1 = = 1 p N 1 /(1 p) W W = N (1 + 2a) 1 /(1 p) (1 + 2a) = W(1 p) 1 + 2a W W 1 + < 1 + 2a 2a S = 1 p W(1 p) 1 + 2a W W 1 + < 1 + 2a 2a [RN] Sommer 2012 Transportschicht 95
96 [RN] Sommer 2012 Transportschicht 96 Leistungsanalyse: Schiebefensterprotokolle Go-back-N mit Fehlern jeder Fehler erfordert eine Sendewiederholung von K Paketen Annahme: im Fehlerfall ist das Fenster gefüllt und alle Pakete des Fensters müssen erneut gesendet werden, dann: wenn das fehlerhafte Paket i-mal gesendet wird, müssen insgesamt 1+(i-1)K = (1-K)+Ki Pakete gesendet werden + < + + = 2a 1 W W 2a 1 W 2a 1 K = = = = < < = + = + = + = + = + = ) 1 for ( 1 1 using ) (1 1 ) (1 ) (1 1 ) )(1 (1 ) (1 ) )(1 (1 ) (1 ) ) ((1 N i i i i i i i i X X X p Kp p p K K p p K p p K p i p K p p K p p Ki K
97 Leistungsanalyse: Schiebefensterprotokolle mit K erhalten wir: N = 1 p + Kp 1 p 1 p + Kp 1 p = = 1 p + (1+ 2a)p 1 p 1 p + Wp 1 p = 1+ 2ap 1 p W W 1+ 2a < 1+ 2a Division des Durchsatzes ohne Fehler durch N ergibt: S = 1 1 p = N 1 + 2ap W = N (1 + 2a) (1 p W(1 p) + Wp) (1 + 2a) W W 1 + < 1 + 2a 2a S = 1 p 1 + 2ap W(1 p) (1 p + Wp) (1 + 2a) W W 1 + < 1 + 2a 2a [RN] Sommer 2012 Transportschicht 97
98 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-3 : erst für größere Fenster ergibt sich ein spürbarer Vorteil von Selective Repeat [RN] Sommer 2012 Transportschicht 98
99 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-2 : durch die höheren Verluste wird der der Vorteil von Selective Repeat jetzt auch bei kleineren Fenstergrößen sichtbar [RN] Sommer 2012 Transportschicht 99
100 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-1 : der Vorteil von Selective Repeat ist bei so vielen Verlusten deutlich [RN] Sommer 2012 Transportschicht 100
101 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-3 : für große a und große Fenster gibt es einen erheblichen Unterschied zwischen Go-Back-N und Selective Repeat [RN] Sommer 2012 Transportschicht 101
102 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-2 : der Unterschied wird deutlicher [RN] Sommer 2012 Transportschicht 102
103 Leistungsanalyse: Schiebefensterprotokolle Normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-1 : und noch deutlicher [RN] Sommer 2012 Transportschicht 103
104 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 104
105 TCP Transmission Control Protocol Das verbreitete zuverlässige Transportprotokoll im Internet RFCs 793, 1122, 1323, 2018, 2581 Punkt-zu-Punkt: ein Sender, ein Empfänger Reihenfolgebewahrender Bytestrom Fensterbasierte Fehlerkontrolle Vollduplex: 2 entgegengesetzte Datenströme Verbindungsorientiert: Auf- und Abbau einer Verbindung Flusskontrolle: Mechanismus, um Überschreitung der Kapazität des Empfängers zu verhindern Überlastkontrolle: Mechanismus, um Überlastung des Netzes zu verhindern [RN] Sommer 2012 Transportschicht 105
106 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 106
107 TCP: Segmentformat sequence number: Nummer des ersten Bytes des Segments im Bytestrom ack. number: Nummer des nächsten erwarteten Bytes im Bytestrom Flags mit Steuerinformation: URG (urgent pointer gültig) ACK (ACK gültig) PSH (Push Segment) RST (Verbindung zurücksetzen) SYN (synchronisiere Verbindung) FIN (beende Verbindung) AdvertizedWindow: Fenstergröße für Flußsteuerung checksum: Prüfsumme (wie UDP) source port # dest port # head len 32 bits sequence number acknowledgment number not used U A P R S F checksum AdvertizedWindow Urg data pnter Options (variable length) application data (variable length) [RN] Sommer 2012 Transportschicht 107
108 TCP Multiplexen und Demultiplexen TCP-Verbindung eindeutig gekennzeichnet durch 4-Tupel Quell-IP-Adresse Ziel-IP-Adresse Quellportnummer Zielportnummer über einen Port können also viele TCP-Verbindungen laufen (z.b. Port 80 für Web-Server) Pseudo-Header wie in UDP, einschließlich Prüfsummenberechnung [RN] Sommer 2012 Transportschicht 108
109 TCP Multiplexen und Demultiplexen, Beispiel: P1 P4 P5 P6 P2 P1 P3 SP: 5775 DP: 80 S-IP: B D-IP:C SP: 9157 DP: 80 SP: 9157 DP: 80 A S-IP: A C S-IP: B B D-IP:C D-IP:C [RN] Sommer 2012 Transportschicht 109
110 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 110
111 Fehlerkontrolle in TCP TCP: Fehlerkontrolle Mischform von Go-Back-N und Selective Repeat und weiterer Elemente Puffer auf Sender- und Empfängerseite ein Timer kumulative ACKs Sequenz- und ACK-Nummern beziehen sich nicht auf Pakete Sequenznummer = Position des ersten Bytes des Segments im Bytestrom ACK-Nummer = Position des nächsten erwarteten Bytes im Bytestrom diverse Implementierungsoptionen, im Folgenden wird eine vereinfachte Standardform beschrieben, wer mehr Einzelheiten verstehen möchte, sollte die RFCs lesen außerdem wird im Folgenden wegen der Übersichtlichkeit die Behandlung von Bitfehlern nicht beschrieben, sie können genauso wie bei Go-Back-N oder Selective Repeat behandelt werden [RN] Sommer 2012 Transportschicht 111
112 TCP: Fehlerkontrolle Überblick über die Fehlerkontrolle bei TCP der Sender darf mehrere Segmente vor Erhalt eines ACKs senden (bis zu einer von verschiedenen Mechanismen abhängigen maximalen Gesamtzahl von Bytes) er startet beim Senden des ersten Segments eines Fensters einen Timer er puffert die unbestätigten Segmente wenn der Timer abläuft, wird das erste unbestätigte Segment des Fensters erneut gesendet der Empfänger schickt kumulative ACKs mit der Position des ersten noch nicht empfangenen Bytes das Fenster wird auf Sender- und Empfängerseite immer bis zur nächsten Lücke geschoben [RN] Sommer 2012 Transportschicht 112
113 TCP: Fehlerkontrolle Sende- und Empfängerfenster nextsqn Sendeseite: Empfängerseite: base base+w base base+w base: erstes Byte des Fensters base+w: erstes Byte außerhalb des Fensters nextsqn: erstes Byte des nächsten noch nicht gesendeten Segments das Fenster auf Sendeseite enthält versendete unbestätigte und ungesendete Pakete das Fenster auf Empfängerseite enthält empfangene Pakete und Lücken und Platz für unempfangene Pakete [RN] Sommer 2012 Transportschicht 113
114 TCP: Fehlerkontrolle Informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: erstelle Segment mit nextsqn und sende es mit IP, erhöhe nextsqn um Länge der Daten; wenn es das erste Paket im Fenster ist, starte Timer 2. wenn ein ACK mit ACK-Nr. im Fenster zurückkommt, schiebe das Fenster bis zu dieser ACK-Nr.; wenn das Fenster leer ist, stoppe den Timer, sonst starte den Timer neu 3. wenn der Timeout abläuft, sende das erste unbestätigte Paket des Fensters erneut, starte den Timer erneut [RN] Sommer 2012 Transportschicht 114
115 TCP: Fehlerkontrolle Verhalten des Empfängers wenn ein Segment ankommt und SQN = Fensteranfang ist und alle vorherigen Segmente bereits bestätigt sind: schiebe Fensteranfang bis zum nächsten erwarteten Byte und warte ein Timeout (500 ms), wenn bis dahin kein neues Segment ankommt, schicke ein ACK mit dem Fensteranfang (delayed ACK) SQN = Fensteranfang ist und ein vorheriges Segment noch nicht bestätigt wurde, schiebe Fensteranfang bis zum nächsten erwarteten Byte und schicke sofort ein kumulatives ACK mit dem Fensteranfang SQN > Fensteranfang ist, puffere die Daten und schicke sofort ein kumulatives ACK mit dem Fensteranfang es eine Lücke teilweise oder ganz füllt, puffere die Daten, schiebe Fensteranfang bis zum nächsten erwarteten Byte und schicke sofort ein kumulatives ACK mit dem Fensteranfang [RN] Sommer 2012 Transportschicht 115
116 TCP: Fehlerkontrolle Beschreibung durch Statecharts neues Element: zusammengefaßte Zustände zusammengefaßter Zustand Zustand 1 Zustand 2 grafische Vereinfachung: Zustandsübergänge, die an einem zusammengefaßten Zustand beginnen (enden), gelten für jeden inneren Zustand Zustandsübergänge können auch direkt an inneren Zuständen beginnen (enden) [RN] Sommer 2012 Transportschicht 116
117 TCP: Sender [nextsqn base+w]/ signal refusal to application /base=1; nextsqn=initialsqn [nextsqn<base+w]/ segment[nextsqn]= TCPsegment(nextSQN,data,checksum); IP_send(segment[nextSQN]); if nextsqn=base start_timer; nextsqn+=length(data) TCP_send(data) otherwise/ wait timeout/ IP_send(segment[base]); start_timer IP_rcv(ACK) [base<acknum(ack) nextsqn]/ base=acknum(ack); if nextsqn=base stop_timer else start_timer [RN] Sommer 2012 Transportschicht 117
118 TCP: Empfänger [no gap remains]/ timeout/ IP_send(ACK[base]); (deliver data until base-1) not all data acked all data acked otherwise/ [SQN(segment)=base]/ base+=length(data); start_timer IP_rcv(segment)/ data=extractdata(segment); buffer data [SQN(segment)>base]/ IP_send(ACK[base]) delayed ACK gap detected IP_rcv(segment)/ data=extractdata(segment); buffer data; base=lowest unrcvd byte; IP_send(ACK[base]); (deliver data until base-1) [gap in buffered data]/ /base=1 otherwise/ [RN] Sommer 2012 Transportschicht 118
119 TCP: Fehlerkontrolle, normaler Ablauf [RN] Sommer 2012 Transportschicht 119
120 TCP: Fehlerkontrolle, Paketverlust [RN] Sommer 2012 Transportschicht 120
121 Fast Retransmit TCP: Fehlerkontrolle es dauert relativ lange, bis ein Paketverlust bemerkt wird und noch länger bei mehreren Paketverlusten ACKs mit der gleichen ACK-Nr. heißen doppelte ACKs sie sind ein schnellerer Hinweis auf ein fehlendes Segment bei Fast Retransmit wird bei 3 doppelten ACKs (also 4 ACKs mit der gleichen ACK-Nr.) eine Sendewiederholung des Segments mit der SQN ausgelöst Anpassung des Statecharts (ein ACK-Zähler dupacks wird benötigt) [RN] Sommer 2012 Transportschicht 121
122 TCP Sender mit Fast Retransmit [nextsqn base+w]/ signal refusal to application /base=1; nextsqn=initialsqn; dupacks=0 otherwise/ wait [nextsqn<base+w]/ segment[nextsqn]= TCPsegment(nextSQN,data,checksum); IP_send(segment[nextSQN]); if nextsqn=base start_timer; nextsqn+=length(data); dupacks=0 TCP_send(data) timeout/ IP_send(segment[base]); start_timer; dupacks=0 [acknum(ack))=base]/ dupacks++; if dupacks=3 IP_send(segment[base]); dupacks=0 IP_rcv(ACK) [acknum(ack))>base]/ base=acknum(ack); if nextsqn=base stop_timer else start_timer dupacks=0 [RN] Sommer 2012 Transportschicht 122
123 Bemerkungen TCP Fehlerkontrolle TCP ist vollduplex: es werden zwei logische Verbindungen realisiert, eine in jede Richtung ACKs reisen Huckepack (Piggybacking): Segmente mit Daten in die eine Richtung werden als ACKs in die andere Richtung benutzt das delayed ACK soll die Anzahl von ACKs reduzieren Offene Probleme Mehrfache Paketverluste in einem Fenster haben katastrophalen Effekt auf den Durchsatz, da der Sender (durch kumulatives ACK) für jedes fehlende Paket eine Round-Trip-Time warten muss Lösung: es gibt eine TCP-Erweiterung Selective Acknowledgements (SACK), bei der zusätzlich im Optionsfeld selektive ACKs gesendet werden [RN] Sommer 2012 Transportschicht 123
124 Selective Acknowledgements (SACK) Die Grundidee: Selective Acknowledgments (SACK) informieren den Sender über einzelne Pakete, welche im Fenster liegen und nicht durch kumulative ACKs bestätigt werden können Der Sender muss diese (nach Timeout) nicht erneut übertragen Die Informationen werden über TCP Optionsfelder übertragen Allgemeine Regeln Normale ACKs werden unverändert verschickt (Kompatibilität) SACKs werden für das erste Paket außer der Reihe verschickt Empfänger Verschickt so viele SACKs wie möglich (Platz im Header) Sender Entsprechene Neuübertragungen werden initiiert [RN] Sommer 2012 Transportschicht 124
125 SACK Permitted and SACK TCP Connection Establishment Phase SENDER SYN = 1 ACK = 1 SYN = 1 ACK = 1 RECEIVER Data Transfer Phase ACK containing Cumulative Ack (CumAck) and Selective Ack (SACK) [RN] Sommer 2012 Transportschicht 125
126 Sender SACK Beispiel SACKs informieren über (isoliert) empfangene Datenblöcke SEQ 100, 200 bytes ACK 300 SEQ 300, 200 bytes Receiver Receiver s Buffer SEQ 500, 200 bytes SEQ 700, 200 bytes ACK 300,SACK ACK 300, SACK [RN] Sommer 2012 Transportschicht 126
127 SACK Beispiel Sender SEQ 100, 200 bytes ACK 300 Empfänger Empfangspuffer SEQ 300, 200 bytes SEQ 500, 200 bytes ACK 300,SACK SEQ 700, 200 bytes SEQ 900, 200 bytes ACK 300, SACK , SEQ 1100, 200 bytes [RN] Sommer 2012 Transportschicht 127
128 SACK Beispiel Sender SEQ 1100, 100 bytes Empfänger SEQ 300, 200 bytes ACK 700, SACK SEQ 700, 200 bytes ACK [RN] Sommer 2012 Transportschicht 128
129 TCP Fehlerkontrolle Größe des Sequenznummerraums das Sequenznummerfeld ist 32 Bits groß, es gibt also 2 32 Sequenznummern die Bedingung für Schiebefensterprotokolle ist erfüllt: 2 32 >> Sequenznummer vs. max. Fenstergröße Zeiten für den Überlauf der Sequenznummern bei 10 Mbps: 57 Minuten bei 1 Gbps: 34 Sekunden für hohe Bitraten also etwas kurz TCP-Erweiterung verwendet Zeitstempel im Options-Feld für weitere Unterscheidung, um Verwechslungen von Segmenten zu vermeiden [RN] Sommer 2012 Transportschicht 129
130 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 130
131 TCP: Verbindungsauf- und -abbau Verbindungsaufbau veranlasst 3-Wege-Handshake SYN-Segment: Client sendet Segment mit SYN-Flag=1, zufälliger initialer Client-SQN (client_isn), ohne Daten SYNACK-Segment: Server sendet Segment mit SYN-Flag=ACK- Flag=1, zufälliger initialer Server-SQN (server_isn), ACK=client_isn+1, ohne Daten; er legt Puffer und Variablen an ACK-Segment: Client sendet Segment mit ACK-Flag=1; SQN=client_isn+1, ACK=server_isn+1 und ggfs. Daten; er legt Puffer und Variablen an [RN] Sommer 2012 Transportschicht 131
132 TCP: Verbindungsauf- und -abbau 3-Wege-Handshake: Anlegen von Puffern und Variablen Anlegen von Puffern und Variablen [RN] Sommer 2012 Transportschicht 132
133 TCP: Verbindungsauf- und -abbau Sequenznummern bei SYN- und FIN-Segmenten Segmente mit SYN-Flag=1 oder FIN-Flag=1 dürfen keine Daten enthalten, die nächste SQN muss aber um Eins inkrementiert werden, damit diese Segmente explizit bestätigt werden können Verbindungsabbau jede Seite kann Verbindungsabbau durch Segment mit FIN- Flag=1 veranlassen die andere Seite bestätigt mit ACK-Flag=1 beide Seiten müssen ihre Hälfte der Verbindung schließen hat eine Seite geschlossen, sendet sie keine Daten mehr, nimmt aber noch welche an Timed Wait: die Seite, die den Verbindungsabbau veranlasst, wartet zum Schluss noch 2 Segmentlebensdauern, um noch mögliche alte Segmente zu empfangen (und eine neue TCP- Verbindung davor zu schützen) [RN] Sommer 2012 Transportschicht 133
134 TCP: Verbindungsauf- und abbau, Beispiel linke Seite hat nichts mehr zu senden und bricht ab: Timed Wait: 2 Segmentlebensdauern auf mögliche alte Segment warten Verbindung geschlossen letztes ACK: Verbindung geschlossen [RN] Sommer 2012 Transportschicht 134
135 TCP: Verbindungsauf- und -abbau Zustandsmaschine in RFC 793 ist Zustandsmaschine für Verbindungsauf- und -abbau verbesserte Version, enthält alle Möglichkeiten: anything / reset Syn Recvd begin Closed passive open close active open / syn syn / syn+ack Listen send / syn close / fin reset close / fin ack syn / syn+ack Established syn+ack / ack fin / ack close / fin Syn Sent Close Wait close/ timeout/ reset Fin Wait-1 ack / Fin Wait-2 fin / ack Closing fin-ack / ack ack/ fin / ack Time Wait Last Ack ack/ timeout after 2 segment lifetimes [RN] Sommer 2012 Transportschicht 135
136 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 136
137 TCP: Schätzung der RTT Timeout für Sendewiederholungen der Sender muss einen Timeout wählen ein ACK kann frühestens nach RTT zurückkommen ist der Timeout zu klein, gibt es unnötige Sendewiederholungen ist der Timeout zu groß, kann erst spät auf Fehler reagiert werden der passende Timeout hängt von der Konfiguration ab und ändert sich dynamisch Vorgehen von TCP Zeitstempel für Segment und ACK, Differenz = Messung der aktuellen RTT Durchschnitt und Abweichung aus mehreren Messungen bestimmen, daraus Timeout ableiten Messungen bei Sendewiederholungen nicht verwenden [RN] Sommer 2012 Transportschicht 137
138 TCP: Schätzung der RTT Bestimmung der RTT jede Messung ergibt ein SampleRTT gleitender Durchschnitt (Exponentially Weighted Moving Average): EstimatedRTT = (1-α) x EstimatedRTT + α x SampleRTT bei großem α reagiert Durchschnitt stark auf aktuelle Schwankungen, bei kleinem α gibt es größere Stabilität, aber langsamere Reaktion auf Änderungen, typischer Wert: α = 0,125 mittlere Abweichung wieder als gleitender Durchschnitt, ähnlich zu Standardabweichung DevRTT = (1-β) x DevRTT + β x SampleRTT-EstimatedRTT typisch: β = 0.25 Timeout geschätzte RTT + aus Abweichung abgeleitete Sicherheit: TimeoutInterval = EstimatedRTT + 4 x DevRTT Timeout Backoff: wenn der Timeout ausgelöst wird, wird er jeweils verdoppelt und wird benutzt, bis neues SampleRTT da ist [RN] Sommer 2012 Transportschicht 138
139 Beispiel für RTT-Schätzung: TCP: Schätzung der RTT [RN] Sommer 2012 Transportschicht 139
140 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 140
141 TCP: Fluss- und Überlastkontrolle Flußkontrolle (Flow Control) Mechanismus, mit dem der Empfänger den Sender steuern kann, damit er ihn nicht überlastet aber auch so schnell sendet wie möglich üblicherweise durch Benachrichtigung über Fenstergröße Überlastkontrolle (Congestion Control) Mechanismus, mit dem der Sender davon abgehalten wird, das Netz (Bandbreiten und Puffer) zu überlasten kann durch explizite Signale des Netzes an den Sender erfolgen (z.b. bei ATM) in TCP gibt es klassischerweise keinen solchen expliziten Mechanismus, der Sender leitet sich aus den zurückkommenden ACKs Informationen über den Netzzustand ab und reagiert entsprechend inzwischen gibt es auch Vorschläge für die Erweiterung von TCP und IP zur expliziten Überlastbenachrichtigung: Explicit Congestion Notification (ECN) [RN] Sommer 2012 Transportschicht 141
142 TCP: Flusskontrolle Prinzip der Flußkontrolle die Empfängerseite besitzt einen Puffer, IP fügt neue empfangene Daten ein, die Anwendung liest Daten aus RecWindow Daten von IP frei TCP- Daten im Buffer Anwendungsprozess RecBuffer der jeweils freie Pufferplatz wird der Senderseite mitgeteilt die Senderseite besitzt einen Puffer, in den die Anwendung neue Daten schreibt und mit IP soviel Daten entfernt werden, wie es der Puffer der Empfangsseite zuläßt die Anwendung auf Sendeseite blockiert, wenn der Puffer voll ist dadurch reguliert die Empfängeranwendung die Senderanwendung [RN] Sommer 2012 Transportschicht 142
143 Puffer auf Empfängerseite TCP: Flusskontrolle MaxRcvBuffer AdvertizedWindow LastByteRead NextByteExpected = base LastByteRcvd LastByteRead: das letzte an die Anwendung ausgelieferte Byte NextByteExpected: das nächste erwartete Byte LastByteRcvd: das letzte empfangene Byte MaxRcvBuffer: insgesamt zur Verfügung stehender Pufferplatz AdvertizedWindow = MaxRcvBuffer ((NextByteExpected -1) LastByteRead): freier Pufferplatz, wird dem Sender mitgeteilt [RN] Sommer 2012 Transportschicht 143
144 TCP: Flusskontrolle Puffer auf Senderseite MaxSendBuffer LastByteAcked = base LastByteSent = nextsqn-1 LastByteWritten LastByteAcked: das letzte bestätigte Byte LastByteSent: das letzte gesendete Byte LastByteWritten: das letzte von der Anwendung geschriebene Byte MaxSendBuffer: insgesamt zur Verfügung stehender Pufferplatz EffectiveWindow = AdvertizedWindow - (LastByteSent-LastByteAcked) Sender sendet nur, falls EffectiveWindow > 0 Anwendung schreibt nur, falls LastByteWritten - LastByteAcked MaxSendBuffer [RN] Sommer 2012 Transportschicht 144
145 TCP: Flusskontrolle Bemerkungen zum Ablauf der Flußkontrolle initial wird AdvertizedWindow möglichst groß eingestellt nach AdvertizedWindow = 0 werden periodisch Sondensegmente mit 1 Byte gesendet, sonst kommen evtl. nie ACKs mit wieder größerem AdvertizedWindow zurück Vermeidung des Silly Window Syndroms Segmente mit wenig Daten sind ineffizient wenn die Puffer voll sind und kleine Segmente gesendet werden, zirkulieren sie zwischen Sender und Empfänger und bleiben im System MSS (Maximum Segment Size), Default sind 536 Bytes wenn der Empfänger ein AdvertizedWindow = 0 bekannt gibt, wartet er danach bis er ein AdvertizedWindow MSS bekannt geben kann [RN] Sommer 2012 Transportschicht 145
146 TCP: Flusskontrolle, Beispiel MaxSendBuffer=MaxRcvBuffer=1400 Bytes MSS = 500 Bytes (EffectiveWindow = 1400) (AdvertizedWindow = 1400) (EffectiveWindow = 900) (EffectiveWindow = 400 < MSS) Sender blockiert Anwendung liest 500 Bytes (EffectiveWindow = 900) (EffectiveWindow = 400) [RN] Sommer 2012 Transportschicht 146
147 Ist das Fenster groß genug? TCP: Flusskontrolle kann es Verwechselungen von Segmenten geben? das AdvertizedWindow-Feld ist 16 Bits groß, also kann das Fenster 2 16 Bytes groß sein die Bedingung für Schiebefensterprotokolle ist erfüllt: 2 32 >> kann der Sender den Kanal gefüllt halten? auf der nächsten Folie ist zu sehen, daß für manche Konstellationen das Bitraten-Verzögerungs-Produkt so groß ist, daß das maximale Fenster dafür nicht ausreicht als Abhilfe kann im Options-Feld des ersten Segments ein Window- Scale-Faktor F 14 gesetzt werden, die Fenstergröße ergibt sich dann immer aus AdvertizedWindow 2 F es gilt immer noch 2 32 > [RN] Sommer 2012 Transportschicht 147
148 TCP: Flusskontrolle Default Window Size Window Scale = 4 bei Werten unter 1 ist das Fenster nicht groß genug, um den Kanal zu füllen [RN] Sommer 2012 Transportschicht 148
149 TCP: Überlastkontrolle Überblick über die Überlastkontrolle der TCP-Sender versucht aus den zurückkommenden ACKs Informationen über die mögliche Senderate zu erhalten hierzu gibt es das CongestionWindow, das zusammen mit der Flußkontrolle zur Ermittlung des tatsächlichen Sendefensters verwendet wird: MaxWindow = Min(CongestionWindow, AdvertizedWindow) EffectiveWindow = MaxWindow - (LastByteSent-LastByteAcked) die Bitrate ergibt sich ungefähr aus CongestionWindow/RTT durch Vergrößerung des CongestionWindows vergrößert der Sender die Bitrate und versucht sich an die mögliche Bitrate anzunähern bei einem Verlust (durch 3 doppelte ACKs oder einen Timeout zu erkennen) wird das CongestionWindows und damit die Bitrate wieder verkleinert [RN] Sommer 2012 Transportschicht 149
150 3 Mechanismen TCP: Überlastkontrolle Slow Start: am Anfang erhöht der Sender das CongestionWindow beginnend mit einer MSS exponentiell bis er durch 3 doppelte ACKs erfährt, dass ein Segment verlorengegangen ist danach erfolgt AIMD (Additive Increase, Multiplicative Decrease): das CongestionWindow wird halbiert und dann linear bis zum nächsten Erhalt von 3 doppelten ACKs erhöht danach wieder AIMD... konservative Reaktion nach Timeout: dann wird Slow Start bis zur Hälfte des aktuellen CongestionWindows und danach AIMD durchgeführt [RN] Sommer 2012 Transportschicht 150
151 TCP: Überlastkontrolle Mehr Details: Slow Start setze CongestionWindow = MSS nach Erhalt eines ACKs: CongestionWindow += MSS (hierdurch wird ein exponentielles Ansteigen realisiert) bis Threshold erreicht ist, dann Additive Increase (am Anfang ist Threshold unendlich) nach 3 doppelten ACKs: Multiplicative Decrease: Threshold = CongestionWindow/2; CongestionWindow /= 2 Additive Increase: bei Erhalt eines ACKs CongestionWindow += MSS x (MSS/CongestionWindow) nach Timeout hierdurch wird ein Wachstum um ca. ein MSS pro RTT realisiert z.b.: MSS = Bytes, CongestionWindow = Bytes, jedes ACK vergrößert um ca. 1/10 MSS, 10 ACKs um ca. 1 MSS Threshold = CongestionWindow/2; CongestionWindow = MSS [RN] Sommer 2012 Transportschicht 151
152 TCP: Überlastkontrolle Beispiel für Slow Start Sender Empfänger CongestionWindow = 1 MSS CongestionWindow = 2 MSS RTT (delayed ACK wird hier vernachlässigt) CongestionWindow = 4 MSS (ab hier kann ununterbrochen gesendet werden) CongestionWindow = 8 MSS [RN] Sommer 2012 Transportschicht 152
153 TCP: Überlastkontrolle Beispiel für zeitlichen Ablauf: CongestionWindow in MSS dupacks Threshold = 8 CongestionWindow = 8 3 dupacks Threshold = 9 CongestionWindow = 9 Timeout Threshold = 10 CongestionWindow = 1 Zeit in RTTs [RN] Sommer 2012 Transportschicht 153
154 Ungefährer Durchsatz TCP: Überlastkontrolle Annahme: nur AIMD, Vernachlässigung von Slow-Start am Anfang und nach Timeouts CongestionWindow pendelt ungefähr zwischen dem maximalen Wert W und der Hälfte W/2 die Bitrate also zwischen W/RTT und ½ W/RTT im Mittel ergibt sich ¾ W/RTT [RN] Sommer 2012 Transportschicht 154
155 Szenario TCP: Fairness der Überlastkontrolle 2 TCP-Verbindungen teilen sich die Bitrate R eines Kanals Fairness: jede Verbindung sollte R/2 erhalten Vernachlässigung des Slow Starts R gleiche Aufteilung der Bitrate 3 dupacks: Halbierung lineares Wachstum 3 dupacks: Halbierung lineares Wachstum Bitrate von Verbindung 1 R [RN] Sommer 2012 Transportschicht 155
156 Einführung UDP Fehlerkontrolle TCP Transportschicht Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse [RN] Sommer 2012 Transportschicht 156
157 TCP: Leistungsanalyse Zeit zum Kopieren eines Objektes mit TCP hängt ab von Objektgröße, Bitrate, Ausbreitungsverzögerung und Verzögerungen durch Protokollmechanismen insbesondere Slow-Start kann sich spürbar auswirken Annahmen keine Bitfehler und Verluste, keine schwankenden Bitraten und Verzögerungen, ACKs benötigen keine Sendezeit, keine Bearbeitungszeiten, Fenster der Flußkontrolle immer groß genug Notation S: MSS in Bits O: Objektgröße in Bits R: Bitrate RTT: round trip time W: Fenstergröße in MSSs Analyse zunächst für feste Fenstergröße, dann für wachsendes Fenster wie bei Slow Start [RN] Sommer 2012 Transportschicht 157
158 Festes Fenster Festes Fenster, 1. Fall Fenster füllt den Kanal: WS/R > RTT + S/R Verzögerung = 2RTT + O/R initiate TCP connection request object RTT S/R RTT WS/R O/R 1 st ack returns time at client time at server [RN] Sommer 2012 Transportschicht 158
159 Festes Fenster Festes Fenster, 2. Fall Fenster ist nicht groß genug um den Kanal zu füllen: WS/R < RTT + S/R Verzögerung = 2RTT + O/R + (K-1)[S/R + RTT - WS/R] K gibt die Anzahl von Fenstern an, die das Objekt benötigt: O K = WS initiate TCP connection request object time at client RTT S/R RTT 1 st ack returns time at server WS/R [RN] Sommer 2012 Transportschicht 159
160 Fenster wächst wie bei Slow Start Wachsendes Fenster wie bei Slow Start: 2RTT für den Verbindungsaufbau O/R für das Senden O/S Segmente K Fenster P Slow-Start- Wartezeiten hier: O/S = 15 K = 4 P = 2 initiate TCP connection request object object delivered RTT time at client time at server first window = S/R second window = 2S/R third window = 4S/R fourth window = 8S/R complete transmission [RN] Sommer 2012 Transportschicht 160
161 Fenster wächst wie bei Slow Start Verzögerungszeit Verzögerung = 2 RTT + O/R + Slow-Start-Wartezeiten Slow-Start-Wartezeit im k-ten Fenster 2 k-1 S/R = Sendezeit im k-ten Fenster S/R + RTT = Zeit vom Sendebeginn bis zum Erhalt des ACKs max[s/r + RTT - 2 k-1 S/R, 0] = Wartezeit im k-ten Fenster mit P = Anzahl von Slow-Start-Wartezeiten: Verzögerung = = = O R O R O R + 2RTT + + 2RTT + P k= 1 P k= 1 Wartezeit S R + 2RTT + P[RTT + [ + RTT 2 S ] R k ( 2 k 1 P S ] R S 1) R [RN] Sommer 2012 Transportschicht 161
162 [RN] Sommer 2012 Transportschicht 162 Fenster wächst wie bei Slow Start Berechnung der Anzahl von Slow-Start-Wartezeiten K = Anzahl der Fenster, die für das Objekt benötigt werden Q = Anzahl von Slow-Start-Wartezeiten bei unendlich großem Objekt dann P = min(q, K-1) Wartezeiten + = + = = = = 1) S O ( log 1)} S O ( log min{k : k } S O 1 2 min{k : O / S} min{k : O} S 2 S 2 S 2 min{k : 2 2 k 1 k k S /R RTT 1 log S /R RTT 1 2 max 0 R S 2 RTT R S max 2 1 k k 1 k k + + = + = + =
163 Endergebnis: Fenster wächst wie bei Slow Start Verzögerung = 2RTT + O R + P RTT + S R ( 2 P S 1) R enthält Produkt von P und RTT, also: wenn RTT groß und/oder viele Slow-Start-Wartezeiten auftreten, kann die Verzögerung spürbar werden [RN] Sommer 2012 Transportschicht 163
164 TCP: Leistungsanalyse, Beispiele Szenario I: S=536 Bytes, RTT=100 ms (intern.), O=100 KB (lang) R O/R Verzögerung 28 Kbps 28.6 s 28.9 s 100 Kbps 8 s 8.4 s 1 Mbps 800 ms 1.5 s 10 Mbps 80 ms 0.98 s Szenario II: S=536 Bytes, RTT=100 ms, O=5 KB (kurz) R O/R Verzögerung 28 Kbps 1.43 s 1.73 s 100 Kbps 0.48 s s 1 Mbps 40 ms 0.52 s 10 Mbps 4 ms 0.50 s Szenario III: S=536 Bytes, RTT=1 s (Überlast), O=5 KB R O/R Verzögerung 28 Kbps 1.43 s 5.8 s 100 Kbps 0.48 s 5.2 s 1 Mbps 40 ms 5.0 s 10 Mbps 4 ms 5.0 s [RN] Sommer 2012 Transportschicht 164
165 TCP: Leistungsanalyse, Beispiele S=536 Bytes, O=5 KB, R=1 Mbps, RTT wird verändert: Verzögerung [s] S=536 Bytes, O=5 KB, RTT=100 ms, R wird verändert: von 10 Kbps bis 10 Mbps (logarithmische Skalierung): Verzögerung[s] Kbps 1 Mbps 10 Mbps R RTT [s] [RN] Sommer 2012 Transportschicht 165
166 Antwortzeiten bei Web-Seiten Web-Seite mit: 1 Basis-HTML-Seite (O Bits) M Bilder (auch jeweils O Bits) nicht-persistentes HTTP: M+1 sequentielle TCP-Verbindungen Antwortzeit = (M+1)O/R + (M+1)2RTT + Slow-Start-Wartezeiten persistentes HTTP: 2 RTT für Basis-Seite 1 RTT für M Bilder Antwortzeit = (M+1)O/R + 3RTT + Slow-Start-Wartezeiten nicht-persistentes HTTP mit X parallelen Verbindungen Annahme: M/X ist ganze Zahl 1 TCP-Verbindung für Basis-Seite M/X Mengen von parallelen Verbindungen für Bilder Antwortzeit = (M+1)O/R + (M/X+1)2RTT + Slow-Start-Wartezeiten [RN] Sommer 2012 Transportschicht 166
167 TCP: Leistungsanalyse S Kbps 100 Kbps RTT = 100 ms, O = 5 Kbytes, M=10, X=5 1 Mbps 10 Mbps non-persistent persistent parallel nonpersistent Für geringe Bitraten wird die Antwortzeit durch die Übertragungszeit dominiert; persistente Verbindungen ergeben nur geringen Vorteil gegenüber parallelen Verbindungen. [RN] Sommer 2012 Transportschicht 167
168 S Kbps 100 Kbps TCP: Leistungsanalyse RTT =1 s, O = 5 Kbytes, M=10, X=5 1 Mbps 10 Mbps non-persistent persistent parallel nonpersistent Für große RTTs wird die Antwortzeit durch Slow-Start-Wartezeiten dominiert, persistente Verbindungen ergeben insbesondere für große Bitraten-Verzögerungs-Produkte Vorteile. [RN] Sommer 2012 Transportschicht 168
Inhalt der Vorlesung Rechnerkommunikation
Inhalt der Vorlesung Rechnerkommunikation Einführung Anwendungsschicht Transportschicht Netzwerkschicht Sicherungsschicht Physikalische Schicht Netzwerksicherheit Rechnerkommunikation, Transportschicht
MehrÜbungen zu Rechnerkommunikation
Übungen zu Rechnerkommunikation Sommersemester 2009 Übung 4 Jürgen Eckert, Mykola Protsenko PD Dr.-Ing. Falko Dressler Friedrich-Alexander Universität Erlangen-Nürnberg Informatik 7 (Rechnernetze und Kommunikationssysteme)
MehrNetzwerktechnologien 3 VO
Netzwerktechnologien 3 VO Dr. Ivan Gojmerac ivan.gojmerac@univie.ac.at 5. Vorlesungseinheit, 17. April 2013 Bachelorstudium Medieninformatik SS 2013 3.4 Zuverlässigkeit der Datenübertragung - 2 - 3.4 Zuverlässigkeit
MehrTCP. Transmission Control Protocol
TCP Transmission Control Protocol Wiederholung TCP-Ports Segmentierung TCP Header Verbindungsaufbau-/abbau, 3 - WayHandShake Timeout & Retransmission MTU maximum transfer Unit TCP Sicher Verbunden? Individuelle
MehrNetzwerktechnologien 3 VO
Netzwerktechnologien 3 VO Univ.-Prof. Dr. Helmut Hlavacs helmut.hlavacs@univie.ac.at Dr. Ivan Gojmerac gojmerac@ftw.at Bachelorstudium Medieninformatik SS 2012 Kapitel 3 Transportschicht 3.1 Dienste der
MehrThemen. Dienste der Transportschicht. 3-Wege-Handshake. TCP-Protokoll-Header. Real-Time-Protocol
Themen Dienste der 3-Wege-Handshake TCP-Protokoll-Header Real-Time-Protocol Dienste der Fehlerüberwachung Steuerung der Reihenfolge Wie kann eine korrekte Paket-Übertragung garantiert werden? Wie kann
MehrLehrveranstaltung Rechnernetze Einschub für das Labor
Lehrveranstaltung Rechnernetze Einschub für das Labor Sommersemester 2010 Dr. Andreas Hanemann Einordnung der Transportschicht Verbindungen bestehen zwischen zwei Endsystemen Transitnetze bzw. Netzknoten
MehrRechnernetze Übung 11
Rechnernetze Übung 11 Frank Weinhold Professur VSR Fakultät für Informatik TU Chemnitz Juli 2011 Herr Müller (Test GmbH) Sekretärin (Super AG) T-NR. 111 T-NR. 885 Sekretärin (Test GmbH) Herr Meier (Super
MehrRechnernetze Übung 11. Frank Weinhold Professur VSR Fakultät für Informatik TU Chemnitz Juni 2012
Rechnernetze Übung 11 Frank Weinhold Professur VSR Fakultät für Informatik TU Chemnitz Juni 2012 IP: 192.168.43.9 MAC: 02-55-4A-89-4F-47 IP: 216.187.69.51 MAC: 08-48-5B-77-56-21 1 2 IP: 192.168.43.15 MAC:
MehrGrundlagen der Rechnernetze. Transportschicht
Grundlagen der Rechnernetze Transportschicht Übersicht Einfacher Demultiplexer (UDP) Transmission Control Protocol (TCP) TCP Überlastkontrolle TCP Überlastvermeidung TCP Varianten SS 2014 Grundlagen der
MehrTCP-Verbindungen und Datenfluss
TCP-Verbindungen und Datenfluss Jörn Stuphorn stuphorn@rvs.uni-bielefeld.de Universität Bielefeld Technische Fakultät Stand der Veranstaltung 13. April 2005 Unix-Umgebung 20. April 2005 Unix-Umgebung 27.
MehrModul 5: TCP-Flusskontrolle
Modul 5: TCP-Flusskontrolle M. Leischner Internetkommunikation Folie 1 Prinzip des Sliding-Window: Zuverlässigkeit + Effizienz A B A B A B A B unbestätigtes Senden Stop-and-Wait Sliding-Window Sliding
MehrTransportschicht. Einleitung Transmission Control Protocol, RFC793. Transportschicht
Transportschicht 1 / 33 Kommunikationsnetze I 19.11.2008 Dienste der Transportschicht Die Transportschicht bietet einen verbindungsorientierten und einen verbindungslosen Dienst, unabhängig von den Diensten
MehrTCP/UDP. Transport Layer
TCP/UDP Transport Layer Lernziele 1. Wozu dient die Transportschicht? 2. Was passiert in der Transportschicht? 3. Was sind die wichtigsten Protkolle der Transportschicht? 4. Wofür wird TCP eingesetzt?
MehrDie Transportprotokolle UDP und TCP
Die Transportprotokolle UDP und TCP! UDP (User Datagram Protocol) " Ist wie IP verbindungslos (Zustellung und Reihenfolge werden nicht garantiert) " Erweitert die Funktionalität von IP um die Möglichkeit,
MehrNetzwerktechnologien 3 VO
Netzwerktechnologien 3 VO Univ.-Prof. Dr. Helmut Hlavacs helmut.hlavacs@univie.ac.at Dr. Ivan Gojmerac gojmerac@ftw.at Bachelorstudium Medieninformatik SS 2012 Kapitel 3 Transportschicht 3.1 Dienste der
MehrUDP User Datagramm Protokoll
UDP User Datagramm Protokoll Marco Gerland Janina de Jong Internet Protokolle WS 03 / 04 1/31 Einführung IP Datagramme werden durchs Internet geroutet abh. von der IP Adresse Anhand der Ziel IP Adresse
MehrTCP/UDP PROF. DR. M. FÖLLER NORD INSTITUT EMBEDDED AND MOBILE COMPUTING
TCP/UDP PROF. DR. M. FÖLLER NORD INSTITUT EMBEDDED AND MOBILE COMPUTING Bereitstellen von logischer Kommunikation zwischen Anwendungsprozessen Multiplexen und Demultiplexen von Anwendungen Prinzipien des
MehrÜbungen zu Rechnerkommunikation Wintersemester 2010/2011 Übung 8
Übungen zu Rechnerkommunikation Wintersemester 2010/2011 Übung 8 Mykola Protsenko, Jürgen Eckert PD. Dr.-Ing. Falko Dressler Friedrich-Alexander d Universität Erlangen-Nürnberg Informatik 7 (Rechnernetze
MehrThemen. Transportschicht. Internet TCP/UDP. Stefan Szalowski Rechnernetze Transportschicht
Themen Transportschicht Internet TCP/UDP Transportschicht Schicht 4 des OSI-Modells Schicht 3 des TCP/IP-Modells Aufgaben / Dienste: Kommunikation von Anwendungsprogrammen über ein Netzwerk Aufteilung
MehrVortrag zur Diplomarbeit
Fakultät Informatik Professur für VLSI-Entwurfssysteme, Diagnostik und Architektur Vortrag zur Diplomarbeit Entwurf und Implementierung eines zuverlässigen verbindungsorientierten Transportprotokolls für
MehrInternetanwendungstechnik. Transportschicht. Gero Mühl
Internetanwendungstechnik Transportschicht Gero Mühl Technische Universität Berlin Fakultät IV Elektrotechnik und Informatik Kommunikations- und Betriebssysteme (KBS) Einsteinufer 17, Sekr. EN6, 10587
Mehr15 Transportschicht (Schicht 4)
Netzwerktechnik Aachen, den 16.06.03 Stephan Zielinski Dipl.Ing Elektrotechnik Horbacher Str. 116c 52072 Aachen Tel.: 0241 / 174173 zielinski@fh-aachen.de zielinski.isdrin.de 15 Transportschicht (Schicht
MehrDie Transportprotokolle: Transmission Control Protocol (TCP) User Datagram Protocol (UDP) Die Socket-Schnittstelle
Die Transportprotokolle: Transmission Control Protocol (TCP) User Datagram Protocol (UDP) Die Socket-Schnittstelle 1 Schichten 5..7 Rolle der Transportschicht im OSI- Referenzmodell Anforderungen des Anwendungsprozesses
MehrVorlesung: Netzwerke (TK) WS 2011/12 Kapitel 1 Vorbereitung für Praktikum Session 03
Vorlesung: Netzwerke (TK) WS 2011/12 Kapitel 1 Vorbereitung für Praktikum Session 03 Prof. Dr. Michael Massoth [Stand: 19.10.2011] 3-1 3-2 Vorbereitung auf Praktikum: Versuch 1 Hausaufgabe: Schriftliche
MehrFakultät Informatik Professur für VLSI-Entwurfssysteme, Diagnostik und Architektur. Diplomverteidigung
Fakultät Informatik Professur für VLSI-Entwurfssysteme, Diagnostik und Architektur Diplomverteidigung Entwurf und Implementierung eines zuverlässigen verbindungsorientierten Transportprotokolls für die
MehrMobilkommunikationsnetze - TCP/IP (und andere)-
- TCP/IP (und andere)- Vorlesung Inhalt Überblick ISO/OSI vs. TCP/IP Schichten in TCP/IP Link Layer (Netzzugang) Network Layer (Vermittlung) Transport Layer (Transport) Application Layer (Anwendung) Page
MehrChapter 11 TCP. CCNA 1 version 3.0 Wolfgang Riggert,, FH Flensburg auf der Grundlage von
Chapter 11 TCP CCNA 1 version 3.0 Wolfgang Riggert,, FH Flensburg auf der Grundlage von Rick Graziani Cabrillo College Vorbemerkung Die englische Originalversion finden Sie unter : http://www.cabrillo.cc.ca.us/~rgraziani/
MehrRechnernetze I SS Universität Siegen Tel.: 0271/ , Büro: H-B Stand: 7.
Rechnernetze I SS 2016 Universität Siegen rolanda.dwismuellera@duni-siegena.de Tel.: 0271/740-4050, Büro: H-B 8404 Stand: 7. Juli 2016 Betriebssysteme / verteilte Systeme Rechnernetze I (1/13) i Rechnernetze
MehrKommunikationsnetze Prof. Dr. rer. nat. habil. Seitz. Sara Schaarschmidt Eric Hänsel
Kommunikationsnetze Prof. Dr. rer. nat. habil. Seitz Sara Schaarschmidt Eric Hänsel 23.05.2011 Seite 1 Gliederung 1. Was ist eine Flusssteuerung? 2. Unterschied zur Staukontrolle 3. Verfahren der Flusssteuerung
MehrTransportschicht (Schicht 4) des Internet
Transportschicht (Schicht 4) des Internet Es gibt zwei Transportprotokolle: TCP = Transmission Control Protocol UDP = User Datagram Protocol a) TCP: baut virtuelle Verbindung auf (verbindungsorientiert)
MehrTransportprotokolle. TCP - Transmission Control Protocol
Transportprotokolle Setzen auf Internet-Protokollen (Rechner-zu-Rechner) auf Unterscheiden Kommunikationskanäle innerhalb eines Rechners ICMP - Internet Control Message Protocol TCP - Transmission Control
MehrDie Transportprotokolle: Transmission Control Protocol (TCP) User Datagram Protocol (UDP) Die Socket-Schnittstelle
Die Transportprotokolle: Transmission Control Protocol (TCP) User Datagram Protocol (UDP) Die Socket-Schnittstelle 1 Schichten 5..7 Schicht 4 Rolle der Transportschicht im OSI- Referenzmodell Anforderungen
MehrRolf Wanka Sommersemester Vorlesung
Peer-to to-peer-netzwerke Rolf Wanka Sommersemester 2007 4. Vorlesung 14.05.2007 rwanka@cs.fau.de basiert auf einer Vorlesung von Christian Schindelhauer an der Uni Freiburg Inhalte Kurze Geschichte der
MehrInternet Networking TCP Congestion Avoidance and Control
Internet Networking TCP Congestion Avoidance and Control Sommersemester 2003 Gliederung 1 Einleitung 2 TCP - Transport Control Protocol 3 Conservation Of Packets 4 Methoden des Congestion Controls Round
MehrTutorübung zur Vorlesung Grundlagen Rechnernetze und Verteilte Systeme Übungsblatt 8 (10. Juni 17. Juni 2013)
Technische Universität München Lehrstuhl Informatik VIII Prof. Dr.-Ing. Georg Carle Dipl.-Ing. Stephan Günther, M.Sc. Nadine Herold, M.Sc. Dipl.-Inf. Stephan Posselt Tutorübung zur Vorlesung Grundlagen
MehrDas ISO / OSI -7 Schichten Modell
Begriffe ISO = Das ISO / OSI -7 Schichten Modell International Standardisation Organisation Dachorganisation der Normungsverbände OSI Model = Open Systems Interconnection Model Modell für die Architektur
MehrTCP/IP-Protokollfamilie
TCP/IP-Protokollfamilie Internet-Protokolle Mit den Internet-Protokollen kann man via LAN- oder WAN kommunizieren. Die bekanntesten Internet-Protokolle sind das Transmission Control Protokoll (TCP) und
MehrGrundkurs Routing im Internet mit Übungen
Grundkurs Routing im Internet mit Übungen Falko Dressler, Ursula Hilgers {Dressler,Hilgers}@rrze.uni-erlangen.de Regionales Rechenzentrum der FAU 1 Tag 4 Router & Firewalls IP-Verbindungen Aufbau von IP
MehrThemen. Sicherungsschicht. Rahmenbildung. Häufig bereitgestellte Dienste. Fehlererkennung. Stefan Szalowski Rechnernetze Sicherungsschicht
Themen Sicherungsschicht Rahmenbildung Häufig bereitgestellte Dienste Fehlererkennung OSI-Modell: Data Link Layer TCP/IP-Modell: Netzwerk, Host-zu-Netz Aufgaben: Dienste für Verbindungsschicht bereitstellen
MehrHauptdiplomklausur Informatik. September 2000: Rechnernetze
Universität Mannheim Fakultät für Mathematik und Informatik Lehrstuhl für Praktische Informatik IV Prof. Dr. W. Effelsberg Hauptdiplomklausur Informatik September 2000: Rechnernetze Name:... Vorname:...
MehrVorlesung SS 2001: Sicherheit in offenen Netzen
Vorlesung SS 2001: Sicherheit in offenen Netzen 2.2 Transmission Control Protocol - TCP 2.3 User Datagram Protocol - UDP Prof. Dr. Christoph Meinel Informatik, Universität Trier & Institut für Telematik,
MehrLösungsvorschlag zur 12. Übung
Prof. Frederik Armknecht Sascha Müller Daniel Mäurer Grundlagen der Informatik 3 Wintersemester 09/0 Lösungsvorschlag zur 2. Übung Präsenzübungen. Schnelltest a) Welche der Behauptungen zum OSI-Modell
Mehr2 Sicherungsschicht (Data Link Layer)
Übertragungsdauer Ausbreitungsgeschwindigkeit T ges = T s + T a In üblichen Medien (Kabel, Glasfaser) ist v 2 3 c 200 000km s Bandbreiten-Verzögerungs-Produkt auf dem Medium befindet. ist das Datenvolumen,
MehrProtokolle und Schichten. Grundlagen der Rechnernetze Einführung 41
Protokolle und Schichten Grundlagen der Rechnernetze Einführung 41 Protokoll und Interface Host 1 Host 2 High Level Objekt High Level Objekt Service Interface Service Interface Protokoll Peer to peer Interface
Mehr11. Foliensatz Betriebssysteme und Rechnernetze
Prof. Dr. Christian Baun 11. Foliensatz Betriebssysteme und Rechnernetze FRA-UAS SS2017 1/23 11. Foliensatz Betriebssysteme und Rechnernetze Prof. Dr. Christian Baun Frankfurt University of Applied Sciences
MehrÜbungsblatt Warum brauchen Bridges und Layer-2-Switches keine physischen oder logischen
Übungsblatt 3 Aufgabe 1 (Bridges und Switche) 1. Was ist die Aufgabe von Bridges in Computernetzen? 2. Wie viele Schnittstellen ( Ports ) hat eine Bridge? 3. Was ist der Hauptunterschied zwischen Bridges
MehrTransportprotokolle im TCP/IP- Referenzmodell
Transportprotokolle im TCP/IP- Referenzmodell HTTP FTP Telnet SMTP DNS SNMP TFTP Internetprotokolle IGMP TCP ICMP UDP RARP IP ARP Schicht 1/2 Ethernet TokenRing Token Bus Wireless Lan TCP (Transmission
MehrNetzwerk-Programmierung. Netzwerke.
Netzwerk-Programmierung Netzwerke Alexander Sczyrba Michael Beckstette {asczyrba,mbeckste}@techfak.uni-bielefeld.de Übersicht Netzwerk-Protokolle Protkollfamilie TCP/IP Transmission Control Protocol (TCP)
MehrGrundlagen TCP/IP. C3D2 Chaostreff Dresden. Sven Klemm sven@elektro-klemm.de
Grundlagen TCP/IP C3D2 Chaostreff Dresden Sven Klemm sven@elektro-klemm.de Gliederung TCP/IP Schichtenmodell / Kapselung ARP Spoofing Relaying IP ICMP Redirection UDP TCP Schichtenmodell Protokolle der
MehrVorlesung: Netzwerke (TK) WS 2009/10 Kapitel 5 Ende-zu-Ende-Protokolle Session 15
Vorlesung: Netzwerke (TK) WS 2009/10 Kapitel 5 Ende-zu-Ende-Protokolle Session 15 Prof. Dr. Michael Massoth [Stand: 07.01.2009] 15-1 15-2 ACHTUNG: Testat_3 am Mittwoch, den 13.01.2010 Referenzmodelle (OSI,
MehrAbschlussklausur. Computernetze. 14. Februar Legen Sie bitte Ihren Lichtbildausweis und Ihren Studentenausweis bereit.
Abschlussklausur Computernetze 14. Februar 2014 Name: Vorname: Matrikelnummer: Tragen Sie auf allen Blättern (einschlieÿlich des Deckblatts) Ihren Namen, Vornamen und Ihre Matrikelnummer ein. Schreiben
MehrDamit zwischen den verschiedenen Rechnern überhaupt ein Austausch möglich ist, muss man sich über das was und wie verständigen.
Webanwendungen Protokolle Damit zwischen den verschiedenen Rechnern überhaupt ein Austausch möglich ist, muss man sich über das was und wie verständigen. So wurde eine Sammlung von Vereinbarungen zusammengestellt,
MehrSysteme II 10. Woche Transportschicht. Christian Schindelhauer Technische Fakultät Rechnernetze und Telematik Albert-Ludwigs-Universität Freiburg
Systeme II 10. Woche Transportschicht Christian Schindelhauer Technische Fakultät Rechnernetze und Telematik Albert-Ludwigs-Universität Freiburg Dienste der Transportschicht Verbindungslos oder Verbindungsorientert
MehrTCP/IP Grundlagen verfasst von wintools4free.dl.am visit: www.tgss.dl.am www.wintools4free.dl.am
TCP/IP Grundlagen verfasst von wintools4free.dl.am visit: www.tgss.dl.am www.wintools4free.dl.am Das Internet ist ein Heute weit verbreitetes Medium, das auf eine große Resonanz stößt. War das Internet
MehrIP Internet Protokoll
IP Internet Protokoll Adressierung und Routing fürs Internet von Stephan Senn Inhalt Orientierung: Die Netzwerkschicht (1min) Aufgabe des Internet Protokolls (1min) Header eines Datenpakets (1min) Fragmentierung
MehrAbschlussklausur. Computernetze. Bewertung: 16. Mai Name: Vorname: Matrikelnummer:
Abschlussklausur Computernetze 16. Mai 2014 Name: Vorname: Matrikelnummer: Mit meiner Unterschrift bestätige ich, dass ich die Klausur selbständig bearbeite und das ich mich gesund und prüfungsfähig fühle.
MehrInformations- und Kommunikationssysteme
Informations- und Kommunikationssysteme Kapitel 2.3 Transportschicht Acknowledgement: Folien angelehnt an J.F. Kurose and K.W. Ross 1 Kapitel 2.3: Transportschicht Unsere Ziele: Prinzipien der Dienste
MehrComputeranwendung in der Chemie Informatik für Chemiker(innen) 5. Internet
Computeranwendung in der Chemie Informatik für Chemiker(innen) 5. Internet Jens Döbler 2003 "Computer in der Chemie", WS 2003-04, Humboldt-Universität VL5 Folie 1 Dr. Jens Döbler Internet Grundlagen Zusammenschluß
MehrFOPT 5: Eigenständige Client-Server-Anwendungen (Programmierung verteilter Anwendungen in Java 1)
1 FOPT 5: Eigenständige Client-Server-Anwendungen (Programmierung verteilter Anwendungen in Java 1) In dieser Kurseinheit geht es um verteilte Anwendungen, bei denen wir sowohl ein Client- als auch ein
MehrBeispiel TCP-/IP-Datenübertragung
TCP/IP Beispiel TCP-/IP-Datenübertragung Einfach mal Sniffen (im Raum LAN/Filius) --> Installieren Sie das Programm WireShark http://www.wireshark.org/ Lauschen Sie Ihre Netzwerkkarte aus! (10 Sek) Vorsicht!
MehrNetzwerke, Kapitel 3.1
Netzwerke, Kapitel 3.1 Fragen 1. Mit welchem anschaulichen Beispiel wurde das OSI-Schichtenmodell erklärt? Dolmetscher 2. Was versteht man unter Dienstprimitiven? Request, Indication, Response, Confirm
MehrKapitel 3 Transportschicht
Kapitel 3 Transportschicht Ein Hinweis an die Benutzer dieses Foliensatzes: Wir stellen diese Folien allen Interessierten (Dozenten, Studenten, Lesern) frei zur Verfügung. Da sie im PowerPoint-Format vorliegen,
MehrVorlesung: Netzwerke (TK) WS 2011/12 Kapitel 5 Ende-zu-Ende-Protokolle Session 15
Vorlesung: Netzwerke (TK) WS 2011/12 Kapitel 5 Ende-zu-Ende-Protokolle Session 15 Prof. Dr. Michael Massoth [Stand: 10.01.2012] 15-1 15-2 ACHTUNG: Testat_4 am Dienstag, den 17.01.2012 Referenzmodelle (OSI,
MehrARP, ICMP, ping. Jörn Stuphorn Bielefeld, den 4. Mai Mai Universität Bielefeld Technische Fakultät
ARP, ICMP, ping Jörn Stuphorn stuphorn@rvs.uni-bielefeld.de Universität Bielefeld Technische Fakultät TCP/IP Data Link Layer Aufgabe: Zuverlässige Übertragung von Rahmen über Verbindung Funktionen: Synchronisation,
MehrCharakteristische Fragestellungen der Schicht 4
Charakteristische Fragestellungen der Schicht 4 Rechnernetze Kap. 8 Kapitel 8 1 Charakteristische Fragestellungen der Schicht 4 Kapitel: 8.1: Internet Transportprotokolle 1 TCP (1): Überblick TCP (Transport
MehrNetzwerke. Netzwerk-Programmierung. Sven Hartmeier.
Netzwerk-Programmierung Netzwerke Sven Hartmeier shartmei@techfak.uni-bielefeld.de Übersicht Netzwerk-Protokolle Protokollfamilie TCP/IP Transmission Control Protocol (TCP) erste Schritte mit sockets Netzwerk-Programmierung
MehrKommunikationsnetze 1. TCP/IP-Netze 1.2 TCP. University of Applied Sciences. Kommunikationsnetze. 1. TCP/IP-Netze 1.
Kommunikationsnetze (und UDP ) Gliederung 1. Aufgaben eines Transportprotokolls 2. Eigenschaften von TCP und UDP 3. Der TCP-Header 4. TCP-Verbindungsmanagement Gliederung 1. Aufgaben eines Transportprotokolls
MehrNetzwerk-Programmierung. Netzwerke. Alexander Sczyrba Michael Beckstette.
Netzwerk-Programmierung Netzwerke Alexander Sczyrba Michael Beckstette {asczyrba,mbeckste}@techfak.uni-bielefeld.de 1 Übersicht Netzwerk-Protokolle Protkollfamilie TCP/IP Transmission Control Protocol
Mehr2.3 Applikationen. Protokolle: TCP/IP. Telnet, FTP, Rlogin. Carsten Köhn
2.3 Applikationen Telnet, FTP, Rlogin Carsten Köhn Protokolle: TCP/IP Application umfasst Dienste, die als Prozesse des Betriebssystems ausgeführt werden SMTP, FTP, HTTP, MIME Transport regelt die Kommunikation
MehrVernetzte Systeme. Übungsstunde Adrian Schüpbach 30. Juni 2006
Vernetzte Systeme Übungsstunde 30.06.2006 Adrian Schüpbach scadrian@student.ethz.ch 30. Juni 2006 Adrian Schüpbach (ETH Zürich) Vernetzte Systeme SS 2006 1 / 33 Letzte Serie! Letzte Serie! Adrian Schüpbach
MehrRechnernetze und Internettechnologien
Rechnernetze und Internettechnologien Dr. Harald Sack Institut für Informatik Friedrich-Schiller-Universität Jena Sommersemester 2008 http://www.informatik.uni-jena.de/~sack/ss08/ n 1 2 3 4 5 6 7 8 9 10
MehrKOMMUNIKATIONSNETZE UND - PROTOKOLLE 6. TRANSPORTSCHICHT. KNP: 6. Transport. 1 / v5. prof. dr. Werner Winzerling
KOMMUNIKATIONSNETZE UND - PROTOKOLLE 6. TRANSPORTSCHICHT 1 / v5 6. TRANSPORTSCHICHT HEUTIGES LERNZIEL: Aufbau und Aufgaben der Transportschicht Dienste der Transportschicht (Ende-zu-Ende- Verbindung, Flussteuerung)
MehrHauptdiplomklausur Informatik Juni 2008: Computer Networks
Universität Mannheim Fakultät für Mathematik und Informatik Lehrstuhl für Praktische Informatik IV Prof. Dr.-Ing. W. Effelsberg Hauptdiplomklausur Informatik Juni 2008: Computer Networks Name: Matrikel-Nr.:
Mehr2 Kommunikationssysteme. vs2 1
2 Kommunikationssysteme vs2 Kommunikationssysteme bieten Kommunikationsdienste an, die das Senden und Empfangen von Nachrichten erlauben (sending & receiving messages) bestehen aus - Kommunikationsnetz
MehrRouter 1 Router 2 Router 3
Network Layer Netz 1 Netz 2 Netz 3 Router 1 Router 2 Router 3 Router 1 Router 2 Router 3 Netz 1, Router 1, 1 Netz 1, Router 1, 2 Netz 1, Router 2, 3 Netz 2, Router 2, 2 Netz 2, Router 2, 1 Netz 2, Router
MehrÜbungen zu Rechnerkommunikation
Übungen zu Rechnerkommunikation Sommersemester 2009 Übung 7 Jürgen Eckert, Mykola Protsenko PD Dr.-Ing. Falko Dressler Friedrich-Alexander Universität Erlangen-Nürnberg Informatik 7 (Rechnernetze und Kommunikationssysteme)
Mehr7 Transportprotokolle
7 Transportprotokolle 7.1 Transmission Control Protocol (TCP) 7.2 User Datagram Protocol (UDP) 7.3 Ports 7.1 TCP (1) IP-Pakete (Datagramme) von A nach B transportieren reicht nicht interaktive Verbindungen
MehrIPv4 - Internetwork Protocol
IPv4 - Internetwork Protocol Connectionless Pakete werden abgeschickt, eine Bestätigung erfolgt NICHT! Networklayer Erfüllt die Aufgaben der 3. ISO-Schicht Aufbau # Bits Abkürzung Inhalt 4 Vers Version
MehrDomain Name Service (DNS)
Domain Name Service (DNS) Aufgabe: den numerischen IP-Adressen werden symbolische Namen zugeordnet Beispiel: 194.94.127.196 = www.w-hs.de Spezielle Server (Name-Server, DNS) für Listen mit IP-Adressen
Mehr2. Architektur von Kommunikationssystemen
2. Architektur von Kommunikationssystemen 2.1 2.2 TCP/IP-basierte Protokollarchitektur Digitale Kommunikationssysteme Prof. Dr. Habermann / Dr. Hischke 12-01 / 1 Das OSI-Referenzmodell wird ausführlich
MehrÜbung - Mit Wireshark eine UDP-DNS-Aufzeichnung untersuchen
Übung - Mit Wireshark eine UDP-DNS-Aufzeichnung untersuchen Topologie Lernziele Teil 1: Wireshark für das Erfassen von Paketen vorbereiten Auswahl einer geeigneten Netzwerk-Schnittstelle, um Pakete zu
MehrVermittlungsschicht ( network layer )
Vermittlungsschicht ( network layer ) ggf. Auswahl eines Subnetzes für die folgende Übertragungsstrecke Auswahl eines guten Transportweges (Routing) im gewählten Subnetz statisch: fest für alle Pakete
MehrOSI-Schichtenmodell. Martin Fechtner
OSI-Schichtenmodell Martin Fechtner Rechnernetze Rechnernetze sind Netzwerke, deren Teilnehmer Rechner sind zwischen den Teilnehmern werden digitale Daten übertragen im Allgemeinen können beliebige Teilnehmer
MehrTCP Teil 2. TCP Teil 2: Tilmann Kuhn Betreuer: Dr. Thomas Fuhrmann 1/18
TCP Teil 2 sliding window protocol Begriffe: MSS, RTT und RTO bulk-data flow Stau-Vermeidung Langsamer Start Zusammenspiel: S.V. und L.S. TCP features und options TCP Teil 2: Tilmann Kuhn Betreuer: Dr.
MehrDienste der Transportschicht
Dienste der Transportschicht Die Transportschicht bietet einen verbindungsorientierten und einen verbindungslosen Dienst, unabhängig von den Diensten der zugrundeliegenden Vermittlungsschicht. Im verbindungsorientierten
MehrComputerforensik. Prof. Dr. Silke Draber Fachhochschule Bonn Rhein Sieg. Vorlesung SS 2008. Einführung in TCP/IP
Computer Forensik Fachhochschule Bonn Rhein Sieg Vorlesung SS 2008 1 Einführung in TCP/IP Grundlagen von Netzwerken im Allgemeinen Protokolle und Dienste TCP/IP im Detail TCP/IP Protokollarchitektur Die
MehrÜbung 5: Transport. Rechnernetze. Wintersemester 2014/ Allgemeine TCP Verständnisfragen
Wintersemester 2014/2015 Rechnernetze Universität Paderborn Fachgebiet Rechnernetze Übung 5: Transport 1. Allgemeine TCP Verständnisfragen (a) TCP ermöglicht einem Empfänger, die maximum segment size (MSS),
MehrEinleitung Sniffing, Analyzing, Scanning Scanning. Netzwerke. Bierfert, Feresst, Günther, Schuster. 21. März 2006
Sniffing, Analyzing, 21. März 2006 Sniffing, Analyzing, Sniffing, Analyzing, Transmission Control Protocol (RFC 793) Zwei Endpunkte, bezeichnet mit Server und Client Server und Client aus je einem geordneten
MehrMultiuser Client/Server Systeme
Multiuser /Server Systeme Christoph Nießner Seminar: 3D im Web Universität Paderborn Wintersemester 02/03 Übersicht Was sind /Server Systeme Wie sehen Architekturen aus Verteilung der Anwendung Protokolle
MehrGrundlegende Steuer- und Verwaltungsfunktionen (ICMP)
Grundlegende Steuer- und Verwaltungsfunktionen (ICMP) Dr. Hannes P. Lubich Bank Julius Bär Zürich Einführung in TCP/IP Grundlegende Steuer- und Verwaltungsfunktionen (ICMP) (1) Einführung in ICMP Zur Steuerung
MehrÜberblick. Daten- kommunikation
Überblick Wintersemester 2014/2015 Prof. Dr. Peter Mandl Daten- kommunikation Aufbau von Kommunikationssystemen Funktionen und Protokolle der unteren Schichten Grundlagen der Transportschicht TCP-Grundlagen
MehrUDP-, MTU- und IP- Fragmentierung
UDP-, MTU- und IP- Fragmentierung Jörn Stuphorn stuphorn@rvs.uni-bielefeld.de Universität Bielefeld Technische Fakultät Stand der Veranstaltung 13. April 2005 Unix-Umgebung 20. April 2005 Unix-Umgebung
MehrInhaltsverzeichnis. Kapitel 1 Computernetzwerke und das Internet 21. Kapitel 2 Anwendungsschicht 107
Inhaltsverzeichnis Die Autoren................................................. 9 Vorwort.................................................... 10 Was bringt die sechste Auflage Neues?...................
MehrTCP flow control, congestion avoidance
TCP flow control, congestion Christian Dondrup (cdondrup@techfak...) Tim Nelißen (tnelisse@techfak...) 1 Übersicht Einleitung Sliding Window Delayed Acknowledgements Nagle Algorithm Slow Start Congestion
MehrDer TCP/IP Protokollstapel
Der TCP/IP Protokollstapel Inhaltsverzeichnis 1. EINFÜHRUNG 2 2. VERGLEICH OSI-MODELL TCP/IP-SCHICHTENMODELL 2 3. PHYSISCHES NETZWERK TCP/IP DATENFLUß 3 3.1 ARP 3 3.2 DATENFLUß IM TCP/IP MODELL 3 4. DIE
MehrTransportprotokolle im TCP/IP- Referenzmodell
Transportprotokolle im TCP/IP- Referenzmodell HTTP FTP Telnet SMTP DNS SNMP TFTP Internetprotokolle IGMP TCP ICMP UDP RARP IP ARP Schicht 1/2 Ethernet TokenRing Token Bus Wireless Lan TCP (Transmission
MehrRechnern netze und Organisatio on
Rechnernetze und Organisation Assignment A3 Präsentation 1 Motivation Übersicht Netzwerke und Protokolle Rechnernetze und Organisatio on Aufgabenstellung: Netzwerk-Protokoll-Simulator 2 Motivation Protokoll-Simulator
MehrVerteilte Systeme. Protokolle. by B. Plattner & T. Walter (1999) Protokolle-1. Institut für Technische Informatik und Kommunikationsnetze
Protokolle Protokolle-1 Kommunikationssubsystem Ein System, welches innerhalb eines verteilten Systems für den Nachrichtentransport zwischen Kommunikationspartnern (= Prozesse) zuständig ist (Hardware
Mehr