5. Rappresentazioni di tipi primitivi (Primitive Type Representations)

La codifica HPACK utilizza due tipi primitivi: interi non firmati di lunghezza variabile e stringhe di ottetti.

5.1. Rappresentazione di interi (Integer Representation)

Gli interi sono utilizzati per rappresentare indici di nomi, indici di campi di intestazione o lunghezze di stringhe. Una rappresentazione di intero può iniziare ovunque all'interno di un ottetto. Per consentire un'elaborazione ottimale, una rappresentazione di intero termina sempre alla fine di un ottetto.

Un intero è rappresentato in due parti: un prefisso che riempie l'ottetto corrente e un elenco opzionale di ottetti che vengono utilizzati se il valore intero non si adatta al prefisso. Il numero di bit del prefisso (chiamato N) è un parametro della rappresentazione dell'intero.

Se il valore intero è sufficientemente piccolo, cioè strettamente inferiore a 2^N-1, viene codificato nel prefisso di N bit.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | ? |       Value       |
+---+---+---+-------------------+

    Figura 2: Valore intero codificato nel prefisso (N = 5)

Altrimenti, tutti i bit del prefisso sono impostati a 1, e il valore, diminuito di 2^N-1, viene codificato utilizzando un elenco di uno o più ottetti. Il bit più significativo di ciascun ottetto viene utilizzato come indicatore di continuazione: il suo valore è impostato a 1 tranne che per l'ultimo ottetto dell'elenco. I bit rimanenti degli ottetti vengono utilizzati per codificare il valore diminuito.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | ? | 1   1   1   1   1 |
+---+---+---+-------------------+
| 1 |    Value-(2^N-1) LSB      |
+---+---------------------------+
               ...
+---+---------------------------+
| 0 |    Value-(2^N-1) MSB      |
+---+---------------------------+

    Figura 3: Valore intero codificato dopo il prefisso (N = 5)

La decodifica del valore intero dall'elenco di ottetti inizia invertendo l'ordine degli ottetti nell'elenco. Quindi, per ciascun ottetto, il suo bit più significativo viene rimosso. I bit rimanenti degli ottetti vengono concatenati, e il valore risultante viene aumentato di 2^N-1 per ottenere il valore intero.

La dimensione del prefisso, N, è sempre compresa tra 1 e 8 bit. Un intero che inizia al confine di un ottetto avrà un prefisso di 8 bit.

Pseudo-codice per rappresentare un intero I:

if I < 2^N - 1, encode I on N bits
else
    encode (2^N - 1) on N bits
    I = I - (2^N - 1)
    while I >= 128
         encode (I % 128 + 128) on 8 bits
         I = I / 128
    encode I on 8 bits

Pseudo-codice per decodificare un intero I:

decode I from the next N bits
if I < 2^N - 1, return I
else
    M = 0
    repeat
        B = next octet
        I = I + (B & 127) * 2^M
        M = M + 7
    while B & 128 == 128
    return I

Esempi che illustrano la codifica degli interi sono disponibili nell'appendice C.1.

Questa rappresentazione di interi consente valori di dimensione indefinita. È anche possibile per un codificatore inviare un gran numero di valori zero, che può sprecare ottetti e potrebbe essere utilizzato per causare overflow di valori interi. Le codifiche di interi che superano i limiti di implementazione -- in valore o in lunghezza di ottetti -- DEVONO (MUST) essere trattate come errori di decodifica. Limiti diversi possono essere definiti per ciascuno dei diversi usi degli interi, a seconda dei vincoli di implementazione.

5.2. Rappresentazione di letterali di stringa (String Literal Representation)

I nomi dei campi di intestazione e i valori dei campi di intestazione possono essere rappresentati come letterali di stringa (String Literal). Un letterale di stringa è codificato come una sequenza di ottetti, sia codificando direttamente gli ottetti del letterale di stringa, sia utilizzando un codice di Huffman (vedere [HUFFMAN]).

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| H |    String Length (7+)     |
+---+---------------------------+
|  String Data (Length octets)  |
+-------------------------------+

            Figura 4: Rappresentazione di letterale di stringa

Una rappresentazione di letterale di stringa contiene i seguenti campi:

H: Un flag a un bit, H, che indica se gli ottetti della stringa sono codificati con Huffman o meno.

Lunghezza della stringa (String Length): Il numero di ottetti utilizzati per codificare il letterale di stringa, codificato come un intero con un prefisso di 7 bit (vedere sezione 5.1).

Dati della stringa (String Data): I dati codificati del letterale di stringa. Se H vale '0', allora i dati codificati sono gli ottetti grezzi del letterale di stringa. Se H vale '1', allora i dati codificati sono la codifica di Huffman del letterale di stringa.

I letterali di stringa che utilizzano la codifica di Huffman sono codificati con il codice di Huffman definito nell'appendice B.

---