2. TCP Window Scale Option (Opzione di scala della finestra TCP)

2.1 Introduction (Introduzione)

L'estensione di scala della finestra espande la definizione della finestra TCP a 32 bit e quindi utilizza un fattore di scala per trasportare questo valore a 32 bit nel campo Window a 16 bit dell'intestazione TCP (SEG.WND in RFC-793). Il fattore di scala viene trasportato in una nuova opzione TCP, Window Scale. Questa opzione viene inviata solo in un segmento SYN (un segmento con il bit SYN attivato), quindi la scala della finestra è fissata in ogni direzione quando viene aperta una connessione. (Un'altra scelta progettuale sarebbe quella di specificare la scala della finestra in ogni segmento TCP. Sarebbe errato inviare un'opzione di scala della finestra solo quando il fattore di scala cambia, poiché un'opzione TCP in un segmento di riconoscimento non verrà consegnata in modo affidabile (a meno che l'ACK non sia trasportato con dati nell'altra direzione). Fissare la scala quando viene aperta la connessione ha il vantaggio di un overhead inferiore ma lo svantaggio che il fattore di scala non può essere modificato durante la connessione.)

La finestra di ricezione massima, e quindi il fattore di scala, è determinata dallo spazio buffer di ricezione massimo. In un'implementazione moderna tipica, questo spazio buffer massimo è impostato per impostazione predefinita ma può essere sovrascritto da un programma utente prima dell'apertura di una connessione TCP. Questo determina il fattore di scala, e quindi non è necessaria alcuna nuova interfaccia utente per la scala della finestra.

2.2 Window Scale Option (Opzione di scala della finestra)

L'opzione Window Scale a tre byte può essere inviata in un segmento SYN da un TCP. Ha due scopi: (1) indicare che il TCP è pronto a eseguire sia la scala della finestra di invio che di ricezione, e (2) comunicare un fattore di scala da applicare alla sua finestra di ricezione. Pertanto, un TCP che è pronto a scalare le finestre dovrebbe inviare l'opzione, anche se il proprio fattore di scala è 1. Il fattore di scala è limitato a una potenza di due e codificato logaritmicamente, quindi può essere implementato mediante operazioni di shift binario.

TCP Window Scale Option (WSopt):

Kind: 3 Length: 3 bytes

       +---------+---------+---------+
       | Kind=3  |Length=3 |shift.cnt|
       +---------+---------+---------+

Questa opzione è un'offerta, non una promessa; entrambi i lati devono inviare opzioni Window Scale nei loro segmenti SYN per abilitare la scala della finestra in entrambe le direzioni. Se la scala della finestra è abilitata, allora il TCP che ha inviato questa opzione sposterà a destra i suoi veri valori di finestra di ricezione di 'shift.cnt' bit per la trasmissione in SEG.WND. Il valore 'shift.cnt' può essere zero (offrendo di scalare, mentre si applica un fattore di scala di 1 alla finestra di ricezione).

Questa opzione può essere inviata in un segmento `<SYN>` iniziale (cioè un segmento con il bit SYN attivato e il bit ACK disattivato). Può anche essere inviata in un segmento `<SYN,ACK>`, ma solo se un'opzione Window Scale è stata ricevuta nel segmento `<SYN>` iniziale. Un'opzione Window Scale in un segmento senza bit SYN dovrebbe essere ignorata.

Il campo Window in un segmento SYN (cioè un segmento `<SYN>` o `<SYN,ACK>`) stesso non viene mai scalato.

2.3 Using the Window Scale Option (Utilizzo dell'opzione di scala della finestra)

Un'implementazione modello della scala della finestra è la seguente, utilizzando la notazione di RFC-793 [Postel81]:

Tutte le finestre sono trattate come quantità a 32 bit per l'archiviazione nel blocco di controllo della connessione e per i calcoli locali. Ciò include i valori della finestra di invio (SND.WND) e della finestra di ricezione (RCV.WND), nonché la finestra di congestione.
Lo stato della connessione è aumentato da due conteggi di spostamento della finestra, Snd.Wind.Scale e Rcv.Wind.Scale, da applicare rispettivamente ai campi finestra in ingresso e in uscita.
Se un TCP riceve un segmento `<SYN>` contenente un'opzione Window Scale, invia la propria opzione Window Scale nel segmento `<SYN,ACK>`.
L'opzione Window Scale viene inviata con shift.cnt = R, dove R è il valore che il TCP desidera utilizzare per la sua finestra di ricezione.
Al ricevimento di un segmento SYN con un'opzione Window Scale contenente shift.cnt = S, un TCP imposta Snd.Wind.Scale su S e imposta Rcv.Wind.Scale su R; altrimenti, imposta sia Snd.Wind.Scale che Rcv.Wind.Scale su zero.
Il campo finestra (SEG.WND) nell'intestazione di ogni segmento in ingresso, ad eccezione dei segmenti SYN, viene spostato a sinistra di Snd.Wind.Scale bit prima di aggiornare SND.WND:
```
SND.WND = SEG.WND &lt;&lt; Snd.Wind.Scale
```
(assumendo che le altre condizioni di RFC793 siano soddisfatte, e utilizzando la notazione "C" "<<" per lo spostamento a sinistra).
Il campo finestra (SEG.WND) di ogni segmento in uscita, ad eccezione dei segmenti SYN, viene spostato a destra di Rcv.Wind.Scale bit:
```
SEG.WND = RCV.WND >> Rcv.Wind.Scale.
```

TCP determina se un segmento di dati è "vecchio" o "nuovo" testando se il suo numero di sequenza è entro 231 byte dal bordo sinistro della finestra, e se non lo è, scartando i dati come "vecchi". Per garantire che i nuovi dati non siano mai erroneamente considerati vecchi e viceversa, il bordo sinistro della finestra del mittente deve essere al massimo a 231 di distanza dal bordo destro della finestra del ricevitore. Similmente con il bordo destro del mittente e il bordo sinistro del ricevitore. Poiché i bordi destro e sinistro della finestra del mittente o del ricevitore differiscono per la dimensione della finestra, e poiché le finestre del mittente e del ricevitore possono essere sfasate al massimo per la dimensione della finestra, i vincoli di cui sopra implicano che 2 * la dimensione massima della finestra deve essere inferiore a 2**31, o

max window &lt; 2**30

Poiché la finestra massima è 2S (dove S è il conteggio di spostamento della scala) moltiplicato per al massimo 216 - 1 (la finestra massima non scalata), la finestra massima è garantita essere < 230 se S <= 14. Pertanto, il conteggio di spostamento deve essere limitato a 14 (che consente finestre di 230 = 1 Gbyte). Se viene ricevuta un'opzione Window Scale con un valore shift.cnt superiore a 14, il TCP dovrebbe registrare l'errore ma utilizzare 14 invece del valore specificato.

Il fattore di scala si applica solo al campo Window come trasmesso nell'intestazione TCP; ogni TCP che utilizza finestre estese manterrà i valori della finestra localmente come numeri a 32 bit. Ad esempio, la "finestra di congestione" calcolata da Slow Start e Congestion Avoidance non è influenzata dal fattore di scala, quindi la scala della finestra non introdurrà quantizzazione nella finestra di congestione.