1. Transport Layer Goals: Overview:
understand principles behind transport layer services and protocols:
UDP
TCP
Overview:
transport layer services
multiplexing/demultiplexing
connectionless transport: UDP
connection-oriented transport: TCP
reliable transfer
flow control
connection management
Transport Layer

2. Transport services and protocols
provide logical communication between app’ processes running on different hosts
transport protocols run in end systems (exception – L4, L7 switches)
transport vs network layer services:
network layer: data transfer between end systems
transport layer: data transfer between processes
application
transport
network
data link
physical
logical end-end transport
Transport Layer

3. Transport-layer protocols
Internet transport services:
reliable, in-order unicast delivery (TCP)
congestion control
flow control
connection setup
unreliable (“best-effort”), unordered unicast or multicast delivery: UDP
services not available:
real-time
bandwidth guarantees
reliable multicast
application
transport
network
data link
physical
logical end-end transport
Transport Layer

4. Multiplexing/demultiplexing
gathering data from multiple
app processes, enveloping
data with header (later used
for demultiplexing)
Multiplexing:
source port #
dest port #
32 bits
application
data
(message)
other header fields
TCP/UDP segment format
multiplexing/demultiplexing:
based on sender, receiver IP addresses & port numbers
source, dest port #s in each segment
“well-known” port numbers for specific applications
Transport Layer

5. Multiplexing/demultiplexing
segment - unit of data exchanged between transport layer entities
aka TPDU: transport protocol data unit
Demultiplexing: delivering
received segments (TPDUs)to
correct app layer processes
application
transport
network M P2
receiver H t n
segment P1 P3 P4
header
application-layer
data
Transport Layer

6. Multiplexing/demultiplexing: examples
host A
server B
source port: x
dest. port: 23
source port:23
dest. port: x
port use: simple telnet app
WWW client
host A
WWW
server B
host C
Source IP: C
Dest IP: B
source port: x
dest. port: 80
source port: y
port use: WWW server
Source IP: A
Transport Layer

7. Well-Known Port Numbers
The port numbers are divided into three ranges: the Well Known Ports, the Registered Ports, and the Dynamic and/or Private Ports.
The Well Known Ports are those from 0 through 1023.
The Registered Ports are those from 1024 through 49151
Well Known ports and Registered ports SHOULD NOT be used without IANA registration. The registration procedure is defined in [RFC4340], Section 19.9.
The Dynamic and/or Private Ports are those from through 65535
Transport Layer

8. UDP: User Datagram Protocol [RFC 768]
“no frills”, “bare bones” Internet transport protocol
“best effort” service, UDP segments may be:
lost
delivered out of order to app
connectionless:
no handshaking between UDP sender & receiver
each UDP segment handled independently of others
Why is there a UDP?
no connection establishment (which can add delay, require more resources)
simple: no connection state at sender & receiver
small segment header
no congestion control: UDP can blast away as fast as desired
Transport Layer

9. UDP (cont’d) often used for streaming multimedia apps loss tolerant
rate sensitive
other UDP uses
DNS
SNMP
reliable transfer over UDP: add reliability at application layer
application-specific error recovery!
source port #
dest port #
32 bits
Application
data
(message)
UDP segment format
length
checksum
Length in
bytes of UDP
segment,
including
header
Transport Layer

10. UDP checksum
Goal: detect “errors” (e.g., flipped bits) in transmitted segment
Receiver:
compute checksum of received segment
check if computed checksum equals checksum field value:
NO - error detected
YES - no error detected.
Sender:
treat segment contents as sequence of 16-bit integers
checksum: addition (1’s complement sum) of segment contents
sender puts checksum value into UDP checksum field
Transport Layer

11. TCP: Overview [RFCs: 793, 1122, 1323, 2018, 2581] point-to-point:
one sender, one receiver
reliable, in-order byte steam:
no “message boundaries”
pipelined:
TCP congestion and flow control set window size
full duplex data:
bi-directional data flow in same connection
connection-oriented:
handshaking (exchange of control msgs) initializes sender, receiver state before data exchange
flow controlled:
sender will not overwhelm receiver
Transport Layer

12. TCP segment structure source port # dest port # application data
32 bits
application
data
(variable length)
sequence number
acknowledgement number
rcvr window size
ptr urgent data
checksum F S R P A U
head
len
not
used
Options (variable length)
URG: urgent data
(generally not used)
counting
by bytes
of data
(not segments!)
ACK: ACK #
valid
PSH: push data now
(generally not used)
# bytes
rcvr willing
to accept
RST, SYN, FIN:
connection estab
(setup, teardown
commands)
Internet
checksum
(as in UDP)
Transport Layer

13. simple telnet scenario
TCP seq. #’s and ACKs
Seq. #’s:
byte stream “number” of first byte in segment’s data
ACKs:
seq # of next byte expected from other side
cumulative ACK
Q: how receiver handles out-of-order segments
A: TCP spec doesn’t say, - up to the implementor
Host A
Host B
User
types
‘C’
Seq=42, ACK=79, data = ‘C’
host ACKs
receipt of
‘C’, echoes
back ‘C’
Seq=79, ACK=43, data = ‘C’
host ACKs
receipt
of echoed
‘C’
Seq=43, ACK=80
time
simple telnet scenario
Transport Layer

14. TCP: reliable data transfer
event: data received
from application above
simplified sender, assuming
create, send segment
one way data transfer
no flow, congestion control
wait
for
event
event: timer timeout for
segment with seq # y
wait
for
event
retransmit segment
event: ACK received,
with ACK # y
ACK processing
Transport Layer

15. TCP: reliable data transfer
00 sendbase = initial_sequence number
01 nextseqnum = initial_sequence number 02
loop (forever) {
switch(event)
event: data received from application above
create TCP segment with sequence number nextseqnum
start timer for segment nextseqnum
pass segment to IP
nextseqnum = nextseqnum + length(data)
event: timer timeout for segment with sequence number y
retransmit segment with sequence number y
compute new timeout interval for segment y
restart timer for sequence number y
event: ACK received, with ACK field value of y
if (y > sendbase) { /* cumulative ACK of all data up to y */
cancel all timers for segments with sequence numbers < y
sendbase = y }
else { /* a duplicate ACK for already ACKed segment */
increment number of duplicate ACKs received for y
if (number of duplicate ACKS received for y == 3) {
/* TCP fast retransmit */
resend segment with sequence number y
restart timer for segment y }
} /* end of loop forever */
TCP: reliable data transfer
Simplified
TCP
sender
Transport Layer

16. TCP ACK generation [RFC 1122, RFC 2581]
Event
in-order segment arrival,
no gaps,
everything else already ACKed
one delayed ACK pending
out-of-order segment arrival
higher-than-expect seq. #
gap detected
arrival of segment that
partially or completely fills gap
TCP Receiver action
delayed ACK. Wait up to 500ms
for next segment. If no next segment,
send ACK
immediately send single
cumulative ACK
send duplicate ACK, indicating seq. #
of next expected byte
immediate ACK if segment starts
at lower end of gap
Transport Layer

17. TCP: retransmission scenarios
Host A
Seq=92, 8 bytes data
ACK=100
loss
timeout
time
lost ACK scenario
Host B X
Host A
Seq=100, 20 bytes data
ACK=100
Seq=92 timeout
time
premature timeout,
cumulative ACKs
Host B
Seq=92, 8 bytes data
ACK=120
Seq=100 timeout
Transport Layer

18. sender will not overrun
TCP Flow Control
receiver: explicitly informs sender of (dynamically changing) amount of free buffer space
RcvWindow size field in TCP segment
sender: amount of transmitted, unACKed data less than most recently-receiver RcvWindow size
sender will not overrun
receiver’s buffers by
transmitting too much,
too fast
flow control
receiver buffering
Transport Layer

19. TCP Round Trip Time (RTT) & Timeout
Q: how to set TCP timeout value?
longer than RTT
note: RTT will vary
too short: premature timeout
unnecessary retransmissions
too long: slow reaction to segment loss
Q: how to estimate RTT?
SampleRTT: measured time from segment transmission until ACK receipt
ignore retransmissions, cumulatively ACKed segments
SampleRTT will vary, for “smoother” estimated RTT
use several recent measurements, not just current SampleRTT
Transport Layer

20. TCP Round Trip Time (RTT) & Timeout
EstimatedRTT = (1-x)*EstimatedRTT + x*SampleRTT
Exponential weighted moving average
influence of given sample decreases exponentially fast
typical value of x: 0.1
Setting the timeout
RTT plus “safety margin”
large variation in EstimatedRTT -> larger safety margin
Timeout = EstimatedRTT + 4*Deviation
Deviation = (1-x)*Deviation +
x*abs(SampleRTT-EstimatedRTT)
Transport Layer

21. TCP Connection Management
Recall: TCP sender, receiver establish a “connection” before exchanging data segments
initialize TCP variables:
seq. #s
buffers, flow control info (e.g., RcvWindow)
client: connection initiator
server: contacted by client
Transport Layer

22. TCP Connection Management (cont’d)
Opening a connection (3-way handshake):
Step 1: client end system sends TCP SYN control segment to server
Step 2: server end system receives SYN, replies with SYN-ACK
allocates buffers
ACKs received SYN
Step 3: client rcvs SYN-ACK
connection is now set up
client starts the “real work”
client
SYN
server
SYN-ACK
ACK
open
listen
established
Transport Layer

23. TCP Connection Management (cont’d)
Closing a connection:
Step 1: client end system sends TCP FIN control segment to server
Step 2: server receives FIN, replies with ACK. Closes connection, sends FIN.
client
FIN
server
ACK
close
closed
timed wait
Transport Layer

24. TCP Connection Management (cont’d)
Step 3: client receives FIN, replies with ACK.
Enters “timed wait” - will respond with ACK to received FINs
Step 4: server, receives ACK. Connection closed.
client
FIN
server
ACK
close
closed
timed wait
Transport Layer

25. TCP Connection Management (cont’d)
TCP client
FSM
TCP server
FSM
Transport Layer

26. Summary transport layer services multiplexing/demultiplexing
connectionless transport: UDP
connection-oriented transport: TCP
Transport Layer