4.5 Fragment Header (Intestazione di frammento)

La Fragment header viene usata da una sorgente IPv6 per inviare pacchetti più grandi della MTU del percorso verso la destinazione. Nota: diversamente da IPv4, in IPv6 la frammentazione è eseguita solo dai nodi sorgente, non dai router lungo il percorso di consegna del pacchetto; vedere la Sezione 5. La Fragment header è identificata dal valore 44 di Next Header nell'intestazione immediatamente precedente e ha il formato seguente:

+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  Next Header  |   Reserved    |      Fragment Offset    |Res|M|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         Identification                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Next Header (intestazione successiva) - Selettore a 8 bit. Identifica il tipo dell'intestazione iniziale della Fragmentable Part (parte frammentabile), definita di seguito, del pacchetto originale. Usa gli stessi valori del campo IPv4 Protocol [RFC-1700 et seq.].

Reserved (riservato) - Campo riservato a 8 bit. Inizializzato a zero alla trasmissione; ignorato alla ricezione.

Fragment Offset (offset del frammento) - Intero senza segno a 13 bit. Offset, in unità di 8 ottetti, dei dati che seguono questa intestazione rispetto all'inizio della Fragmentable Part del pacchetto originale.

Res (riservato) - Campo riservato a 2 bit. Inizializzato a zero alla trasmissione; ignorato alla ricezione.

M flag (flag M) - 1 = altri frammenti seguono; 0 = ultimo frammento.

Identification (identificazione) - 32 bit. Vedere la descrizione seguente.

Per inviare un pacchetto troppo grande per la MTU del percorso verso la destinazione, il nodo sorgente può dividere il pacchetto in frammenti e inviare ogni frammento come pacchetto separato, affinché venga riassemblato dal ricevitore.

Per ogni pacchetto da frammentare, il nodo sorgente genera un valore Identification. Tale Identification deve essere diversa dall'identificazione di qualsiasi altro pacchetto frammentato inviato di recente* con gli stessi Source Address e Destination Address. Se è presente una Routing header, il Destination Address di interesse è l'indirizzo della destinazione finale.

*"Di recente" significa entro la massima durata possibile del pacchetto, incluso il tempo di trasmissione dalla sorgente alla destinazione e il tempo trascorso in attesa del riassemblaggio con altri frammenti dello stesso pacchetto. Tuttavia, non è richiesto che il nodo sorgente conosca la massima durata del pacchetto. Si assume invece che questo requisito possa essere soddisfatto usando per Identification un semplice contatore a 32 bit con ritorno ciclico (wrap-around), incrementato ogni volta che un pacchetto deve essere frammentato. La scelta di mantenere un singolo contatore per il nodo, oppure più contatori, ad esempio uno per ogni possibile indirizzo sorgente del nodo o uno per ogni combinazione attiva (indirizzo sorgente, indirizzo destinazione), è una scelta di implementazione.

Struttura del pacchetto originale

Il pacchetto iniziale, grande e non frammentato, chiamato "pacchetto originale (original packet)", è considerato composto da due parti, come segue:

original packet:

+------------------+----------------------//-----------------------+
|  Unfragmentable  |                 Fragmentable                  |
|       Part       |                     Part                      |
+------------------+----------------------//-----------------------+

La Unfragmentable Part (parte non frammentabile) è composta dall'intestazione IPv6 più qualsiasi intestazione di estensione che deve essere elaborata dai nodi lungo il percorso verso la destinazione, cioè tutte le intestazioni fino alla Routing header inclusa, se presente; altrimenti fino alla Hop-by-Hop Options header inclusa, se presente; altrimenti nessuna intestazione di estensione.

La Fragmentable Part (parte frammentabile) è composta dal resto del pacchetto, cioè da qualsiasi intestazione di estensione che debba essere elaborata solo dal nodo di destinazione finale, più l'intestazione e i dati di livello superiore.

La Fragmentable Part del pacchetto originale viene suddivisa in frammenti, ciascuno dei quali, forse con l'eccezione dell'ultimo frammento, quello più a destra (rightmost), ha lunghezza pari a un multiplo intero di 8 ottetti. Questi frammenti sono trasmessi in pacchetti frammento (fragment packets) separati, come segue:

original packet:

+------------------+--------------+--------------+--//--+----------+
|  Unfragmentable  |    first     |    second    |      |   last   |
|       Part       |   fragment   |   fragment   | .... | fragment |
+------------------+--------------+--------------+--//--+----------+

fragment packets:

+------------------+--------+--------------+
|  Unfragmentable  |Fragment|    first     |
|       Part       | Header |   fragment   |
+------------------+--------+--------------+

+------------------+--------+--------------+
|  Unfragmentable  |Fragment|    second    |
|       Part       | Header |   fragment   |
+------------------+--------+--------------+
                      o
                      o
                      o
+------------------+--------+----------+
|  Unfragmentable  |Fragment|   last   |
|       Part       | Header | fragment |
+------------------+--------+----------+

Composizione dei pacchetti frammento

Ogni pacchetto frammento è composto dalle parti seguenti:

(1) La Unfragmentable Part del pacchetto originale, con il Payload Length dell'intestazione IPv6 originale modificato in modo da contenere solo la lunghezza di questo pacchetto frammento, esclusa la lunghezza dell'intestazione IPv6 stessa, e con il campo Next Header dell'ultima intestazione della Unfragmentable Part modificato a 44.

(2) Una Fragment header, contenente:

• Il valore Next Header che identifica la prima intestazione della Fragmentable Part del pacchetto originale.

• Il Fragment Offset, che contiene l'offset del frammento rispetto all'inizio della Fragmentable Part del pacchetto originale, in unità di 8 ottetti. Il Fragment Offset del primo frammento, quello più a sinistra (leftmost), è 0.

• Un valore M flag pari a 0 se il frammento è l'ultimo, quello più a destra (rightmost), altrimenti pari a 1.

• Il valore Identification generato per il pacchetto originale.

(3) Il frammento stesso.

La lunghezza dei frammenti deve essere scelta in modo che i pacchetti frammento risultanti si adattino alla MTU del percorso verso la destinazione del pacchetto.

Processo di riassemblaggio

Alla destinazione, i pacchetti frammento vengono riassemblati nella loro forma originale non frammentata, come segue:

reassembled original packet:

+------------------+----------------------//------------------------+
|  Unfragmentable  |                 Fragmentable                   |
|       Part       |                     Part                       |
+------------------+----------------------//------------------------+

Le regole seguenti governano il riassemblaggio:

Il pacchetto originale viene riassemblato solo da pacchetti frammento aventi gli stessi Source Address, Destination Address e Fragment Identification.

La Unfragmentable Part del pacchetto riassemblato è composta da tutte le intestazioni fino alla Fragment header del primo pacchetto frammento, cioè quello con Fragment Offset pari a zero, ma esclusa tale Fragment header, con le due modifiche seguenti:

• Il campo Next Header dell'ultima intestazione della Unfragmentable Part è ottenuto dal campo Next Header della Fragment header del primo frammento.

• Il Payload Length del pacchetto riassemblato è calcolato dalla lunghezza della Unfragmentable Part e dalla lunghezza e dall'offset dell'ultimo frammento. Per esempio, la formula per calcolare il Payload Length del pacchetto originale riassemblato è:

PL.orig = PL.first - FL.first - 8 + (8 * FO.last) + FL.last

where
PL.orig  = Payload Length field of reassembled packet.
PL.first = Payload Length field of first fragment packet.
FL.first = length of fragment following Fragment header of
           first fragment packet.
FO.last  = Fragment Offset field of Fragment header of
           last fragment packet.
FL.last  = length of fragment following Fragment header of
           last fragment packet.

La Fragmentable Part del pacchetto riassemblato è costruita dai frammenti che seguono le Fragment headers in ciascun pacchetto frammento. La lunghezza di ciascun frammento viene calcolata sottraendo dal Payload Length del pacchetto la lunghezza delle intestazioni tra l'intestazione IPv6 e il frammento stesso; la sua posizione relativa nella Fragmentable Part viene calcolata dal valore Fragment Offset.

La Fragment header non è presente nel pacchetto finale riassemblato.

Condizioni di errore

Durante il riassemblaggio dei pacchetti frammentati possono verificarsi le seguenti condizioni di errore:

Errore di timeout: se, entro 60 secondi dalla ricezione del primo frammento arrivato per quel pacchetto, non vengono ricevuti abbastanza frammenti per completare il riassemblaggio del pacchetto, il riassemblaggio di quel pacchetto deve essere abbandonato e tutti i frammenti già ricevuti per quel pacchetto devono essere scartati. Se è stato ricevuto il primo frammento, cioè quello con Fragment Offset pari a zero, dovrebbe essere inviato alla sorgente di tale frammento un messaggio ICMP Time Exceeded -- Fragment Reassembly Time Exceeded.

Errore di lunghezza: se la lunghezza del frammento, derivata dal campo Payload Length del pacchetto frammento, non è un multiplo di 8 ottetti e il M flag di quel frammento è 1, il frammento deve essere scartato e dovrebbe essere inviato alla sorgente del frammento un messaggio ICMP Parameter Problem, Code 0, che punta al campo Payload Length del pacchetto frammento.

Errore di pacchetto troppo grande: se la lunghezza e l'offset di un frammento fanno sì che il Payload Length del pacchetto riassemblato da quel frammento superi 65,535 ottetti, il frammento deve essere scartato e dovrebbe essere inviato alla sorgente del frammento un messaggio ICMP Parameter Problem, Code 0, che punta al campo Fragment Offset del pacchetto frammento.

Condizioni non errate

Le situazioni seguenti non sono previste, ma se si verificano non sono considerate errori:

Differenze nelle intestazioni: il numero e il contenuto delle intestazioni precedenti la Fragment header in frammenti diversi dello stesso pacchetto originale possono differire. Qualunque intestazione sia presente prima della Fragment header in ogni pacchetto frammento viene elaborata all'arrivo del pacchetto, prima che il frammento sia accodato per il riassemblaggio. Solo le intestazioni del pacchetto frammento con offset pari a zero vengono conservate nel pacchetto riassemblato.

Differenze in Next Header: i valori Next Header nelle Fragment headers di frammenti diversi dello stesso pacchetto originale possono differire. Per il riassemblaggio viene usato solo il valore del pacchetto frammento con offset pari a zero.