Beispiel für einen Bitfehler

(1)

Grundlagen der Rechnernetze

Übertragungssicherung

(2)

Übersicht

• Fehlerdetektion

• Fehlerkorrektur

• Flusskontrolle

• Fehlerkontrolle

• Framing

(3)

Fehlerdetektion

Grundlagen der Rechnernetze ‐Übertragungssicherung 3

(4)

Ablauf der Fehlerdetektion

check bits

Bildquelle: William Stallings, „Data and Computer Communications“, 2004

(5)

Parity‐Check

1110001

Daten Sender

Empfänger

1110001 1110001 1110001

Beispiel für einen Bitfehler

(6)

Internet‐Checksumme

Einfache Idee

• Sender addiert alle übertragenen n‐Bit‐Wörter und fügt diese Prüfsumme der Übertragung im Header hinzu

• Empfänger führt die gleiche Berechnung durch und vergleicht das Ergebnis mit der empfangenen Prüfsumme

Typischer Einsatz

• Internetprotokolle IP (v4), UDP, TCP

• Verwenden 16‐Bit‐Komplementarithmetik und das Komplement des Ergebnisses Vorteil: zusätzlicher Kommunikationsaufwand ist gering und einfach zu implementieren Nachteil: Stärke der Fehlererkennung nicht besonders gut.

Typische Nutzung:

• Die meisten Fehler werden von stärkeren Fehlererkennungsalgorithmen wie z.B. CRC (siehe gleich) auf Verbindungsebene erfasst

• Checksumme dient als „letzte Verteidigungslinie“ z.B. in einem Ende‐zu‐Ende‐Protokoll

1011 0101 1110 1001 ... 1100

b₁ b₂ b₃ b₄ b_n

Sum(b₁, b₂, … , b_n)

(7)

Internet‐Checksumme: 4‐Bit‐Beispiel

1011 0101 1110 1001 ... 1100

b₁ b₂ b₃ b₄ b_n

Sum(b₁, b₂, … , b_n)

Beispiel Summenberechnung anhand von Einer‐Komplement‐Arithmetik:

(8)

Einer‐Komplement‐Arithmetik

Warum das Carry am Schluss als LSB addieren? [Begründung am Beispiel]

(9)

Fehlerdetektion

Cyclic‐Redanduncy‐Check

(10)

Modulo 2 Arithmetik

A B A  B 0 0

0 1 1 0 1 1

A B A  B 0 0

0 1 1 0 1 1

A B A  B 0 0

0 1 1 0 1 1

Beispiel 0110111011

 1101010110

=

Addition Modulo 2 Subtraktion Modulo 2 Multiplikation Modulo 2

(11)

Division Modulo 2

1010111 : 1101 = ????

Also: 1010111 : 1101 = Rest

(12)

CRC Idee

1010010000 : 1101

(13)

n‐k Nullen an Datenblock D anhängen:

Bestimmen von FCS F:

Zu versendender Frame T:

Cyclic‐Redundancy‐Check (CRC)

1010001101

n‐Bit‐Frame T

k‐Bit‐Datenblock D (n‐k)‐Bit‐FCS F

01110 110101

(n‐k+1)‐Pattern P T ist immer durch P teilbar:

(14)

Auswirkung von Fehlern

Ein Fehler mit nicht teilbarem Fehler‐Pattern wird erkannt:

1010001101 01110 1000011101 01011

T

_r

E

Sender

Empfänger

(15)

Darstellung von Datenblock und Pattern als Polynom:

Datenblock um n‐k Stellen (also hier 4 Stellen) verschieben:

Berechnung der FCS:

Darstellung des zu versendenden Frames T

CRC mit Polynomen

110011

k‐Bit Datenblock D

11001

(n‐k+1)‐Pattern P

(16)

Polynom‐Division Modulo 2

X

⁶

+ X

⁴

+ X

²

+ X

¹

+ 1 : X

³

+ X

²

+ 1 =

(17)

00101

Auswirkung von Fehlern

10100 10001

T

_r

E

Sender

Empfänger

Für Generator P(X) und T(X)/P(X) = Q(X) werden nicht teilbare Fehler‐Pattern erkannt:

(18)

Erkennbare und nicht erkennbare Fehler

Ein Fehler ist nicht erkennbar genau dann wenn:

Single‐Bitfehler ist immer erkennbar, wenn P(X) mindestens zwei Terme enthält

Beispiel

(19)

Erkennbare und nicht erkennbare Fehler

Bitfehler‐Burst < Anzahl Check‐Bits ist immer erkennbar, wenn P(X) den Term 1 enthält

Beispiel

(20)

Weitere CRC‐Fakten

Double‐Bitfehler immer erkennbar, wenn P(X) einen Faktor mit drei Termen besitzt (ohne Beweis)

P(X) = R(X) ∙ (X

^p

+ X

^r

+ X

^q

)

Ungeradzahlige Bitfehler immer erkennbar, solange P(X) einen Faktor (X+1) enthält (ohne Beweis)

P(X) = R(X) ∙ (X+1)

Beliebte Polynome

CRC‐12 = X

¹²

+ X

¹¹

+ X

³

+ X

²

+ 1 CRC‐16 = X

¹⁶

+ X

¹⁵

+ X

²

+ 1

CRC‐CCITT = X

¹⁶

+ X

¹²

+ X

⁵

+ 1

CRC‐32 = X

³²

+ X

²⁶

+ X

²³

+ X

²²

+ X

¹⁶

+ X

¹²

+ X

¹¹

+ X

¹⁰

+ X

⁸

+ X

⁷

+ X

⁵

+ X

⁴

+ X

²

+ X + 1

(21)

Fehlerkorrektur

(22)

Ablauf der Fehlerkorrektur

(23)

Beispiel Two‐Dimensional‐Parity

0 1 0 1

1 1 1 0

0 1 1 0

1 0 0 1

(24)

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

(25)

Hamming‐Distanz

Hamming‐Distanz d(v₁, v₂) zwischen zwei n‐Bit‐Sequenzen v₁ und v₂

Beispiel: vier 4‐Bit‐Sequenzen mit einer paarweisen Hamming‐Distanz von

mindestens 2

Wieviele Bit‐Fehler können erkannt werden?

(26)

Allgemein:

Ablauf der Übertragung im Falle keiner Bitfehler

Block‐Codes

Datenblock Codewort 00 -> 00000 01 -> 00111 10 -> 11001 11 -> 11110

Erkennen von Bit‐Fehlern: Es sei Code = {b₁,...,b_k} und es werde b empfangen:

Sender

Empfänger

f : Datenblock

^

Codewort

(27)

Korrigieren von Bit‐Fehlern: Es sei Code = {b

₁

,...,b

_k

} und es werde b empfangen:

Korrigieren von Bitfehlern

Empfangen Nächstes gültiges CW Daten

Datenblock Codewort

00 -> 00000 01 -> 00111 10 -> 11001 11 -> 11110

(28)

Für k Daten‐Bits und n‐Bit Code‐Wörter gilt

Eindeutiges C‐Wort für jeden D‐Block, also

Benötigte Anzahl gültiger Code‐Wörter

Redundante Bits und Code‐Redundanz

Code‐Rate

Code‐Distanz für Code {b₁,...,b_k}

Benötigtes Verhältnis zwischen k und r=n‐

k zum Korrigieren von allen 1‐Bit‐Fehlern?

(29)

Hamming‐Code

1 2 3 4 5 6 7 8 9 10 11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

(30)

Erkennen eines Ein‐Bit‐Fehlers

0 0 1 1 0 0 1

1 2 3 4 5 6 7 8 9 10 11

0 0 0 0

0 0 1 1 0 1 1 0 0 0 0

Original Code‐Wort Ein‐Bit‐Fehler

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Check Ergebnis

Daten‐Bits Check‐Bits

(31)

Hamming‐Code erreicht die Schranke

Wie eben für k Daten‐Bits und n‐Bit Code‐Wörter ausgerechnet:

Benötigtes Verhältnis zwischen k und r=n‐k zum Korrigieren von allen 1‐Bit‐

Fehlern:

r+k+1 ^≤ 2 ^r

Beispiel für unten abgebildeten Hamming‐Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Daten‐Bits Check‐Bits Was wenn Daten nur bis 11?

(32)

Umgang mit Bit‐Fehler‐Bursts

Bildquelle: Andrew S. Tanenbaum, „Computer Networks“, Fourth Edition, 2003

Also:

(33)

Fakten zu allgemeinen Block‐Codes

Code‐Distanz von d_min = 2t+1 kann bis zu wie viele c‐Bit‐Fehler korrigieren?

Und wie viele d‐Bit‐Fehler erkennen?

Also: Code‐Distanz von d_minerlaubt Korrektur von bis zu wie vielen Fehlern?

Und Erkennen von wie vielen Fehlern?

(34)

Coding‐Gain

coding gain

(35)

Flusskontrolle

(36)

Stop‐and‐Wait

Es sei t_p der Propagation‐Delay und t_f die Transmission‐Time für einen Frame. Die Gesamtzeit T für n Frames ist:

Die Utilization U (d.h. Zeit für Daten in

Relation zur Zeit für Daten plus Overhead) ist:

Definiere a = t_p / t_f (d.h. normalisiere t_f auf 1), dann ist:

(37)

Utilization in Abhängigkeit von a

Utilization

a = Propagation‐Delay / Transmission‐Time

Beispiel: 1 Mbps Satelliten‐Link und 1000 Bit Frame mit 100ms Propagation‐Delay:

(38)

Sliding‐Window‐Protokoll

Sender Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6

…

Empfänger

Window

Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6

…

• Sender‐Fenster: Frames, die versendet werden dürfen (SWS= Sender‐Fenster‐Größe; hier z.B. 4)

• Empfänger‐Fenster: Frames die erwartet werden (RWS = Empfänger‐Fenster‐Größe ; hier z.B. 4)

• Jedes Frame hat eine Frame‐Nummer

• Empfang der am weitesten links stehenden Frames rückt Empfänger‐Fenster vor

• Empfangene Frames werden vom Sender mittels ACK (mit dessen Frame‐Nummer+1) bestätigt

• Empfang von Bestätigungen (ACKs) des Empfängers rückt das Sender‐Fenster vor

• Bitbegrenzung: Frame‐Nummern wiederholen sich irgendwann (modulo 2^k bei k Bits)

• ACKs können kumulativ sein, d.h. nicht jedes empfangene Frame muss bestätigt werden. ACK bestätigt ab der Frame‐Nummer den Empfang aller vorigen Frames mit.

(39)

Sliding‐Window‐Protokoll: Details

(40)

Sliding‐Window‐Protokoll: Beispiel

Bildquelle: William Stallings, „Data and Computer Communications“, 2004 RR = „receive ready“

(41)

Utilization – Fall 1: W ^≥ 2a + 1

Fenstergröße = W, Frame‐Transmission‐Time = 1 und normalisierter Propagation‐Delay = a (a sei ganzzahlig). Was ist die Utilization U in diesem Fall?

(42)

Utilization – Fall 2: W < 2a + 1

Was ist die Utilization U in diesem Fall?

(43)

Utilitzation

Erinnerung: Satelliten‐

Link‐Beispiel: a = 100

Utilization

(44)

Fehlerkontrolle

(45)

Automatic‐Repeat‐Request (ARQ)

Fehlerfälle

Fehlerdetektion

Positive‐Acknowledgment

Retransmission nach Timeout

Negative‐Acknowledgment und Retransmission

Techniken

Bildquelle: William Stallings, „Data and Computer Communications“, 2004 lost frame

damaged frame

(46)

Fehlerkontrolle

Stop‐and‐Wait ARQ

(47)

Stop‐and‐Wait ARQ

Grundlagen der Rechnernetze ‐Übertragungssicherung 47 Bildquelle: William Stallings, „Data and Computer Communications“, 2004

(A) Lost/Damaged Frame (B) Lost ACK

(48)

Utilization von Stop‐and‐Wait ARQ

Es sei p Paket‐Fehlerrate. Was ist die erwartete Anzahl N der Übertragungsversuche?

Es sei t_p der Propagation‐Delay und t_f die Transmission‐Time. Was ist die Utilization U?

Mit a = Propagation‐Delay/Transmission‐Time erhält man:

(49)

Utilization in Abhängigkeit von a

Utilization

Link‐Beispiel: a = 100 p=10^‐1

p=10^‐2

p=10^‐3

(50)

Fehlerkontrolle

Go‐Back‐N und Relective‐Reject ARQ

(51)

ARQ mittels Sliding‐Window‐Verfahren

Betrachten Sliding‐Window‐Verfahren

Frames können jedoch defekt sein oder verloren gehen

Wie bisher besprochen: Frames werden mit RR (receive ready) bestätigt (diese sind kumulativ)

Zusätzlich

•

Empfangenes Frame mit Fehler oder empfangenes Frame mit fehlenden Frames davor wird durch REJ (reject) abgelehnt

•

Empfänger verwirft alle nachfolgenden Frames, bis das fehlerhafte Frame korrekt empfangen wurde

•

Somit: Sender muss bei REJ‐Empfang ab dort alle Frames erneut senden Das ist die Go‐Back‐N‐Variante (die Alternative Selective‐Reject folgt gleich) Wie bei Stop‐and‐Wait: bei keiner Bestätigung wiederholt der Sender die letzte Übertragung nach einem Timeout

Betrachten im folgenden Go‐Back‐N‐ARQ unter allen möglichen Eventualitäten

(52)

Go‐Back‐N ARQ

Fall: Frame(i) ist Damaged oder Lost:

B macht nichts

1. Fall: A sendet Frame(i+1)

B empfängt Out-of-Order Frame(i+1) B sendet REJ(i)

A muss Frame(i) und nachfolgende reübertragen

2. Fall: A sendet zunächst nicht Timer von A läuft ab

A sendet RR(„mit P-Bit=1“) B muss mit RR(i) antworten

A sendet bei Empfang von RR(i) (Alternative zu Fall 2: A sendet

Frame(i) nach Ablauf des Timers)

(53)

Go‐Back‐N ARQ

Fall: Frame(i) ist Damaged oder Lost:

B macht nichts

1. Fall: A sendet Frame(i+1)

B empfängt Out-of-Order Frame(i+1) B sendet REJ(i)

A muss Frame(i) und nachfolgende reübertragen

2. Fall: A sendet zunächst nicht Timer von A läuft ab

A sendet bei Empfang von RR(i) (Alternative zu Fall 2: A sendet

Frame(i) nach Ablauf des Timers)

Timeout

(54)

Go‐Back‐N ARQ

Fall: RR(i) ist Damaged oder Lost:

1. Fall: A empfängt ein späteres RR(j) (Erinnerung ACKs sind kumulativ)

A weiß, dass Frame(i),...,Frame(j-1) korrekt angekommen sind

A macht weiter wie bisher 2. Fall: Timer von A läuft ab

A versucht wiederholt:

(mit einem P-Bit-Timer)

Wenn nach einigen Versuchen keine Antwort, dann startet A eine Reset-Prozedur

(55)

Go‐Back‐N ARQ

Fall: RR(i) ist Damaged oder Lost:

1. Fall: A empfängt ein späteres RR(j) (Erinnerung ACKs sind kumulativ)

A weiß, dass Frame(i),...,Frame(j-1) korrekt angekommen sind

A macht weiter wie bisher 2. Fall: Timer von A läuft ab

A versucht wiederholt:

(mit einem P-Bit-Timer)

Wenn nach einigen Versuchen keine Antwort, dann startet A eine Reset-Prozedur

(56)

Go‐Back‐N ARQ

Fall: REJ ist Damaged oder Lost:

Timer von A läuft ab

A sendet RR(„mit P-Bit=1“)

B muss mit RR(i) oder REJ antworten A sendet bei Empfang von RR(i)

Timeout

*

(57)

Piggybacking

A

B

Annahme beide Stationen A und B senden und empfangen mittels Sliding‐Window

• A ‐> B : Sendefenster von A und Empfangsfenster von B

• B ‐> A : Sendefenster von B und Empfangsfenster von A

Somit jede Seite sendet Frames, die von der anderen Seite bestätigt werden müssen Piggybacking: Jedes Daten‐Frame von A nach B hat im Header

• ein Feld für die Nummer des gesendeten Frames von A sowie

• ein Feld zur Bestätigung der empfangenen Frames von B

Bestätigungen (ACKs) können damit auf folgende Weise versendet werden

• Bei gleichzeitig zu versendendem Daten‐Frame: im ACK‐Feld des Daten‐Frame

• Bei aktuell keinen zu versendenden Daten: verwende separate ACK‐Nachricht (Nachricht mit leerem Datenfeld)

Bei zu versendendem Daten‐Frame aber aktuell keinem zu versendendem ACK: setze in das ACK‐Feld den zuletzt versendeten ACK‐Wert (Empfänger ignoriert dieses duplizierte ACK)

1 1

Frame 1 Frame 2

Sequenznummer der versendeten Frames

Sequenznummer der des nächsten erwarteten Frames

2 1

Frame 3

3 1 1 4

Frame 1

2 4

Frame 2

3

(58)

Maximal erlaubte Window‐Größe?

A

B

A

B

* * * * * * *

Piggybacked ACK in Übertragung von B nach A

Damit ist für k Bit Sequenznummern die maximal erlaubte Window‐Größe s_max:

Sequenznummerngröße sei 3 Bits; Annahme wir nutzen die volle Window‐Größe 8

Antwort auf

RR (P‐Bit=1) oder

(59)

Reübertragung von Frames mit negative ACK

Reübertragung von Frames mit Timeout

Selective‐Reject ARQ

Auch hier Piggybacking anwendbar, wenn in beide Richtungen kommuniziert werden soll.

Buffered by receiver

(60)

Verwendung der Window‐Größe 2 ^k ‐1?

A

B

*

Timeout

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Window von B

A

B

*

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Window von B

(61)

Maximal erlaubte Window‐Größe?

Lösung: mache Fenster kleiner, so dass keine Überlappungen vorhanden sind.

Also, damit ist für k Bit Sequenznummern die maximal erlaubte Window‐Größe s_max: 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 …

Empfänger‐Fenster

Problem: nicht vorgerücktes Sender‐Fenster und vorgerücktes Empfänger‐Fenster überlappen (d.h. haben gemeinsame Sequenznummern)

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Sender‐Fenster

(62)

Fehlerkontrolle

Utilization von Go‐Back‐N und Relective‐Reject

(63)

Utilization von Go‐Back‐N und Selective‐Reject

Allgemeine Beobachtung:

U = Utilization eines Verfahrens ohne Berücksichtigung von Paketverlusten U_e

= Utilization eines Verfahrens mit Berücksichtigung von Paketverlusten

t_f

= Transmission‐Time für ein Paket

t_o

= gesamt benötigte Zeit für eine Paketübertragung (d.h. inklusive Delays)

n

= Anzahl übertragener Pakete

k

= Erwartete Anzahl an Paketwiederholungen pro Paket bis zum Erfolgsfall

Es gilt:

(64)

Utilization bei Selective‐Reject ARQ

Wir hatten für Sliding‐Window ohne Fehler die Utilization U schon hergeleitet:

(mit W = Fenstergröße, a = Propagation‐Delay / Transmission‐Delay)

Mit voriger Beobachtung erhält man für a = Propagation‐Delay/Transmission‐Time und U_e = Utilization mit Berücksichtigung von Paket‐Verlusten:

Wir hatten für Paketfehlerrate p die erwartete Anzahl k der Übertragungsversuche schon hergeleitet:

(65)

Utilization bei Go‐Back‐N ARQ

Es sei m die Anzahl zu übertragender Frames, wenn ein Frame reübertragen werden muss.

Es sei p die Paketfehlerrate.

1.) Gesamtanzahl Reübertragungen f(i), wenn ein Frame iVersuche brauchte:

2.) Erwartete Gesamtanzahl k an Reübertragungen für ein Frame:

3.) Somit ergibt sich mit voriger Beobachtung für a = Transmission‐Time/Propagation‐Delay und U_e = Utilization mit Berücksichtigung von Paket‐Verlusten:

Wir hatten für Sliding‐Window ohne Fehler die Utilization U schon hergeleitet:

(mit W = Fenstergröße, a = Propagation‐Delay / Transmission‐Delay)

(66)

Utilization bei Go‐Back‐N ARQ

m für W ≥ 2a + 1:

Also, gemäß voriger Folie:

(67)

Utilization bei Go‐Back‐N ARQ

m für W < 2a + 1:

Also, gemäß voriger Folie:

(68)

Utilization

Vergleich für p=10 ^‐3

Link‐Beispiel: a = 100

(69)

Framing

(70)

Problemstellung

100010110111011011011101…

Frame 1 Frame 2 Frame 3 Frame 4

Link‐Layer Link‐Layer

Physical Layer Physical Layer

Upper Layers Upper Layers

(71)

Asynchron

• Kurze Folge von Bits mit Pausen dazwischen; Pausen trennen die Bitblöcke

• Einfache Synchronisation zwischen Sender und Empfänger

(Timing für Sampling wird am Empfänger für jeden Bitblock neu synchronisiert)

• Nachteil: großer Overhead (z.B. hier 1‐2 ungenutzte Stop‐Bits auf 5‐8 Bit Daten) Synchron

• Lange Folge von Bits in einem Frame (Synchronisationsmethoden schon besprochen)

• Frames folgen aufeinander. Beginn und Ende von Frames muss erkennbar sein

• Methode 1: Character‐Count

• Methode 2: Präambel und Postambel (auf Byte oder auf Bit‐Ebene)

Grundlagen der Rechnernetze ‐Übertragungssicherung

71 Bildquelle: William Stallings, „Data and Computer Communications“, 2004

Asynchrone versus Synchrone Übertragung

(72)

Framing

Synchrone Übertragung mittels Character‐Count, Byte‐ und Bit‐Stuffing

(73)

Character‐Count

Beispiel für Character‐Count‐Verfahren ohne Übertragungsfehler

Beispiel für Fehler bei Character‐Count‐Verfahren aufgrund von Übertragungsfehler

(74)

Flag‐Bytes und Byte‐Stuffing

(75)

Start‐ und End‐Flags mit Bit‐Stuffing

Frames beginnen und enden mit speziellem Bit‐Pattern: z.B. 01111110

01111110 | Header | Payload | Trailer | 01111110

(76)

Framing

Beispiel für synchrone Übertragung mittels Enoding‐Violations

(77)

Erinnerung: NRZ und das Clocking‐Problem

00111010101000000000000000000000000000000000000000000 Daten

Signal Sender

Sampling Empfänger

Zeit

Clock‐Drift Zeit Clock‐Synchronization

Bildquelle: William Stallings, „Data and Computer Communications“, Seventh Edition, 2004

(78)

4B/5B

...

Data 5‐Bit‐Code 0000 11110 0001 01001 0010 10100 0011 10101 0100 01010 0101 01011 0110 01110 0111 01111 1000 10010 1001 10011 1010 10110 1011 10111 1100 11010 1101 11011 1110 11100 1111 11101

(79)

Zusammenfassung und Literatur

(80)

Zusammenfassung

• Behandlung von Fehlern bei der Bitübertragung

– Fehlerdetektion versus Vorwärtsfehlerkorrektur – Hamming‐Distanz

– Block‐Codes

– Tradeoff zwischen Code‐Länge und Redundanz – Fehlerkontrolle

• Behandlung von Synchronisationsfehlern

– Flusskontrolle

– Framing

(81)