slides.

Livello trasporto
 Servizi
 Multiplexing e
demultiplexing
 Trasporto senza
connessione: UDP
 Principi di trasferimento
affidabile
 TCP
 Struttura del segmento
 Trasferimento dati
affidabile
 Controllo del flusso
 Gestione della connessione
 Principi di controllo della
congestione
 Controllo della
congestione in TCP
TCP (1/2)
 Definito negli RFC 793,
 Pipelined: controllo del
1122, 1323, …
 Point-to-point:
connessione tra un
sender ed un receiver
 Full-duplex: flusso di
dati bidirezionale nella
stessa connessione
 Sequenza ordinata,
senza errori
flusso e della congestione
regolano la finestra di
trasmissione
 Connection-oriented:
handshake a tre vie prima
dell’invio dei dati
1
TCP (2/2)
 Basato su una versione del protocollo sliding
window con dimensione della finestra di
trasmissione variabile
 La PDU prende il nome di segmento
 La quantità massima di dati del segmento
(MSS, Maximum Segment Size) è negoziata
quando si attiva la connessione
TCP: buffer di ricezione/trasmissione
 I dati vengono accumulati in buffer sia in trasmissione
sia in ricezione:


I dati vengono passati attraverso il socket ad un buffer di
trasmissione, da cui vengono prelevati per creare un
segmento
I dati ricevuti vengono memorizzati in un buffer di ricezione
socket
door
application
writes data
application
reads data
TCP
send buffer
TCP
receive buffer
socket
door
segment
2
TCP - trasmissione
 In trasmissione il protocollo deve:
Accettare un flusso dati da livello applicazione
 Spezzare il flusso dati in segmenti; ogni segmento
verrà incapsulato in un pacchetto a livello rete
 Trasmettere i segmenti tramite un sottostante
livello rete inaffidabile
 Gestire gli errori di trasmissione con la
ritrasmissione dei segmenti

TCP - ricezione
 In ricezione il protocollo deve:
Ricevere i segmenti dal livello rete
 Segnalare i segmenti danneggiati
 Riordinare i segmenti ricevuti
 Consegnare i dati nei segmenti a livello
applicazione

3
Segmento TCP
URG: dati urgenti
(generalmente
non usato)
campo riscontro valido
32 bit
n. porta sorg.
n. porta dest.
sequenza e ACK
n. di sequenza
n. di riscontro
lunghezza intestazione
PSH: push data
(generalmente
non usato)
RST, SYN, FIN:
apertura connessione
head not
UAP R S F
len used
checksum
finestra ricezione
Urg data pointer
opzioni (lungh. variable)
dati
applicativi
(lungh. variabile)
n. bytes che il
receiver può
accettare
Internet
checksum
(come UDP)
Opzioni
 Definite durante l’apertura della connessione, o
durante la connessione
Negoziazione MSS
 Negoziazione Window scale, fattore di scala della
finestra di ricezione, che può aumentare fino a 230
bytes
 Timestamp: usato per il calcolo del RTT

4
TCP – numeri di sequenza e ACK
 Dati: sequenza ordinata di




byte
Sequenza: posizione,
rispetto alla sequenza di
byte, del primo byte del
segmento
ACK: prossimo byte atteso
Riscontro cumulativo: la
perdita di un ACK non
blocca la trasmissione se
confermato da un ACK
successivo
Nessuna specifica su
segmenti fuori ordine
outgoing segment from sender
source port #
dest port #
sequence number
acknowledgement number
rwnd
checksum
urg pointer
window size
N
sender sequence number space
sent
ACKed
sent, not- usable not
yet ACKed but not usable
yet sent
(“inflight”)
incoming segment to sender
source port #
dest port #
sequence number
acknowledgement number
rwnd
A
checksum
urg pointer
TCP – trasferimento affidabile
 Pipelining dei segmenti
 ACK cumulativi
 Timer unico per la ritrasmissione (RFC 6298)
 Il receiver invia un ACK, che può essere a
piggyback di un segmento contenente anche
dati
 Ritrasmissione in seguito a:
timeout
 ACK duplicati

5
Receiver TCP (RFC 1122, RFC 5681)
 Arrivo di un segmento in ordine, tutti i segmenti
già riscontrati: attesa massima di 500 ms di un
altro segmento in ordine e invio di ACK
(delayed ACK)
 Arrivo di un segmento in ordine, con numero di
sequenza atteso e un segmento in attesa di
trasmissione di ACK: invio ACK cumulativo
 Arrivo di segmento fuori ordine: invio ACK
duplicato. Il segmento non viene scartato
 Arrivo di segmento che chiude un buco nella
sequenza dei dati ricevuti, alla base della
finestra: invio immediato di ACK cumulativo
Sender TCP semplificato
 No ACK duplicati, no controllo flusso, no
controllo congestione
 Eventi:
dati passati dal livello applicativo: TCP crea
segmento, lo passa a livello IP. Se non attivo, il
timer viene avviato
 timeout: il TCP ritrasmette il segmento che ha
causato l’evento di timeout e riavvia il timer
 arrivo di un riscontro: un riscontro conferma tutti i
byte precedenti il byte di riscontro. Se ci sono
segmenti non riscontrati, riavvia il timer

6
Sender TCP (semplificato)

NextSeqNum = InitialSeqNum
SendBase = InitialSeqNum
wait
for
event
data received from application above
create segment, seq. #: NextSeqNum
pass segment to IP (udt_send)
NextSeqNum = NextSeqNum + length(data)
if (timer currently not running)
start timer
timeout
retransmit not-yet-acked segment
with smallest seq. #
start timer
ACK received, with ACK field value y
if (y > SendBase) {
SendBase = y
/* SendBase–1: last cumulatively ACKed byte */
if (there are currently not-yet-acked segments)
start timer
else stop timer
}
Sender TCP - Ritrasmissione veloce
 La perdita di segmenti viene dedotta da ACK
duplicati:
Il sender spesso invia tanti segmenti
 se un segmento è perso, ci saranno molti ACK
duplicati

 Al terzo ACK duplicato per lo stesso segmento,
il sender deduce che il segmento successivo è
andato perso
 ritrasmissione veloce (fast retransmit):
ritrasmissione del segmento prima del timeout
7
RTT e timeout
 Deve essere timeout > RTT, altrimenti
ritrasmissioni non necessarie
 RTT varia nel tempo
Se il timeout è troppo piccolo esiste rischio di
timeout prematuri, con ritrasmissioni inutili.
 Se il timeout è troppo grande, c’è scarsa efficienza
nella gestione delle ritrasmissioni.
 Algoritmo (Jacobson ‘88) che regola il timer in
base alla misurazione della rete

Stima di RTT
 SampleRTT = RTT campione = tempo tra la
trasmissione del segmento e il ricevimento
del riscontro relativo
 SampleRTT varia nel tempo:
EstimatedRTT = (1- ) * EstimatedRTT +  SampleRTT
 Parametro legato alla varianza di RTT
DevRTT=(1-)*DevRTT+*|SampleRTT–EstimatedRTT|
 Media esponenziale pesata (EWMA) dei
valori campioni: l’influenza dei campioni
vecchi decresce esponenzialmente

Valori tipici di  e sono 0.125 e 0.25
8
Timeout
 Timeout = EstimatedRTT + 4 * DevRTT
 Algoritmo di Karn: RTT dei segmenti
ritrasmessi non influisce su stima RTT.
Per ogni nuovo segmento si utilizza l’algoritmo di
Jacobson
 Per ogni segmento da ritrasmettere il timeout è
impostato al doppio del precedente. Dopo il
ricevimento di ACK o la ricezione di dati da livello
applicazione, il timeout viene impostato in base ai
valori più recenti di EstimatedRTT e DevRTT

TCP: apertura della connessione
 Prima dello scambio dati, sender e receiver si
"stringono la mano":


Concordano sull’aprire la connessione
Concordano su alcuni parametri
 A livello trasporto, la richiesta del client genera un
segmento TCP di richiesta connessione
 La sottorete di comunicazione può perdere o
duplicare i pacchetti
 Sono necessari protocolli sofisticati per attivare la
connessione
9
Apertura connessione (handshake)
 La richiesta del client è un segmento SYN (SYN bit posto
a 1) che indica il numero di sequenza iniziale
 Se sul server un processo è in attesa di richieste sulla
porta destinazione specificata nel segmento


il server alloca buffer e variabili per la connessione
invia un segmento di controllo SYNACK che contiene SYN bit
posto a 1, riscontro per SYN ricevuto, e numero di sequenza
iniziale per il server
 Se non esiste processo in attesa il server invia segmento
con RST=1
 Il client riceve SYNACK e alloca buffer e variabili per la
connessione. Invia ACK con SYN bit posto a 0 (può
contenere dati)
 Ogni segmento con SYN=1 conta come un singolo byte
Apertura della connessione
client state
server state
LISTEN
LISTEN
choose init seq num, x
send TCP SYN msg
SYNSENT
ESTAB
received SYNACK(x)
indicates server is live;
send ACK for SYNACK;
this segment may contain
client-to-server data
SYNbit=1, Seq=x
choose init seq num, y
send TCP SYNACK
SYN RCVD
msg, acking SYN
SYNbit=1, Seq=y
ACKbit=1; ACKnum=x+1
ACKbit=1, ACKnum=y+1
received ACK(y)
indicates client is live
ESTAB
10
TCP 3-way handshake: FSM
closed
Socket connectionSocket =
welcomeSocket.accept();

SYN(x)
SYNACK(seq=y,ACKnum=x+1)
create new socket for
communication back to client
listen
Socket clientSocket =
newSocket("hostname","port
number");
SYN(seq=x)
SYN
sent
SYN
rcvd
SYNACK(seq=y,ACKnum=x+1)
ACK(ACKnum=y+1)
ESTAB
ACK(ACKnum=y+1)

Apertura della connessione - esempi
11
Chiusura connessione
 Rilascio asimmetrico: dati in transito potrebbero
essere persi
Chiusura della connessione
 Rilascio simmetrico: le due entità devono
concordare prima di rilasciare l’intera
connessione
Da A a B: io sono pronto a chiudere, e tu?
 Da B a A: anch’io sono pronto.
 Da A a B: ok, arrivederci

 Ogni direzione è rilasciata indipendentemente
dall’altra: una entità continua a ricevere dati
anche dopo aver chiesto la chiusura
12
Chiusura della connessione
Il problema delle due armate
Chiusura connessione
 Three way handshake con timeout; non è
infallibile ma considerato adeguato
 Client (chi chiude la connessione) invia
segmento di controllo FIN, con FIN bit posto a 1:
entra in stato d’attesa per ACK
 ricevuto ACK, rilascia la connessione ed entra in stato
d’attesa per FIN
 ricevuto FIN invia ACK ed entra in stato TIME WAIT

 Server riceve FIN e risponde con ACK
 Invia FIN a client e fa partire timer
 riceve ACK, rilascia la connessione
13
TCP: chiusura connessione
client state
server state
ESTAB
ESTAB
clientSocket.close()
FIN_WAIT_1
FIN_WAIT_2
can no longer
send but can
receive data
FINbit=1, seq=x
CLOSE_WAIT
ACKbit=1; ACKnum=x+1
wait for server
close
FINbit=1, seq=y
TIME_WAIT
timed wait
for 2*max
segment lifetime
can still
send data
LAST_ACK
can no longer
send data
ACKbit=1; ACKnum=y+1
CLOSED
CLOSED
14

Download Report