 UNIT 3.

The Data Link Layer

 In this chapter we will study the design principles for layer 2, the data link
layer. This study deals with the algorithms for achieving reliable, efficient
communication between two adjacent machines at the data link layer. By
adjacent, we mean that the two machines are connected by a communication
channel that acts conceptually like a wire (e.g., a coaxial cable, telephone
line, or point-to-point wireless channel
 At first you might think this problem is so trivial that there is no software to
study—machine A just puts the bits on the wire, and machine B just takes
them off. Unfortunately, communication circuits make errors occasionally.
Furthermore, they have only a finite data rate, and there is a nonzero
propagation delay between the time a bit is sent and the time it is received.
These limitations have important implications for the efficiency of the data
transfer. The protocols used for communications must take all these factors
into consideration
 DATALINKLAYERDESIGNISSUES
 •Services Provided to the Network Layer
 •Framing
 •Error Control
 •Flow Control
 After an introduction to the key design issues present in the data link layer,
we will start our study of its protocols by looking at the nature of errors, their
causes, and how they can be detected and correced
 Data Link Layer Design Issues
 The data link layer has a number of specific functions it can carry out. These
functions include
 1. Providing a well-defined service interface to the network layer.
 2. Dealing with transmission errors.
 3. Regulating the flow of data so that slow receivers are not swamped by fast
senders.
 To accomplish these goals, the data link layer takes the packets it gets from
the network layer and encapsulates them into frames for transmission. Each
frame contains a frame header, a payload field for holding the packet, and a
frame trailer, as illustrated in Fig. 3- Frame management forms the heart of
what the data link layer does.
Relationship between packets and frames.
 Services Provided to the Network Layer
 The function of the data link layer is to provide services to the network layer.
The principal service is transferring data from the network layer on the source
machine to the network layer on the destination machine.
 On the source machine is an entity, call it a process, in the network layer that
hands some bits to the data link layer for transmission to the destination.
 The job of the data link layer is to transmit the bits to the destination machine
so they can be handed over to the network layer there, as shown in Fig. 3-2(a).
 The actual transmission follows the path of Fig. 3-2(b), but it is easier to think in
terms of two data link layer processes communicating using a data link
protocol. For this reason, we will implicitly use the model of Fig. 3-2(a)
throughout this chapter.
Figure 3-2. (a) Virtual communication. (b) Actual
communication.
 The data link layer can be designed to offer various services. The actual
services offered can vary from system to system. Three reasonable
possibilities that are commonly provided are
 1. Unacknowledged connectionless service.
 2. Acknowledged connectionless service.
 3. Acknowledged connection-oriented service.
 Unacknowledged connectionless service consists of having the source
machine send independent frames to the destination machine without having
the destination machine acknowledge them. No logical connection is
established beforehand or released afterward. If a frame is lost due to noise on
the line, no attempt is made to detect the loss or recover from it in the data link
layer. This class of service is appropriate when the error rate is very low so that
recovery is left to higher layers. It is also appropriate for real-time traffic, such
as voice, in which late data are worse than bad data. Most LANs use
unacknowledged connectionless service in the data link layer.
 The next step up in terms of reliability is acknowledged connectionless service.
When this service is offered, there are still no logical connections used, but each
frame sent is individually acknowledged. In this way, the sender knows whether
a frame has arrived correctly. If it has not arrived within a specified time interval,
it can be sent again. This service is useful over unreliable channels, such as
wireless systems.
 It is perhaps worth emphasizing that providing acknowledgements in the data
link layer is just an optimization, never a requirement. The network layer can
always send a packet and wait for it to be acknowledged. If the
acknowledgement is not forthcoming before the timer expires, the sender can
just send the entire message again. The trouble with this strategy is that frames
usually have a strict maximum length imposed by the hardware and network
layer packets do not. If the average packet is broken up into, say, 10 frames,
and 20
 percent of all frames are lost, it may take a very long time for the packet to get
through. If individual frames are acknowledged and retransmitted, entire packets
get through much faster. On reliable channels, such as fiber, the overhead of a
heavyweight data link protocol may be unnecessary, but on wireless channels,
with their inherent unreliability, it is well worth the cost
 Getting back to our services, the most sophisticated service the data link layer
can provide to the network layer is connection-oriented service. With this
service, the source and destination machines establish a connection before
any data are transferred. Each frame sent over the connection is numbered,
and the data link layer guarantees that each frame sent is indeed received.
Furthermore, it guarantees that each frame is received exactly once and that
all frames are received in the right order. With connectionless service, in
contrast, it is conceivable that a lost acknowledgement causes a packet to be
sent several times and thus received several times. Connection-oriented
service, in contrast, provides the network layer processes with the equivalent
of a reliable bit stream.
 When connection-oriented service is used, transfers go through three distinct
phases. In the first phase, the connection is established by having both sides
initialize variables and counters needed to keep track of which frames have
been received and which ones have not. In the second phase, one or more
frames are actually transmitted. In the third and final phase, the connection is
released, freeing up the variables, buffers, and other resources used to
maintain the connection.
 Error Control
 Having solved the problem of marking the start and end of each frame, we
come to the next problem: how to make sure all frames are eventually
delivered to the network layer at the destination and in the proper order.
Suppose that the sender just kept outputting frames without regard to
whether they were arriving properly. This might be fine for unacknowledged
connectionless service, but would most certainly not be fine for reliable,
connection-oriented service.
 The usual way to ensure reliable delivery is to provide the sender with
some feedback about what is happening at the other end of the line.
Typically, the protocol calls for the receiver to send back special control
frames bearing positive or negative acknowledgements about the incoming
frames. If the sender receives a positive acknowledgement about a frame,
it knows the frame has arrived safely. On the other hand, a negative
acknowledgement means that something has gone wrong, and the frame
must be transmitted again.
 An additional complication comes from the possibility that hardware troubles
may cause a frame to vanish completely (e.g., in a noise burst). In this case,
the receiver will not react at all, since it has no reason to react. It should be
clear that a protocol in which the sender transmits a frame and then waits for
an acknowledgement, positive or negative, will hang forever if a frame is
ever lost due to, for example, malfunctioning hardware.
 This possibility is dealt with by introducing timers into the data link layer.
When the sender transmits a frame, it generally also starts a timer. The timer
is set to expire after an interval long enough for the frame to reach the
destination, be processed there, and have the acknowledgement propagate
back to the sender. Normally, the frame will be correctly received and the
acknowledgement will get back before the timer runs out, in which case the
timer will be canceled.
 However, if either the frame or the acknowledgement is lost, the timer will
go off, alerting the sender to a potential problem. The obvious solution is to
just transmit the frame again. However, when frames may be transmitted
multiple times there is a danger that the receiver will accept the same frame
two or more times and pass it to the network layer more than once. To
prevent this from happening, it is generally necessary to assign sequence
numbers to outgoing frames, so that the receiver can distinguish
retransmissions from originals.
 The whole issue of managing the timers and sequence numbers so as to
ensure that each frame is ultimately passed to the network layer at the
destination exactly once, no more and no less, is an important part of the
data link layer's duties
 Flow Control
 Another important design issue that occurs in the data link layer (and higher
layers as well) is what to do with a sender that systematically wants to
transmit frames faster than the receiver can accept them. This situation can
easily occur when the sender is running on a fast (or lightly loaded) computer
and the receiver is running on a slow (or heavily loaded) machine. The
sender keeps pumping the frames out at a high rate until the receiver is
completely swamped. Even if the transmission is error free, at a certain point
the receiver will simply be unable to handle the frames as they arrive and will
start to lose some. Clearly, something has to be done to prevent this
situation.
 Two approaches are commonly used. In the first one, feedback-based flow
control, the receiver sends back information to the sender giving it
permission to send more data or at least telling the sender how the receiver
is doing. In the second one, rate-based flow control, the protocol has a built-
in mechanism that limits the rate at which senders may transmit data,
without using feedback from the receiver. In this chapter we will study
feedback-based flow control schemes because rate-based schemes are
never used in the data link layer.
 Various feedback-based flow control schemes are known, but most of them
use the same basic principle. The protocol contains well-defined rules about
when a sender may transmit the next frame. These rules often prohibit
frames from being sent until the receiver has granted permission, either
implicitly or explicitly. For example, when a connection is set up, the
receiver might say: ''You may send me n frames now, but after they have
been sent, do not send any more until I have told you to continue.'' We will
examine the details shortly.
 Framing
 To provide service to the network layer, the data link layer must use the service
provided to it by the physical layer. What the physical layer does is accept a
raw bit stream and attempt to deliver it to the destination. This bit stream is not
guaranteed to be error free. The number of bits received may be less than,
equal to, or more than
 the number of bits transmitted, and they may have different values. It is up to
the data link layer to detect and, if necessary, correct errors.
 The usual approach is for the data link layer to break the bit stream up into
discrete frames and compute the checksum for each frame. (Checksum
algorithms will be discussed later in this chapter.) When a frame arrives at the
destination, the checksum is recomputed. If the newly-computed checksum is
different from the one contained in the frame, the data link layer knows that an
error has occurred and takes steps to deal with it (e.g., discarding the bad
frame and possibly also sending back an error report).
 Breaking the bit stream up into frames is more difficult than it at first
appears. One way to achieve this framing is to insert time gaps between
frames, much like the spaces between words in ordinary text. However,
networks rarely make any guarantees about timing, so it is possible these
gaps might be squeezed out or other gaps might be inserted during
transmission.
 Since it is too risky to count on timing to mark the start and end of each
frame, other methods have been devised. In this section we will look at four
methods:
 1. Character count.
 2. Flag bytes with byte stuffing.
 3. Starting and ending flags, with bit stuffing.

 The first framing method uses a field in the header to specify the number of
characters in the frame. When the data link layer at the destination sees
the character count, it knows how many characters follow and hence where
the end of the frame is. This technique is shown in Fig. 3-4(a) for four
frames of sizes 5, 5, 8, and 8 characters, respectively.
A character stream. (a) Without errors. (b) With one
error.
 The second framing method gets around the problem
of resynchronization after an error by having each
frame start and end with special bytes. In the past, the
starting and ending bytes were different, but in recent
years most protocols have used the same byte, called
a flag byte, as both the starting and ending delimiter,
as shown in Fig. 3-5(a) as FLAG. In this way, if the
receiver ever loses synchronization, it can just search
for the flag byte to find the end of the current frame.
Two consecutive flag bytes indicate the end of one
frame and start of the next one.
Figure 3-5. (a) A frame delimited by flag bytes. (b) Four
examples of byte sequences before and after byte
stuffing.
 A serious problem occurs with this method when binary data, such as object programs or
floating-point numbers, are being transmitted. It may easily happen that the flag byte's bit pattern
occurs in the data. This situation will usually interfere with the framing. One way to solve this
problem is to have the sender's data link layer insert a special escape byte (ESC) just before
each ''accidental'' flag byte in the data. The data link layer on the receiving end removes the
escape byte before the data are given to the network layer. This technique is called byte stuffing
or character stuffing. Thus, a framing flag byte can be distinguished from one in the data by the
absence or presence of an escape byte before it.
 Of course, the next question is: What happens if an escape byte occurs in the middle of the
data? The answer is that it, too, is stuffed with an escape byte. Thus, any single escape byte is
part of an escape sequence, whereas a doubled one indicates that a single escape occurred
naturally in the data. Some examples are shown in Fig. 3-5(b). In all cases, the byte sequence
delivered after destuffing is exactly the same as the original byte sequence.
 The byte-stuffing scheme depicted in Fig. 3-5 is a slight simplification of the one used in the PPP
protocol that most home computers use to communicate with their Internet service provider. We
will discuss PPP later in this chapter.
 A major disadvantage of using this framing method is that it is closely tied to the use of 8-bit
characters. Not all character codes use 8-bit characters. For example. UNICODE uses 16-bit
characters, As networks developed, the disadvantages of embedding the character code length
in the framing mechanism became more and more obvious, so a new technique had to be
developed to allow arbitrary sized characters.
A character stream. (a) Without errors. (b) With one
error.
 he trouble with this algorithm is that the count can be garbled by a transmission
error. For example, if the character count of 5 in the second frame of Fig. 3-4(b)
becomes a 7, the destination will get out of synchronization and will be unable to
locate the start of the next frame. Even if the checksum is incorrect so the
destination knows that the frame is bad, it still has no way of telling where the
next frame starts. Sending a frame back to the source asking for a
retransmission does not help either, since the destination does not know how
many characters to skip over to get to the start of the retransmission. For this
reason, the character count method is rarely used anymore.
 The second framing method gets around the problem of resynchronization after
an error by having each frame start and end with special bytes. In the past, the
starting and ending bytes were different, but in recent years most protocols have
used the same byte, called a flag byte, as both the starting and ending delimiter,
as shown in Fig. 3-5(a) as FLAG. In this way, if the receiver ever loses
synchronization, it can just search for the flag byte to find the end of the current
frame. Two consecutive flag bytes indicate the end of one frame and start of the
next one.
a) A frame delimited by flag bytes
 The new technique allows data frames to contain an arbitrary number
of bits and allows character codes with an arbitrary number of bits per
character. It works like this. Each frame begins and ends with a
special bit pattern, 01111110 (in fact, a flag byte). Whenever the
sender's data link layer encounters five consecutive 1s in the data, it
automatically stuffs a 0 bit into the outgoing bit stream. This bit stuffing
is analogous to byte stuffing, in which an escape byte is stuffed into
the outgoing character stream before a flag byte in the data.
 When the receiver sees five consecutive incoming 1 bits, followed by
a 0 bit, it automatically destuffs (i.e., deletes) the 0 bit. Just as byte
stuffing is completely transparent to the network layer in both
computers, so is bit stuffing. If the user data contain the flag pattern,
01111110, this flag is transmitted as 011111010 but stored in the
receiver's memory as 01111110. Figure 3-6 gives an example of bit
stuffing.
Figure 3-6. Bit stuffing. (a) The original data. (b)
The data as they appear on the line. (c) The data as
they are stored in the receiver's memory after
destuffing.
 With bit stuffing, the boundary between two frames can be
unambiguously recognized by the flag pattern. Thus, if the receiver
loses track of where it is, all it has to do is scan the input for flag
sequences, since they can only occur at frame boundaries and never
within the data.
 ERRORDETECTION
 Why we need it ?
 To avoid retransmissionof whole packet or
message
 What to do if error detected ?
 Discard, and request a new copy of the
frame:
 explicitly or implicitly
 Try to correcterror, if possible

 2
 Data can be corrupted during
transmission.
 Some applications require that errors be
detected and corrected
REDUNDANCY
To detect or correct errors, we need to send extra
(redundant) bits with data.
 SENDERSITE
 1. The message is divided into 16-bit words.
 2. The value of the checksum word is set to
O.
 3. All words including the checksum are
added using one's complement addition.
 4. The sum is complemented and becomes
the checksum.
 5. The checksum is sent with the data
3
 RECEIVERSITE
 1. The message (including checksum) is
divided into 16-bit words.
 2. All words are added using one's
complement addition.
 3. The sum is complemented and becomes
the new checksum.
 4. If the value of checksum is 0, the message
is accepted; otherwise, it is rejected.
4
Elementary Data Link Protocols

• An Unrestricted Simplex Protocol

• A Simplex Stop-and-Wait Protocol
• A Simplex Protocol for a Noisy Channel
Unrestricted
Simplex
Protocol
Simplex
Stop-and-
Wait
Protocol
 A Simplex Protocol for a Noisy
Channel
A positive
acknowledgement
with retransmission
protocol.

Continued 
A Simplex Protocol for a Noisy Channel
(ctd.)

A positive acknowledgement with retransmission protocol.

Sliding Window Protocols

• A One-Bit Sliding Window Protocol

• A Protocol Using Go Back N
• A Protocol Using Selective Repeat
Sliding Window Protocols (2)

A sliding window of size 1, with a 3-bit sequence number.

(a) Initially.
(b) After the first frame has been sent.
(c) After the first frame has been received.
(d) After the first acknowledgement has been received.
A One-Bit Sliding Window
Protocol

Continued 
A One-Bit Sliding Window Protocol
(ctd.)
A One-Bit Sliding Window Protocol (2)

Two scenarios for protocol 4. (a) Normal case.

(b) Abnormal case. The notation is (seq, ack,
packet number). An asterisk indicates where a
A Protocol Using Go Back N

Pipelining and error recovery. Effect on an error when

(a) Receiver’s window size is 1.
(b) Receiver’s window size is large.
Go-Back-N
 Go-Back-N:
 Equivalent to receiver's window size = 1.
 If receiver sees bad frames or missing
sequence numbers, subsequent frames
are discarded. No ACKs for discarded
frames.
Sliding Window Protocol Using Go
Back N (2)
Simulation of multiple timers in software.
 Selective-Repeat
 Selective-Repeat:
 Receiver's window size larger than one.
 Store all received frames after the bad one. ACK
only last one received in sequence.

 Use NAK (Negative ACK) when an error detected:

checksum error or out of sequence
The Data Link Layer in the
Internet
A home personal computer acting as an
internet host.
PPP – Point to Point Protocol

The PPP full frame format for unnumbered

mode operation.
PPP – Point to Point Protocol (2)

A simplified phase diagram for bring a line up and down.