Transcript Transport Layer

Transport Layer
Goals:
Overview:
 understand principles  transport layer services
behind transport
layer services and
protocols:


UDP
TCP
 multiplexing/demultiplexing
 connectionless transport:
UDP
 connection-oriented
transport: TCP



reliable transfer
flow control
connection management
Transport Layer
1
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
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
application
transport
network
data link
physical
Transport Layer
2
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:



application
transport
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
application
transport
network
data link
physical
real-time
bandwidth guarantees
reliable multicast
Transport Layer
3
Multiplexing/demultiplexing
Multiplexing:
gathering data from multiple
app processes, enveloping
data with header (later used
for demultiplexing)
multiplexing/demultiplexing:
 based on sender, receiver
IP addresses & port
numbers
 source, dest port #s in
each segment
 “well-known” port
numbers for specific
applications
32 bits
source port #
dest port #
other header fields
application
data
(message)
TCP/UDP segment format
Transport Layer
4
Multiplexing/demultiplexing
segment - unit of data
exchanged between
transport layer entities
 aka TPDU: transport
protocol data unit
application-layer
data
segment
header
segment
Ht M
Hn segment
P1
M
application
transport
network
Demultiplexing: delivering
received segments (TPDUs)to
correct app layer processes
P3
receiver
M
M
application
transport
network
P4
M
P2
application
transport
network
Transport Layer
5
Multiplexing/demultiplexing: examples
host A
source port: x
dest. port: 23
server B
source port:23
dest. port: x
Source IP: C
Dest IP: B
source port: y
dest. port: 80
port use: simple telnet app
WWW client
host A
WWW client
host C
Source IP: A
Dest IP: B
source port: x
dest. port: 80
Source IP: C
Dest IP: B
source port: x
dest. port: 80
WWW
server B
port use: WWW server
Transport Layer
6
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
49152 through 65535
http://www.iana.org/assignments/port-numbers
Transport Layer
7
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
8
UDP (cont’d)
 often used for
streaming multimedia
apps
Length in
 loss tolerant
bytes of UDP
segment,
 rate sensitive
including
header
 other UDP uses
 DNS
 SNMP
 reliable transfer over
UDP: add reliability at
application layer
 application-specific
error recovery!
32 bits
source port #
dest port #
length
checksum
Application
data
(message)
UDP segment format
Transport Layer
9
UDP checksum
Goal: detect “errors” (e.g., flipped bits) in
transmitted segment
Sender:
Receiver:
contents as sequence
of 16-bit integers
 checksum: addition
(1’s complement sum)
of segment contents
 sender puts checksum
value into UDP
checksum field
received segment
 check if computed
checksum equals
checksum field value:
 NO - error detected
 YES - no error
detected.
 treat segment
 compute checksum of
Transport Layer
10
TCP: Overview
 point-to-point:
 one sender, one
receiver
 reliable, in-order
byte steam:

no “message
boundaries”
 pipelined:
 TCP congestion and
flow control set
window size
[RFCs: 793, 1122, 1323, 2018, 2581]
 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
11
TCP segment structure
32 bits
URG: urgent data
(generally not used)
ACK: ACK #
valid
PSH: push data now
(generally not used)
RST, SYN, FIN:
connection estab
(setup, teardown
commands)
Internet
checksum
(as in UDP)
source port #
dest port #
sequence number
acknowledgement number
head not
UA P R S F
len used
checksum
rcvr window size
ptr urgent data
Options (variable length)
counting
by bytes
of data
(not segments!)
# bytes
rcvr willing
to accept
application
data
(variable length)
Transport Layer
12
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
User
types
‘C’
Host B
host ACKs
receipt of
‘C’, echoes
back ‘C’
host ACKs
receipt
of echoed
‘C’
simple telnet scenario
Transport Layer
time
13
TCP: reliable data transfer
event: data received
from application above
create, send segment
wait
wait
for
for
event
event
simplified sender, assuming
• one way data transfer
• no flow, congestion
control
event: timer timeout for
segment with seq # y
retransmit segment
event: ACK received,
with ACK # y
ACK processing
Transport Layer
14
TCP:
reliable
data
transfer
Simplified
TCP
sender
00 sendbase = initial_sequence number
01 nextseqnum = initial_sequence number
02
03 loop (forever) {
04
switch(event)
05
event: data received from application above
06
create TCP segment with sequence number nextseqnum
07
start timer for segment nextseqnum
08
pass segment to IP
09
nextseqnum = nextseqnum + length(data)
10
event: timer timeout for segment with sequence number y
11
retransmit segment with sequence number y
12
compute new timeout interval for segment y
13
restart timer for sequence number y
14
event: ACK received, with ACK field value of y
15
if (y > sendbase) { /* cumulative ACK of all data up to y */
16
cancel all timers for segments with sequence numbers < y
17
sendbase = y
18
}
19
else { /* a duplicate ACK for already ACKed segment */
20
increment number of duplicate ACKs received for y
21
if (number of duplicate ACKS received for y == 3) {
22
/* TCP fast retransmit */
23
resend segment with sequence number y
24
restart timer for segment y
25
}
26
} /* end of loop forever */
Transport Layer
15
TCP ACK generation
[RFC 1122, RFC 2581]
Event
TCP Receiver action
in-order segment arrival,
no gaps,
everything else already ACKed
delayed ACK. Wait up to 500ms
for next segment. If no next segment,
send ACK
in-order segment arrival,
no gaps,
one delayed ACK pending
immediately send single
cumulative ACK
out-of-order segment arrival
higher-than-expect seq. #
gap detected
send duplicate ACK, indicating seq. #
of next expected byte
arrival of segment that
partially or completely fills gap
immediate ACK if segment starts
at lower end of gap
Transport Layer
16
TCP: retransmission scenarios
time
Host A
Host B
X
loss
lost ACK scenario
Host B
Seq=100 timeout
Seq=92 timeout
timeout
Host A
time
premature timeout,
cumulative ACKs
Transport Layer
17
TCP Flow Control
flow control
sender will not overrun
receiver’s buffers by
transmitting too much,
too fast
receiver buffering
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
Transport Layer
18
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
19
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
20
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
21
TCP Connection Management (cont’d)
Opening a connection (3way handshake):
Step 1: client end system
sends TCP SYN control
segment to server
client
server
open
listen
Step 2: server end system
receives SYN, replies with
SYN-ACK

allocates buffers

ACKs received SYN
established
Step 3: client rcvs SYN-ACK

connection is now set up

client starts the “real work”
established
Transport Layer
22
TCP Connection Management (cont’d)
Closing a connection:
Step 1: client end
client
close
system sends TCP FIN
control segment to
server
FIN, replies with ACK.
Closes connection,
sends FIN.
close
timed wait
Step 2: server receives
server
closed
closed
Transport Layer
23
TCP Connection Management (cont’d)
Step 3: client receives
FIN, replies with ACK.
client
server
close
 Enters
“timed wait”
- will respond with
ACK to received
FINs
receives ACK.
Connection closed.
timed wait
Step 4: server,
close
closed
closed
Transport Layer
24
TCP Connection Management (cont’d)
TCP client
FSM
TCP server
FSM
Transport Layer
25
Summary
 transport layer services
 multiplexing/demultiplexing
 connectionless transport:
UDP
 connection-oriented
transport: TCP
Transport Layer
26