23.1

Chapter 23

Process-to-Process Delivery:UDP and TCP

Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display.

23.2

23-1 PROCESS-TO-PROCESS DELIVERY23-1 PROCESS-TO-PROCESS DELIVERY

The transport layer is responsible for process-to-The transport layer is responsible for process-to-process delivery—the delivery of a packet, part of a process delivery—the delivery of a packet, part of a message, from one process to another. Two processes message, from one process to another. Two processes communicate in a client/server relationship, as we will communicate in a client/server relationship, as we will see later. see later.

Client/Server ParadigmMultiplexing and DemultiplexingConnectionless Versus Connection-Oriented ServiceReliable Versus UnreliableThree Protocols

Topics discussed in this section:Topics discussed in this section:

23.3

Process-To-Process Delivery

• The data link layer is responsible for delivery of

frames between two neighboring nodes over a link

called node-to-node delivery.

• The network layer is responsible for delivery of

datagrams between two hosts called host-to-host

delivery.

• Communication on the Internet is based on process-

to-process delivery. The transport layer is responsible

for process-to-process delivery-the delivery of a

packet, part of a message, from one process to

another.

23.4

Client Server Paradigm- Client Server paradigm used to show process-to-

process communication.- a process on the local host (client), needs

services from a process on the remote host (server).

- For communication, we must define the following:1. Local host2. Local process3. Remote host4. Remote process

23.5

Figure 23.1: Types of data deliveries

The transport layer is responsible for process-to-process delivery.

Local

process

Local

host

Remote

process

Remote

host

Addressing•At the transport layer, we need a transport layer address, called a port number, to choose among multiple processes running on the destination host.

• The destination port number is needed for delivery; the source port number is needed for the reply.

• The port numbers are integers between 0 and 65,535. The client program defines itself with a port number, chosen randomly by the transport layer software running on the client host.

• The server process must also define itself with a port number.

This port number, however, cannot be chosen randomly.

• The lANA (Internet Assigned Number Authority) has divided the

port numbers into three ranges: well known, registered, and

dynamic (or private)

IANA ranges

Socket address

• Process-to-process delivery needs two identifiers, IP address and the

port number, at each end to make a connection. The combination of

an IP address and a port number is called a socket address.

• A transport layer protocol needs a pair of socket addresses: the client

socket address and the server socket address.

• These four pieces of information are part of the IP header and the

transport layer protocol header. The IP header contains the IP

addresses; the UDP or TCP header contains the port numbers.

Multiplexing and demultiplexing

• The addressing mechanism allows multiplexing and de-multiplexing by the

transport layer.

• At the sender site, there may be several processes that need to send packets.

However, there is only one transport layer protocol at any time. This is

requires multiplexing. The protocol accepts messages from different

processes, differentiated by their assigned port numbers. After adding the

header, the transport layer passes the packet to the network layer.

• At the receiver site, the relationship is one-to-many and requires

demultiplexing. The transport layer receives datagrams from the network

layer. After error checking and dropping of the header, the transport layer

delivers each message to the appropriate process based on the port number.

80 21 53 110 80 21 53 110

Reliable Versus Unreliable: Error control

• The transport layer service can be reliable or unreliable. If the

application layer program needs reliability, we use a reliable

transport layer protocol by implementing flow and error control at the

transport layer. On the other hand, if the application program does

not need reliability because it uses its own flow and error control

mechanism or it needs fast service or the nature of the service does

not demand flow and error control (real-time applications), then an

unreliable protocol can be used..

Reliable Versus Unreliable: Error control

• In the Internet, there are three common different transport layer

protocols. UDP is connectionless and unreliable; TCP and SCTP

are connection- oriented and reliable. These three can respond to

the demands of the application layer programs.

23.12

Position of UDP, TCP, and SCTP in TCP/IP suite

23.13

23-2 USER DATAGRAM PROTOCOL (UDP)23-2 USER DATAGRAM PROTOCOL (UDP)

The User Datagram Protocol (UDP) is called a The User Datagram Protocol (UDP) is called a connectionless, unreliable transport protocol. It does connectionless, unreliable transport protocol. It does not add anything to the services of IP except to provide not add anything to the services of IP except to provide process-to-process communication instead of host-to-process-to-process communication instead of host-to-host communication. host communication.

Well-Known Ports for UDPUser DatagramChecksumUDP OperationUse of UDP

Topics discussed in this section:Topics discussed in this section:

23.14

Well-known ports used with UDP

23.15

In UNIX, the well-known ports are stored in a file called /etc/services. Each line in this file gives the name of the server and the well-known port number. We can use the grep utility to extract the line corresponding to the desired application. The following shows the port for FTP. Note that FTP can use port 21 with either UDP or TCP.

Example 23.1

SNMP uses two port numbers (161 and 162), each for a different purpose.

User datagram format

• Source port number: This is the port number used by the process

running on the source host.

• Destination port number: This is the port number used by the

process running on the destination host.

• Length: This is a 16-bit field that defines the total length of the user

datagram, header plus data.

• Checksum: This field is used to detect errors over the entire user

datagram (header plus data).

Pseudoheader for checksum calculation

The pseudoheader is the part

of the header of the IP packet

in which the user datagram is

to be encapsulated with some

fields filled with Os

The protocol field is added to ensure that the

packet belongs to UDP, and not to other

transport-layer protocols. The value of the

protocol field for UDP is 17

Checksum calculation of a simple UDP user datagram

Figure 23.11 shows the checksum calculation for a very small user datagram with only 7 bytes of data. Because the number of bytes of data is odd, padding is added for checksum calculation. The pseudoheader as well as the padding will be dropped when the user datagram is delivered to IP.

UDP OPERATION

Connectionless Services

UDP provides a connectionless service. The user datagrams are not

numbered. Also, there is no connection establishment and no

connection termination. This means that each user datagram can

travel on a different path.

Flow and Error Control

UDP is unreliable transport protocol, no flow control, no window

mechanism, no error control mechanism. Doesn’t know if a message

has been lost or duplicated. When the receiver detects an error

through the checksum, the user datagram is silently discarded.

UDP OPERATION (Cont..)

Encapsulation and Decapsulation

The UDP protocol encapsulates and decapsulates messages in an IP

datagram.

Queuing

In UDP, queues are associated with ports (see Figure)

23.21

23-3 TCP23-3 TCP

TCP is a connection-oriented protocol; it creates a TCP is a connection-oriented protocol; it creates a virtual connection between two TCPs to send data. In virtual connection between two TCPs to send data. In addition, TCP uses flow and error control mechanisms addition, TCP uses flow and error control mechanisms at the transport level. at the transport level.

TCP ServicesTCP FeaturesSegmentA TCP ConnectionFlow ControlError Control

Topics discussed in this section:Topics discussed in this section:

23.22

TCP Services

Services offered by TCP at the application layer:•Process-to-process Communication•Stream Delivery Service•Full-Duplex Communication•Connection-Oriented Service•Reliable Service

Well-known ports used by TCP

TCP provides the communication using port numbers for

process-to-process communication.

23.24

Stream DeliveryService

TCP is a stream-oriented protocol.

TCP allows the sending process to deliver data as a stream of

bytes and allows the receiving process to obtain data as a

stream of bytes. TCP creates an environment in which the two

processes seem to be connected by an imaginary "tube" that

carries their data across the Internet.

23.25

Sending and receiving buffers

• Because the sending and the receiving processes may not

write or read data at the same speed, TCP needs buffers for

storage.

• There are two buffers, the sending buffer and the receiving

buffer, one for each direction.

• One way to implement a buffer is to use a circular array of I-

byte locations as shown in above figure.

23.26

Sending and receiving buffers

• The white section contains empty chambers that can be filled by the

sending process (producer).

• The gray area holds bytes that have been sent but not yet acknowledged.

TCP keeps these bytes in the buffer until it receives an acknowledgment.

• The colored area contains bytes to be sent by the sending TCP.

Note:

After the bytes in the gray chambers are acknowledged, the chambers are

recycled and available for use by the sending process.

The figure shows the movement of

the data in one direction. At the

sending site, the buffer has three

types of chambers.

23.27

Operation Buffer atreceiver

• The white area contains empty chambers to be filled by bytes

received from the network.

• The colored sections contain received bytes that can be read

by the receiving process.

When a byte is read by the receiving process, the chamber is recycled

and added to the pool of empty chambers.

The circular buffer is divided

into two areas (shown as white

and colored).

23.28

TCP segments

Before we can

send data; IP

layer need to

send data in

packets, not as a

stream of bytes. • At the transport layer, TCP groups a number of bytes together into a

packet called a segment.

• TCP adds a header to each segment (for control purposes) and

delivers the segment to the IP layer for transmission.

• The segments are encapsulated in IP datagrams and transmitted.

This entire operation is transparent to the receiving process.

Example 23.3

Suppose a TCP connection is transferring a file of 5000 bytes. The first

byte is numbered 1O,00l. What are the sequence numbers for each

segment if data are sent in five segments, each carrying 1000 bytes?

23.30

The value of the acknowledgment field in a segment defines the number of the next byte a party expects to receive. The acknowledgment number is cumulative.

The following shows the sequence number for each segment:

Solution

The value in the sequence number field of a segment defines the number of the first data byte contained in that segment.

23.31

FORMAT OF TCP SEGMENT

23.32

Control Field

These bits enable flow

control, connection

establishment and

termination,

connection abortion,

and the mode of data

transfer in TCP.

TCP CONNECTION

• TCP is connection-oriented. A connection-oriented transport

protocol establishes a virtual path between the source and

destination. All the segments belonging to a message are then

sent over this virtual path. Using a single virtual pathway for the

entire message facilitates the acknowledgment process as well as

retransmission of damaged or lost frames.

• TCP uses the services of IP to deliver individual segments to the

receiver, but it controls the connection itself. If a segment is lost

or corrupted, it is retransmitted.

• In TCP, connection-oriented transmission requires three phases:

i. Connection establishment

ii. Data transfer

iii. Connection termination

23.34

Connection establishment using three-way handshaking

The client sends the first

segment, a SYN segment, in

which only the SYN flag is set.

This segment is for

synchronization of sequence

numbers. It consumes one

sequence number. When the

data transfer starts, the

sequence number is

incremented by 1.

A SYN segment cannot carry data, but it consumes one sequence number.

23.35

Connection establishment using three-way handshaking

The server sends the second

segment, a SYN + ACK

segment, with 2 flag bits set:

SYN and ACK. This segment

has a dual purpose. It is a SYN

segment for communication in

the other direction and serves as

the acknowledgment for the

SYN segment. It consumes one

sequence number.

A SYN + ACK segment cannot carry data, but does consume one

sequence number.

Connection establishment using three-way handshaking

The client sends the third

segment. This is just an ACK

segment. It acknowledges the

receipt of the second segment

with the ACK flag and

acknowledgment number field.

Note that the sequence number

in this segment is the same as

the one in the SYN segment; the

ACK segment does not

consume any sequence

numbers.

An ACK segment, if carrying no data,

consumes no sequence number.

23.37

Data TransferAfter connection is established,

bidirectional data transfer can take place.

The client and server can both send data

and acknowledgments.

In this example, after connection is

established the client sends 2000 bytes

of data in two segments. The server then

sends 2000 bytes in one segment. The

client sends one more segment. The first

three segments carry both data and

acknowledgment, but the last segment

carries only an acknowledgment because

there are no more data to be sent.

23.38

Connection Termination

Any of the two parties involved in exchanging data (client or server) can

close the connection, although it is usually initiated by the client. Most

implementations today allow two options for connection termination: three-

way handshaking and four-way handshaking with a half-close option.

Three-Way Handshaking

Most implementations today allow three-way handshaking for connection

termination as shown in next Figure.

23.39

Connection termination using three-way handshaking

In a normal situation, the client

TCP, after receiving a close

command from the client process,

sends the first segment, a FIN

segment in which the FIN flag is set.

Note:

If FIN segment can include the last

chunk of data sent by the client, or it

can be just a control segment as

shown in Figure. If it is only a

control segment, it consumes only

one sequence number.

The FIN segment consumes one sequence

number if it does not carry data.

23.40

Connection termination using three-way handshaking

The server TCP, after receiving the

FIN segment, informs its process of

the situation and sends the second

segment, a FIN +ACK segment, to

confirm the receipt of the FIN

segment from the client and at the

same time to announce the closing of

the connection in the other direction.

This segment can also contain the

last chunk of data from the server. If

it does not carry data, it consumes

only one sequence number.

The FIN + ACK segment consumes one sequence

number if it does not carry data.

23.41

Connection termination using three-way handshaking

The client TCP sends the last

segment, an ACK segment, to

confirm the receipt of the FIN

segment from the TCP server.

This segment contains the

acknowledgment number, which is 1

plus the sequence number received

in the FIN segment from the server.

This segment cannot carry data and

consumes no sequence numbers.

Half-Close

In TCP, one end can stop sending data while still receiving data. This is

called a half-close.

Although either end can issue a half-close, it is normally initiated by the

client.

It can occur when the server needs all the data before processing can

begin.

A good example is sorting. When the client sends data to the server to be

sorted, the server needs to receive all the data before sorting can start.

This means the client, after sending all the data, can close the connection

in the outbound direction. However, the inbound direction must remain

open to receive the sorted data. The server, after receiving the data, still

needs time for sorting; its outbound direction must remain open.

23.43

Half-close

This figure shows an example of a half-

close.

•The client half-closes the connection by

sending a FIN segment.

•The server accepts the half-close by

sending the ACK segment.

•The data transfer from the client to the

server stops.

•The server, however, can still send

data.

•When the server has sent all the

processed data, it sends a FIN segment,

which is acknowledged by an ACK from

the client.

23.44

Half-close• After half-closing of the connection,

data can travel from the server to

the client and acknowledgments

can travel from the client to the

server.

• The client cannot send any more

data to the server.

Note the sequence numbers we have

used. The second segment (ACK)

consumes no sequence number.

23.45

Sliding window

Flow Control•TCP uses a sliding window to handle flow control. •Window spans once received bytes from the process. •Bytes inside the window can be sent without waiting for ACK.•The window is opened, closed, or shrunk. These activities are controlled by the receiver, not the sender. The sender must obey the commands of the receiver in this matter.

Sliding window

• Opening a window : moving the right wall to the right. • This allows more new bytes in the buffer that are

eligible for sending. • Closing the window : moving the left wall to the right.

• This means that some bytes have been acknowledged.

• Shrinking the window : moving the right wall to the left. • This is strongly discouraged and not allowed in

some implementations because it means revoking the eligibility of some bytes for sending.

23.47

A sliding window is used to make transmission more efficient as well asto control the flow of data so that the

destination does not becomeoverwhelmed with data.

TCP sliding windows are byte-oriented.

Note

23.48

What is the value of the receiver window (rwnd) for host A if the receiver, host B, has a buffer size of 5000 bytes and 1000 bytes of received and unprocessed data?

Example 23.4

SolutionThe value of rwnd = 5000 − 1000 = 4000. Host B can receive only 4000 bytes of data before overflowing its buffer. Host B advertises this value in its next segment to A.

23.49

What is the size of the window for host A if the value of rwnd is 3000 bytes and the value of cwnd is 3500 bytes?

Example 23.5

SolutionThe size of the window is the smaller of rwnd and cwnd, which is 3000 bytes.

Figure above shows an unrealistic example of a sliding window. The sender has sent bytes up to 202. We assume that cwnd is 20 (in reality this value is thousands of bytes). The receiver has sent an acknowledgment number of 200 with an rwnd of 9 bytes (in reality this value is thousands of bytes). The size of the sender window is the minimum of rwnd and cwnd, or 9 bytes. Bytes 200 to 202 are sent, but not acknowledged. Bytes 203 to 208 can be sent without worrying about acknowledgment. Bytes 209 and above cannot be sent.

Example

23.51

Some points about TCP sliding windows:❏ The size of the window is the lesser of rwnd and cwnd.❏ The source does not have to send a full window’s worth of data.❏ The window can be opened or closed by the receiver, but should not be shrunk.❏ The destination can send an acknowledgment at any time as long as it does not result in a shrinking window.❏ The receiver can temporarily shut down the window; the sender, however, can always send a segment of 1 byte after the window is shut down.

Note

23.52

Error Control

• TCP provides reliability using error control. • Error control includes mechanisms for detecting

corrupted segments, lost segments, out-of-order segments, and duplicated segments.

• Error control also includes a mechanism for correcting errors after they are detected.

• Error detection and correction in TCP is achieved through the use of three simple tools: checksum, acknowledgment, and time-out.

23.53

Error Control - Checksum

• Each segment includes a checksum field which is used to check for a corrupted segment. • If the segment is corrupted, it is discarded by

the destination TCP and is considered as lost. • TCP uses a 16-bit checksum that is mandatory in

every segment.

23.54

Error Control - Acknowledgement

• TCP uses acknowledgments to confirm the receipt of data segments.

• Control segments that carry no data but consume a sequence number are also acknowledged.

• ACK segments are never acknowledged.

23.55

Error Control - Retransmission

• The heart of the error control mechanism is the retransmission of segments.

• When a segment is corrupted, lost, or delayed, it is retransmitted.

• A segment is retransmitted on two occasions: • when a retransmission timer expires or• when the sender receives three duplicate

ACKs.

23.56

Scenarios: Normal Operation

• When the client receives the first segment from the server, it does not have any more data to send; it sends only an ACK segment.

• However, the acknowledgment needs to be delayed for 500 ms to see if any more segments arrive.

• When the timer matures, it triggers an acknowledgment.

• This is so because the client has no knowledge if other segments are coming; it cannot delay the acknowledgment forever.

• When the next segment arrives, another acknowledgment timer is set.

• However, before it matures, the third segment arrives. The arrival of the third segment triggers another acknowledgment.

23.57

Lost Segment Scenario

• A lost segment and a corrupted segment are treated the same way by the receiver.

• A lost segment is discarded somewhere in the network; a corrupted segment is discarded by the receiver itself. Both are considered lost.

Fast Retransmission Scenario

• When the receiver receives the fourth, fifth, and sixth segments, it triggers an acknowledgment.

• The sender receives four acknowledgments with the same value (three duplicates).

• Although the timer for segment 3 has not matured yet, the fast transmission requires that segment 3, the segment that is expected by all these acknowledgments, be resent immediately.

• Note that only one segment is retransmitted although four segments are not acknowledged.

• When the sender receives the retransmitted ACK, it knows that the four segments are safe and sound because acknowledgment is cumulative.