Notes

Computer Networks
Data Link Layer

Paolo Costa
[email protected]
http://www.cs.vu.nl/costa
Vrije Universiteit Amsterdam

(Version May 9, 2008)

Paolo Costa

03 - Data Link Layer

1 / 55

Data Link Layer

Notes

Physical: Describes the transmission of raw bits in terms of

mechanical and electrical issues.
Data Link: Describes how a shared communication channel can
be accessed, and how a data frame can be reliably transmitted.
Network: Describes how routing is to be done. Mostly needed in
subnets.
Transport: The hardest one: generally offers connection-oriented
as well as connectionless services, and varying degrees of
reliability. This layer provides the actual network interface to
applications.
Application: Contains the stuff that users see: e-mail, remote
logins, the Webs exchange protocol, etc.

Note
Well just concentrate on transmission issues. Channel access is
discussed in Chapter 4
Paolo Costa

03 - Data Link Layer

Introduction

2 / 55

Design Issues

Notes

Provide well-defined interface to network layer

Handle transmission errors

Regulate flow of data: get sender and receiver in the same pace
Paolo Costa

03 - Data Link Layer

Design Issues

3 / 55

Basic Services

Notes

Network layer passes a number of bits (frame) to the data link

layer.
Data link layer is responsible for transmitting the frame to the
destination machine.
Receiving layer passes received frame to its network layer.
Basic services commonly provided:
unacknowledged connectionless service (LANs)
acknowledged connectionless service (Wireless systems).
acknowledged connection-oriented service (WANs).

Question
Why are we so concerned about error-free frame transmissions?
Cant the higher layers take care of that?
Its not mandatory but it may improve efficiency (fine-grained
recovery: frames vs. messages)
Paolo Costa

03 - Data Link Layer

Design Issues

4 / 55

Transmission

Notes

The actual transmissions follow the path of (b) but it is easier to

think in terms of two data link process communicating using a
data link protocol (a)
Paolo Costa

03 - Data Link Layer

Design Issues

5 / 55

Routing

Notes

The network layer consists of routing

they are connected through point=to-point links

The router would really its packet to be sent correctly, guaranteed,

and in the order it was issued.
It is up to the data link to make unreliable connections look
perfect, or at least, fairly good
Paolo Costa

03 - Data Link Layer

Design Issues

6 / 55

Frames

Notes

Counting

The physical layer doesnt do much: it just pumps bits from one
end to the other.
But things may go wrong
the data link layer needs a means to do retransmissions.

The unit of retransmission is a frame (which is just a fixed number

of bits).
Problem: How can we break up a bit stream into frames?
naive solution: counting

(a) Without errors

Paolo Costa

(b) With errors

03 - Data Link Layer

Design Issues

7 / 55

Frames

Notes

Byte Stuffing

Byte stuffing: Mark the beginning and end of a byte frame with two
special flag bytes a special bit sequence (e.g. 01111110). If
such bytes appear in the original frame, escape them:

Paolo Costa

03 - Data Link Layer

Design Issues

8 / 55

Frames

Notes

Bit Stuffing

Byte stuffing is closely tied to the use of 8-bit character

Solution
Bit stuffing: Escape the flag byte (e.g., 01111110) through an
additional bit
whenever the senders data link encounters five consecutive 1s in
the data, it automatically stuffs a 0 bit

(a) frame to send

(b) frame transmitted over the wire

Paolo Costa

(c) reconstructed frame

03 - Data Link Layer

Design Issues

9 / 55

Error Correction and Detection

Notes

Problem: Suppose something went wrong during frame

transmission. How do we actually notice that somethings wrong,
and can it be corrected by the receiver?
Definition: The Hamming distance between two frames ~a and ~b is
the number of bits at the same position that differ.

Example
10001001 and 10110001 are at Hamming distance 3
1 0 0 0 1 0 0 1
1 0 1 1 0 0 0 1 XOR
0 0 1 1 1 0 0 0
To detect d errors, you need a distance d + 1 code
d-single bit errors cannot change a valid codeword in another

To correct d errors, you need a distance 2d+1 code

this way, even with 2d changes, the original codeword is still closer
that any other codeword
Paolo Costa

03 - Data Link Layer

Error Control

10 / 55

Error Detection

Notes

Parity

Add a bit to a bit string such that the total number of 1-bits is even
(or odd)
e.g., (even parity) 1011010 10110100
(odd parity) 1011010 10110101

The distance between two (legal) frames is at least d = 2.

any single-bit error produces a code word with the wrong parity

We can detect a single error (i.e., k = 1 and d = 2)

remember that to detect d errors, you need a distance d+1 code

Paolo Costa

03 - Data Link Layer

Error Control

11 / 55

Error Correction

Notes

Example

Consider a code with only four valid codewords:

1
2
3
4

0000000000
0000011111
1111100000
1111111111

This code has distance 5

The XOR between any pair of the above codeword gives at least
five 1 bits
it means it can correct double errors
remember that to correct d errors, you need a distance 2d+1 code

E.g., if the codeword 0000000111 is received, the receiver knows

that the original must have been 0000011111
If, however, a triple error changes 0000000000 into 0000000111,
the error will not be corrected properly
Paolo Costa

03 - Data Link Layer

Error Control

12 / 55

Error Correction

Notes

Lower Bound

Problem: we want to design a code with m message bits and r

check bits to correct all single errors
Each of the 2m legal messages has n illegal codewords at
distance 1
these are obtained by systematically change each of the n bits in
the n-bit codeword

Each of the 2m legal messages require n + 1 bit patterns

dedicated to it
The total number of bit pattern is 2n
n=m+r

(n + 1)2m 2n

(m + r + 1) 2r

Given m, it is possible to have a lower bound to the number r of

check bits needed to correct single errors

Paolo Costa

03 - Data Link Layer

Error Control

13 / 55

Error Correction: Hamming

Notes

Definition

The theoretical lower limit can be achieved using a method due to

Hamming (1950)
Enumerate all bits in a codeword starting with bit 1 at the left
The bits at position 2k (k 0) are check bits, the rest (3,5,6,7,. . . )
are filled with the m data bits
Every check bit is used as a parity bit for those positions to which it
contributes
b1
X

1
2
4
8

b2
X

b3
X
X

b4

b5
X

b6

b7
X
X
X

X
X

b8

b9
X

b10

b11
X
X

Rewrite every data bit as sums of power of 2

e.g., 7 = 1 + 2 + 4 and 11 = 1 + 2 + 8

A bit is checked by just those bits occurring in its expansion

e.g., bit 11 is checked by bit 1, 2, and 8
Paolo Costa

03 - Data Link Layer

Error Control

14 / 55

Error Correction: Hamming

Notes

Coding

b1
X

1
2
4
8

b2
X

b3
X
X

b4

b5
X

X
X

b7
X
X
X

b6

b8

X
1

b9
X

X
0

b10
X

b11
X
X

X
0

X
1

Check bits are used to even out the number of 1 bits they
contribute to
e.g., assume the message is 1100001
Check bit at position 2, is used to even out the bits for positions 2,
3, 6, 7, 10, and 11
b2 = 0 as the number of 1s is even (b3 and b11)

Other check bits are computed in the same way

The final codeword is 1011100101
Paolo Costa

03 - Data Link Layer

Error Control

15 / 55

Error Correction: Hamming

Notes

Decoding

If a check bit at position p is wrong upon receipt, the receiver

increments a counter v with p
The value of v will, in the end, give the position of the wrong bit,
which should then be swapped. E.g.:
1
2
4
8

b1
X

b2
X

b3
X
X

b4

b5
X

b6

X
X

b7
X
X
X

b8

b9
X

b10
X

b11
X
X
X

S:

R:

C:

F:

S: string sent
R: string received
C: string corrected on the check bits: #1 and #8 corrected bit #9 is wrong
(v = 1 + 9)
F: final result after correction
Paolo Costa

03 - Data Link Layer

Error Control

16 / 55

Error Correction: Hamming

Notes

Burst Errors

Hamming codes can only detect single errors

However, there is a trick to correct burst errors
A sequence of k codewords
are arranged as a matrix, one
codeword per row
Data are transmitted one
column at a time
If a burst error of length k
occurs, at most 1 bit per
codeword is affected
Hamming code can correct
one error per codeword
the entire block can be
restored
Paolo Costa

03 - Data Link Layer

Error Control

17 / 55

Error Detection

Notes

CRC

Error correcting codes are simply too expensive

e.g., for 10,000 bit blocks, 10 check bits are needed
only use error detection combined with retransmissions

Cyclic Redundancy Check (CRC), a.k.a. polynomial code, is

based upon treating bit strings as polynomials with coefficient of 0
and 1 only
a k -bit frame is regarded as the coefficient list for a polynomial with
k terms, from x k 1 to x 0
e.g., a 6-bit block
M(x)

mk 1 x k 1 + . . . + m1 x 1 + m0 x 0

110001 1x 5 + 1x 4 + 0x 3 + 0x 2 + 0x 1 + 1x 0
=

x5 + x4 + 1

Polynomial arithmetic is done in modulo 2, according to the rule of

algebraic field theory
Paolo Costa

03 - Data Link Layer

Error Control

18 / 55

Polynomial Arithmetic

Notes

Addition and Subtraction

Since the coefficients are constrained to a single bit, any math

operation on CRC polynomials must map the coefficients of the
result to either 0 or 1
Addition
(x 3 + x) + (x + 1) = x 3 + 2x + 1 x 3 + 1
note that 2x becomes zero because addition of coefficient is done
modulo 2
2x = x + x = (1 + 1)x = 0x = 0
analogous to exclusive OR (XOR)
1010 0011 1001

Subtraction
works like addition (only absolute values are used)
(x 4 + x 2 + 1) (x + 1) = x 4 + x 2 x x 4 + x 2 + x
Paolo Costa

03 - Data Link Layer

Error Control

19 / 55

Polynomial Arithmetic

Notes

Multiplication and Division

Multiplication
It follows the rule of traditional polynomials but, again, addition of
coefficient is done module 2
(x 2 + x)(x + 1) = x 3 + x 2 + x 2 + 1 = x 3 + 2x 2 + 1 x 3 + 1

Division
we can also divide polynomials mod 2 and find the quotient and
remainder
x3 + x2 + x
1
= (x 2 + 1)
x +1
x 1
or in other words:
(x 3 + x 2 + x) = (x 2 + 1)(x + 1) 1

Paolo Costa

03 - Data Link Layer

Error Control

20 / 55

CRC

Notes

Algorithm

Lets go back our problem

Sender and receiver agree upon a generator polynomial G(x)
both the high- and low-order bits of the generator must be 1
the frame M(x) must be longer than the generator (m > r )

Idea: append a checksum to the end of the frame in such a way

that the polynomial obtained is divisible (i.e., no remainder) by
G(x)
when the receivers gets the checksummed frame, it tries dividing it
by G(x)
if there is a remainder, there has been a transmission error

Algorithm
1

append r zero bits to the low order of the frame

divide x r M(x) by G(x)

subtract (mod 2) the remainder from x r M(x). The result is the
checksummed frame T (x) to be transmitted

now it contains m + r bits and corresponds to x r M(x)

3

Paolo Costa

03 - Data Link Layer

Error Control

21 / 55

CRC

Notes

Division Example

Check the input bit above the

leftmost divisor
If it is 0, do nothing
If it is 1, the divisor is
XORed into (i.e., subtracted
from) the input

Move the divisor to the right by

one bit

The process is repeated until

the divisor reaches the
right-hand end of the input row

The left bits are the remainder

of the division to be appended
to the frame
Paolo Costa

03 - Data Link Layer

Error Control

22 / 55

CRC

Notes

Decoding

If a transmission error occurs, instead of the original polynomial

T (x),T (x) + E(x) arrives
each 1 bit in E(x) corresponds to a bit that has been inverted
if there are k 1 bits in E(x), k single bit errors have occurred
E(x) is characterized by an initial 1, a mixture of 0s and 1s, and a
final 1

The receiver divided the received frame by G(x), i.e.,

[T (x) + E(x)]/G(x) and computes the remainder
in case of error, the remainder will be E(x)/G(x)

If there is a single-bit error, E(x) = x i (being i the position of the

wrong bit)
if G(x) contains two or more terms, it will never divide E(x) all
single-bit errors will be detected
the simplest error-detection system, the parity bit, is in fact a trivial
CRC: it uses the two-bit-long divisor 11
Paolo Costa

03 - Data Link Layer

Error Control

23 / 55

CRC

Notes

Burst Error

By carefully choosing G(x), burst errors can be correctly detected

a burst error is a contiguous sequence of bits, containing wrong bits

It can be shown, that a polynomial code with r check bits, will

detect all bursts errors of length r
If the burst length is r + 1, the probability of accepting an incorrect
frame is 2r11
It can also be shown that for bursts longer than r + 1 bit, such
probability becomes 21r , assuming that all bit patterns are equally
likely (not always true)
Certain polynomial have become standards
e.g., the one used in IEEE 802 (Wi-Fi) is:
x 32 +x 26 +x 23 +x 22 +x 16 +x 12 +x 11 +x 10 +x 8 +x 7 +x 5 +x 4 +x 2 +x 1 +1
it detects all bursts of length 32 or less and all bursts affecting an
odd number of bits
Paolo Costa

03 - Data Link Layer

Error Control

24 / 55

CRC

Notes

Applications

CRC is not used by the data link layer but also by applications to
check the correctness of a given file
e.g., WinZip

Paolo Costa

03 - Data Link Layer

Error Control

25 / 55

Data Link Layer Protocols

Notes

Concentrated on design aspects and error control

frame size (stuffing)
error correction (Hamming Code)
error detection (CRC)

Now: basic protocols and real-world examples

Some basic assumptions:
We have a machine A that wants to send data to machine B
There is always enough data for A to send
There is a well-defined interface to the network layer, and to the
physical layer
void
void
void
void

from_network_layer(packet *)
to_network_layer(packet *)
from_physical_layer(packet *)
to_physical_layer(packet *)

The receiver generally waits for an event to happen by calling

void wait_for_event(event_type *event)
Paolo Costa

03 - Data Link Layer

Basic Protocols

26 / 55

Unrestricted Simplex Protocol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

typedef
typedef
typedef
typedef

Notes

enum {false, true} boolean;

unsigned int seq_nr;
struct {unsigned char data[MAX_PKT];} packet;
enum {data, ack, nak} frame_kind;

typedef struct {
frame_kind kind;
seq_nr seq;
seq_nr ack;
packet info;
} frame;

/*
/*
/*
/*

what kind of a frame is it? */

sequence number */
acknowledgment number */
the network layer packet */

typedef enum {frame_arrival} event_type;

void sender1(void){
frame s; packet buffer;
while (true) {
from_network_layer(&buffer);
s.info = buffer;
to_physical_layer(&s);
}
}
void receiver1(void){
frame r; event_type event;
while (true) {
wait_for_event(&event);
from_physical_layer(&r);
to_network_layer(&r.info);
}
}
Paolo Costa

03 - Data Link Layer

Basic Protocols

27 / 55

Unrestricted Simplex Protocol

Notes

Issues

Question
What are some of the underlying assumptions here? How does
the flow control manifest itself?
Underlying assumptions are error-free transmission, and
sender-receiver are in pace.
Issue: Fast senders would make receivers collapse

Question
Would a simple delay on senders side fix the problem ?
Not really! Its hard to predict when receivers congestion may
occur.
Assuming always the worst-case behavior would be highly
inefficient
Paolo Costa

03 - Data Link Layer

Basic Protocols

28 / 55

Simplex Stop-and-Wait
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Notes

typedef enum {frame_arrival} event_type;

#include "protocol.h"
void sender2(void){
frame s; packet buffer;
event_type event;
while (true) {
from_network_layer(&buffer);
s.info = buffer;
to_physical_layer(\&s);
wait_for_event(&event);
}
}
void receiver2(void){
frame r, s; event_type event;
while (true) {
wait_for_event(&event);
from_physical_layer(\&r);
to_network_layer(&r.info);
to_physical_layer(&s);
}
}

Here the receiver provide the feedback to the sender

it sends a little dummy packet (acknowledgment) back to the sender

After having sent a frame, the sender is required to wait for the ack
Paolo Costa

03 - Data Link Layer

Basic Protocols

29 / 55

Simplex Protocol for Noisy Channel

Notes

Question
What are the assumptions in this case? We are assuming only
error-free transmission.
Ok, so assume that damaged frames can be detected

Question
Idea: send the ack only upon correct receipt! Works ? No, because also
the ack can be lost.

Question
Second idea: let the sender use a timer by which it simply retransmits
unacknowledged frames after some time! Works ? No again! Because
the data link layer cannot detect duplicate transmissions.

Lets use sequence numbers!

Problem: sequence number cannot go on for ever and they wast space
Solution: no worries, we need just two (0 & 1)
Paolo Costa

03 - Data Link Layer

Basic Protocols

30 / 55

Simplex Protocol for Noisy Channel

Notes

Sender
next_frame_to_send indicates which is the last message sent
A timer is started after sending a message
Only if the correct ack is received, the next message is sent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#define MAX_SEQ 1
typedef enum {frame_arrival, cksum_err, timeout} event_type;
void sender3(void) {
int
next_frame_to_send;
frame
s;
packet
buffer;
event_type event;
next_frame_to_send = 0;
from_network_layer(&buffer);
while (true) {
s.info = buffer;
s.seq = next_frame_to_send;
to_physical_layer(&s);
start_timer(s.seq);
wait_for_event(&event);
if (event == frame_arrival) {
from_physical_layer(&s);
if (s.ack == next_frame_to_send) {
stop_timer(s.ack);
from_network_layer(&buffer);
inc(next_frame_to_send);
} } } }
Paolo Costa

03 - Data Link Layer

Basic Protocols

31 / 55

Simplex Protocol for Noisy Channel

Notes

Receiver

frame_expected enables filtering out duplicate

Its value is increased each time a frame is delivered to the
network layer
only two values (0 and 1) are needed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void receiver3(void) {
seq_nr frame_expected; frame r, s; event_type event;
frame_expected = 0;
while (true) {
wait_for_event(&event);
if(event == frame_arrival) {
from_physical_layer(&r);
if (r.seq == frame_expected) {
to_network_layer(&r.info);
inc(frame_expected);
}
s.ack = 1 - frame_expected;
to_physical_layer(&s);
}
}
}

Paolo Costa

03 - Data Link Layer

Basic Protocols

32 / 55

From Simplex to Duplex

Notes

Problem: We want to allow symmetric frame transmission

between two communicating parties, rather than transmission in
one direction.
dont waste channels, so use the same channel for duplex
communication.

Solution: Just transmit frames, but distinguish between data,

acknowledgments (acks), and possibly negative acks (nacks) in
the frames type field.
Idea: If the other party is going to send data as well, it might as
well send acknowledgments along with its data frames
piggybacking.

Question
Whats good and bad about piggybacking?
Good: save bandwidth.
Bad: poor performance with irregular transmission rate.
Paolo Costa

03 - Data Link Layer

Basic Protocols

33 / 55

Sliding Windows

Notes

Principle: Rather than just sending a single frame at a time, permit

the sender to transmit a set of frames, called the sending window.
a frame is removed from the sending window iff it has been
acknowledged.
the receiver has a receiving window containing frames it is
permitted to receive.

A damaged frame is kept in the receiving window until a correct

version is received. Also, frame N is kept in the window until frame
N-1 has been received.
if both window sizes equal one, we are dealing with the
stop-and-wait protocols.

Question
Is there a relationship between window size, transmission rate, and
propagation delay ? If the propagation delay is high and the window size
is small, transmission rate decreases dramatically because the sender
while waiting for acks cannot send new messages
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

34 / 55

Window Size & Sequence Number

(a) Initially
(c) After receiving frame #1.

Notes

(b) After sending frame #1.

(d) After receiving ack for frame #1

Question
How would you interpret the shaded areas?
Shaded area is to-be-acknowledged (at sender) and
to-be-received next (at receiver).
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

35 / 55

1-Bit Sliding Window

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Notes

void protocol4 (void) {

seq_nr next_frame_to_send, frame_expected;
frame r, s; packet buffer;
event_type event;
next_frame_to_send = 0; frame_expected = 0;
from_network_layer(&buffer);
s.info = buffer;
s.seq = next_frame_to_send;
s.ack = 1 - frame_expected;
to_physical_layer(&s); start_timer(s.seq);
while (true) {
wait_for_event(&event);
if (event == frame_arrival) {
from_physical_layer(&r);
if (r.seq == frame_expected){
to_network_layer(&r.info);
inc(frame_expected);}
if (r.ack == next_frame_to_send){
from_network_layer(&buffer);
inc(next_frame_to_send);}
}
s.info = buffer;
s.seq = next_frame_to_send;
s.ack = 1 - frame_expected;
to_physical_layer(&s); start_timer(s.seq);

next_frame_to_send

tells which frame the

sender is trying to
send
frame_expected
tells which frames the
receiver is expecting
If the received frame
is the one expected,
the frame is passed
to the network layer
If the received ack is
the one expected, the
next frame is sent

}
}
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

36 / 55

1-Bit Sliding Window

Notes

Simultaneous Transmissions

The notation is (seq, ack, packet number). * means: passed to network layer

All things go well, but behavior is a bit strange when A and B

transmit simultaneously.
We are transmitting more than once, just because the two senders
are more or less out of sync.
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

37 / 55

Error Control

Notes

Problem: What should the receiver do if a frame is damaged ?

Go back n
Simply request retransmission of all frames starting from frame
#N. If any other frames had been received in the meantime (and
stored in the receivers window), theyll just be ignored
Selective Repeat
Request just retransmission of the damaged frame, and wait until
it comes in before delivering any frames after that

Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

38 / 55

Error Control

Notes

Example

(a) Go back n
Paolo Costa

(b) Selective Repeat.

03 - Data Link Layer

Sliding Window Protocols

39 / 55

Error Control

Notes

Pros & Cons

Go-back-N is really simple: the sender keeps a frame in its

window until it is acknowledged.
if the window is full, the network layer is not allowed to submit new
packets.
the receiver hardly needs to keep an account on what happens: if a
frame is damaged, its successors in the receive window are
ignored.
it is equivalent to a receive window of size 1

Selective repeat seems to do better because frames arent

discarded, but the administration is much harder
it also requires large amounts of memory if the window is large

Trade-off between bandwidth and data link layer buffer space

Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

40 / 55

Go-back-n (1/2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Notes

#define MAX_SEQ 7 /* should be 2^n - 1 */

typedef enum {frame_arrival, cksum_err,
timeout, network_layer_ready} event_type;
#include "protocol.h"
static boolean between(seq_nr a, seq_nr b, seq_nr c) {
/* Return TRUE iff a <= b < c (cyclic) */
...
}
static void send_data(
seq_nr frame_nr, seq_nr frame_expected, packet buffer[]){
frame s;
s.info = buffer[frame_nr]; s.seq = frame_nr;
s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1);
to_physical_layer(&s); start_timer(frame_nr);
}
void protocol5(void) {
seq_nr next_frame_to_send, ack_expected, frame_expected;
frame r;
packet buffer[MAX_SEQ + 1];
seq_nr nbuffered, i;
event_type event;
enable_network_layer();
ack_expected = 0; next_frame_to_send = 0; frame_expected = 0;
nbuffered = 0;

enable_network_layer prevents network layer to input more frames when

there are MAX_SEQ unacknowledged frames
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

41 / 55

Go-back-n (2/2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Notes

while (true) {
wait_for_event(&event);
switch(event) {
case network_layer_ready:
from_network_layer(&buffer[next_frame_to_send]);
nbuffered = nbuffered + 1;
send_data(next_frame_to_send, frame_expected, buffer);
inc(next_frame_to_send);
break;
case frame_arrival:
from_physical_layer(&r);
if (r.seq == frame_expected) {
to_network_layer(&r.info);
inc(frame_expected); }
while (between(ack_expected, r.ack, next_frame_to_send)) {
nbuffered = nbuffered - 1;
stop_timer(ack_expected);
inc(ack_expected); }
break;
case cksum_err: break; /* just ignore bad frames */
case timeout: /* trouble; retransmit outstanding frames */
next_frame_to_send = ack_expected;
for (i = 1; i <= nbuffered; i++) {
send_data(next_frame_to_send, frame_expected, buffer);
inc(next_frame_to_send); }
}
if (nbuffered < MAX_SEQ)
enable_network_layer();
else
disable_network_layer();
} }
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

42 / 55

Go-back-n

Notes

Comments

An ack for frame n, automatically acknowledges also frames n-1,

n-2, etc.
Note that a maximum of MAX_SEQ frames and not MAX_SEQ + 1
frames may be outstanding
packet buffer[MAX_SEQ+1]
if nbuffered < MAX_SEQ
The reason is the following:
1
2
3

The sender sends frames 0 through 7

An ack for frame 7 comes back to the sender
The sender sends other eight frames with sequence number 0
through 7
Now another piggybacked ack for frame 7 comes in

Problem: Did all eight frames belonging to the second batch arrive
correctly or did all get lost ?
the sender has no way to detect it

Solution Restrict the maximum number of outstanding frames to

MAX_SEQ
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

43 / 55

Selective Repeat

Notes

Go-back-n works well if errors are rare, but if the line is poor, it
wastes a lot of bandwidth
An alternative strategy is to allow receiver to accept and buffer the
frames following a damaged or lost one
both sender and receiver maintain a window larger than 1
whenever a frame arrives, its sequence number is checked by the
function between to see if it falls within the window
however, it must be kept within the data link layer and not passed to
the network layer until all lower numbered frames are received

Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

44 / 55

Selective Repeat (1/3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Notes

static boolean between(seq_nr a, seq_nr b, seq_nr c) {...}

static void send_frame(frame_kind fk, seq_nr frame_nr,
seq_nr frame_expected, packet buffer[]){
frame s; s.kind = fk;
if (fk == data) s.info = buffer[frame_nr % NR_BUFS];
s.seq = frame_nr;
s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1);
if (fk == nak) no_nak = false;
to_physical_layer(&s);
if (fk == data) start_timer(frame_nr % NR_BUFS);
stop_ack_timer();
{
void protocol6(void){
seq_nr ack_expected, next_frame_to_send, frame_expected;
seq_nr nbuffered, too_far; event_type event;int i; frame r;
packet out_buf[NR_BUFS], in_buf[NR_BUFS];
boolean arrived[NR_BUFS];
enable_network_layer();
ack_expected = 0; next_frame_to_send = 0; frame_expected = 0;
too_far = NR_BUFS; nbuffered = 0;
for (i = 0; i < NR_BUFS; i++) arrived[i] = false;
while (true) {
wait_for_event(&event);
switch(event) {
case network_layer_ready:
nbuffered = nbuffered + 1;
from_network_layer(&out_buf[next_frame_to_send % NR_BUFS]);
send_frame(data,next_frame_to_send,frame_expected,out_buf);
inc(next_frame_to_send);
break;
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

45 / 55

Example: Selective Repeat (2/3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Notes

case frame_arrival:
from_physical_layer(&r);
if (r.kind == data) {
if ((r.seq != frame_expected) && no_nak)
send_frame(nak, 0, frame_expected, out_buf);
else start_ack_timer();
if (between(frame_expected, r.seq, too_far) &&
if(arrived[r.seq % NR_BUFS] == false)) {
arrived[r.seq % NR_BUFS] = true;
in_buf[r.seq % NR_BUFS] = r.info;
while (arrived[frame_expected % NR_BUFS]) {
to_network_layer(&in_buf[frame_expected % NR_BUFS]);
no_nak = true;
arrived[frame_expected % NR_BUFS] = false;
inc(frame_expected);
inc(too_far);
start_ack_timer(); }
}
}
if ((r.kind == nak) &&
if between(ack_expected, (r.ack+1) % (MAX_SEQ+1)
next_frame_to_send))
send_frame(data, (r.ack+1) % (MAX_SEQ + 1),
frame_expected,out_buf);
while (between(ack_expected, r.ack, next_frame_to_send)) {
nbuffered = nbuffered - 1;
stop_timer(ack_expected % NR_BUFS);
inc(ack_expected);
}
break;
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

46 / 55

Example: Selective Repeat (3/3)

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

Notes

case cksum_err:
if (no_nak) send_frame(nak, 0, frame_expected, out_buf);
break;
case timeout:
send_frame(data, oldest_frame, frame_expected, out_buf);
break;
case ack_timeout:
send_frame(ack,0,frame_expected, out_buf);
}
if (nbuffered < NR_BUFS) enable_network_layer();
else disable_network_layer();
}
}

Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

47 / 55

Selective Repeat

Notes

Comments

Frames need not be received in order,

we may have an undamaged frame N, while still waiting for an
undamaged version of N 1.

If the receiver delivers all frames in its window just after sending
an ack for the entire window, we may have a serious problem:
Station A
(window size = 4)
01234567

Station B
(window size = 5)

Send window
0 1 2 3 4 5 6 7 Receive 0-3
0 1 2 3 4 5 6 7 Advance window

01234567

Resend window
01234567

Frame #0 is
duplicate

Solution: we must avoid overlapping send and receive windows

the highest sequence number must be at least twice the window
size.
Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

48 / 55

Data Link Protocols

Notes

Demo

http://www.csi.uottawa.ca/~elsaddik/abedweb/applets/
Applets/Sliding_Window/sliding-window/index.html

Paolo Costa

03 - Data Link Layer

Sliding Window Protocols

49 / 55

Data Link Layer Protocols

Notes

Now lets take a look how point-to-point connections are supported in,
for example, the Internet.
Recall:
The data link layer is responsible for transmitting frames from
sender to receiver.
It can use only the physical layer, which supports only
transmission of a bit at a time.
The DLL has to take into account that transmission errors may
occur
error control (ACKs, NACKs, checksums, etc.)

The DLL has to take into account that sender and receiver may
operate at different speeds
flow control (windows, frame numbers, etc.)

Paolo Costa

03 - Data Link Layer

Examples

50 / 55

High-Level Data Link Control

Notes

HDLC: A pretty old, but widely used protocol for point-to-point

connections. Is bit-oriented.

HDLC uses a sliding window protocol with 3-bit sequencing

The control field is used to distinguish different kinds of frames
contains sequence numbers, acks, nacks, etc.

Question
What do we need the address field for? Useful on line with
multiple terminals
Paolo Costa

03 - Data Link Layer

Examples

51 / 55

Internet Point-to-Point Connections

Notes

This is what may happen when you have an Internet connection to

a provider:

Wed like to use the Internet protocol stack at our home (e.g.,
ADSL)
the bottom line is that well have to transfer IP (network) packets
across our telephone line

Issues:
how can we embed IP packets into frames ?
how can we unpacked at the other end ?
Paolo Costa

03 - Data Link Layer

Examples

52 / 55

PPP: Point-to-Point Protocol

Notes

PPP is the data link protocol for point-to-point connections with

respect to the Internet (home-ISP and router-to-router):
Proper framing, i.e. the start and end of a frame can be
unambiguously detected.
A separate protocol for controlling the line (setup, testing,
negotiating options, and tear-down) (LCP)
Supports many different network layer protocols, not just IP.
No need for fixed network addresses.

The default frame:

Address
Protocol
Checksum

(no data link addresses)

LCP / NCP / IP / . . .
(usually 2 bytes)

Paolo Costa

Control
Payload

no seq. number (no reliable transmission)

(up to a negotiated maximum)

03 - Data Link Layer

Examples

53 / 55

PPP

Notes

Connection Setup

Suppose you want to set up a true Internet connection to your provider.

1

Set up a physical connection through your modem

Your PC starts sending a number of Link Control Packets (LCP) to

negotiate the kind of PPP connection you want.
the maximum payload size in data frames
do authentication (e.g. ask for a password)
monitor the quality of the link (e.g. how many frames didnt come
through).
compress headers (useful for slow links between fast computers)

Then, we negotiate network layer stuff, like getting an IP address

that the providers router can use to forward packets to you.

Paolo Costa

03 - Data Link Layer

Examples

54 / 55

PPP

Notes

Example

Question
If an IP address is dynamically assigned, who does the assignment ? The
provider

Question
If an IP address is dynamically assigned, Can someone else ever send you data
(they dont know your address, do they?) We need to contact them first (our
address is included in the request).
Paolo Costa

03 - Data Link Layer

Examples

55 / 55

Notes