Passa al contenuto principale

4. Working with Structured Fields in HTTP

Questa sezione definisce come serializzare e analizzare gli Structured Fields nei valori testuali dei campi HTTP e in altre codifiche compatibili, ad esempio in HTTP/2 [RFC7540] prima della compressione con HPACK [RFC7541].

4.1 Serializing Structured Fields​

Data una struttura definita da questa specifica, restituire una stringa ASCII adatta all'uso come valore di campo HTTP.

Algoritmo principale​

  1. Se la struttura è un Dictionary o una List e il suo valore è vuoto, cioè non ha membri, il campo non viene serializzato affatto, ovvero si omettono field-name e field-value.

  2. Se la struttura è una List, impostare output_string sul risultato dell'esecuzione di "Serializing a List", Sezione 4.1.1.

  3. Altrimenti, se la struttura è un Dictionary, impostare output_string sul risultato dell'esecuzione di "Serializing a Dictionary", Sezione 4.1.2.

  4. Altrimenti, se la struttura è un Item, impostare output_string sul risultato dell'esecuzione di "Serializing an Item", Sezione 4.1.3.

  5. Altrimenti, la serializzazione fallisce.

  6. Convertire output_string in un array di byte usando la codifica ASCII [RFC0020] e restituirlo.

4.1.1 Serializing a List​

Dato come input_list un array di tuple (member_value, parameters), restituire una stringa ASCII adatta all'uso come valore di campo HTTP.

Algoritmo​

  1. Impostare output alla stringa vuota.

  2. Per ogni (member_value, parameters) in input_list:

    • Se member_value è un array, aggiungere a output il risultato dell'esecuzione di "Serializing an Inner List", Sezione 4.1.1.1
    • Altrimenti, aggiungere a output il risultato dell'esecuzione di "Serializing an Item", Sezione 4.1.3
    • Se ci sono altri member_values in input_list:
      • Aggiungere "," a output
      • Aggiungere un singolo spazio (SP) a output

  3. Restituire output.

Esempi​

Input: [(1, {}), (2, {}), (3, {})]
Output: "1, 2, 3"

Input: [("foo", {}), ("bar", {a: 1})]
Output: "foo, bar;a=1"

4.1.1.1 Serializing an Inner List​

Dati un array di tuple (member_value, parameters) come inner_list e i parametri come list_parameters, restituire una stringa ASCII.

Algoritmo​

  1. Impostare output alla stringa "(".

  2. Per ogni (member_value, parameters) in inner_list:

    • Aggiungere a output il risultato dell'esecuzione di "Serializing an Item"
    • Se ci sono altri valori in inner_list, aggiungere un singolo spazio a output

  3. Aggiungere ")" a output.

  4. Aggiungere a output il risultato dell'esecuzione di "Serializing Parameters", Sezione 4.1.1.2.

  5. Restituire output.

Esempio​

Input: [(1, {}), (2, {})] with parameters {lvl: 5}
Output: "(1 2);lvl=5"

4.1.1.2 Serializing Parameters​

Dato come input_parameters un Dictionary ordinato, in cui ogni membro ha param_key e param_value, restituire una stringa ASCII.

Algoritmo​

  1. Impostare output alla stringa vuota.

  2. Per ogni param_key con valore param_value in input_parameters:

    • Aggiungere ";" a output
    • Aggiungere a output il risultato dell'esecuzione di "Serializing a Key", Sezione 4.1.1.3
    • Se param_value non è Boolean true:
      • Aggiungere "=" a output
      • Aggiungere a output il risultato dell'esecuzione di "Serializing a Bare Item"

  3. Restituire output.

Esempio​

Input: {a: 1, b: true, c: "value"}
Output: ";a=1;b;c=\"value\""

4.1.1.3 Serializing a Key​

Dato input_key come key, restituire una stringa ASCII.

Algoritmo​

  1. Convertire input_key in una sequenza di caratteri ASCII; se la conversione fallisce, la serializzazione fallisce.

  2. Se input_key contiene un carattere che non appartiene a lcalpha, DIGIT, "_", "-", "." o "*", la serializzazione fallisce.

  3. Se il primo carattere di input_key non è lcalpha o "*", la serializzazione fallisce.

  4. Restituire input_key.

Esempi di key valide​

+ "foo"
+ "foo_bar"
+ "foo-bar"
+ "*star"
- "Foo"      (maiuscola)
- "123foo"   (inizia con una cifra)

4.1.2 Serializing a Dictionary​

Dato come input_dictionary un Dictionary ordinato, in cui ogni membro ha member_key e un valore tupla (member_value, parameters), restituire una stringa ASCII.

Algoritmo​

  1. Impostare output alla stringa vuota.

  2. Per ogni member_key con valore (member_value, parameters) in input_dictionary:

    • Aggiungere a output il risultato dell'esecuzione di "Serializing a Key"
    • Se member_value è Boolean true:
      • Aggiungere a output il risultato dell'esecuzione di "Serializing Parameters"
    • Altrimenti:
      • Aggiungere "=" a output
      • Se member_value è un array, aggiungere il risultato dell'esecuzione di "Serializing an Inner List"
      • Altrimenti, aggiungere il risultato dell'esecuzione di "Serializing an Item"
    • Se ci sono altri membri in input_dictionary:
      • Aggiungere "," a output
      • Aggiungere un singolo spazio a output

  3. Restituire output.

Esempio​

Input: {a: 1, b: true, c: (2, 3)}
Output: "a=1, b, c=(2 3)"

4.1.3 Serializing an Item​

Dati un Item come bare_item e Parameters come item_parameters, restituire una stringa ASCII.

Algoritmo​

  1. Impostare output alla stringa vuota.
  2. Aggiungere a output il risultato dell'esecuzione di "Serializing a Bare Item", Sezione 4.1.3.1.
  3. Aggiungere a output il risultato dell'esecuzione di "Serializing Parameters".
  4. Restituire output.

4.1.3.1 Serializing a Bare Item​

Dato un Item come input_item, chiamare la funzione di serializzazione corrispondente in base al suo tipo:

  • Integer -> Sezione 4.1.4
  • Decimal -> Sezione 4.1.5
  • String -> Sezione 4.1.6
  • Token -> Sezione 4.1.7
  • Byte Sequence -> Sezione 4.1.8
  • Boolean -> Sezione 4.1.9

4.1.4 Serializing an Integer​

Algoritmo​

  1. Se input_integer non rientra nell'intervallo da -999,999,999,999,999 a 999,999,999,999,999 inclusi, la serializzazione fallisce.
  2. Se input_integer < 0, aggiungere "-".
  3. Aggiungere la rappresentazione decimale di input_integer.

Esempi​

42      -> "42"
-100    -> "-100"
0       -> "0"

4.1.5 Serializing a Decimal​

Algoritmo​

  1. Se non è un decimale, la serializzazione fallisce.
  2. Se ci sono più di 3 cifre significative a destra del punto decimale, arrotondare a 3 cifre.
  3. Se ci sono più di 12 cifre significative a sinistra del punto decimale, la serializzazione fallisce.
  4. Se input_decimal < 0, aggiungere "-".
  5. Aggiungere la rappresentazione decimale della parte intera.
  6. Aggiungere ".".
  7. Aggiungere la parte frazionaria; se è 0, aggiungere "0".

Esempi​

4.5       -> "4.5"
-0.123    -> "-0.123"
3.14159   -> "3.142"  (arrotondato)

4.1.6 Serializing a String​

Algoritmo​

  1. Convertire in una sequenza di caratteri ASCII; se la conversione fallisce, la serializzazione fallisce.
  2. Se contiene caratteri negli intervalli %x00-1f o %x7f-ff, la serializzazione fallisce.
  3. Aggiungere DQUOTE (").
  4. Per ogni carattere:
    • Se è "" o DQUOTE, aggiungere ""
    • Aggiungere il carattere
  5. Aggiungere DQUOTE.

Esempi​

hello world   -> "\"hello world\""
say "hi"      -> "\"say \\\"hi\\\"\""

4.1.7 Serializing a Token​

Algoritmo​

  1. Convertire in una sequenza di caratteri ASCII; se la conversione fallisce, la serializzazione fallisce.
  2. Verificare che il primo carattere sia ALPHA o "*".
  3. Verificare che i caratteri rimanenti appartengano a tchar, ":" o "/".
  4. Restituire input_token.

Esempi​

foo123/456       -> "foo123/456"
application/json -> "application/json"
*                -> "*"

4.1.8 Serializing a Byte Sequence​

Algoritmo​

  1. Se non è una Byte Sequence, la serializzazione fallisce.
  2. Aggiungere ":".
  3. Aggiungere input_bytes codificato in base64, secondo la Sezione 4 di [RFC4648].
  4. Aggiungere ":".

Esempio​

[0x48, 0x65, 0x6c, 0x6c, 0x6f]  -> ":SGVsbG8=:"

4.1.9 Serializing a Boolean​

Algoritmo​

  1. Se non è un boolean, la serializzazione fallisce.
  2. Aggiungere "?".
  3. Se true, aggiungere "1"; se false, aggiungere "0".

Esempio​

true   -> "?1"
false  -> "?0"

4.2 Parsing Structured Fields​

Quando un'implementazione ricevente analizza un campo HTTP noto come Structured Field, deve prestare attenzione, perché molti casi limite possono causare problemi di interoperabilità o persino di sicurezza. Questa sezione specifica gli algoritmi per eseguire tale operazione.

Algoritmo principale​

Dati un array di byte input_bytes che rappresenta il field-value del campo scelto, vuoto se il campo non esiste, e field_type, uno tra "dictionary", "list" o "item", restituire il valore header analizzato.

  1. Convertire input_bytes in una stringa ASCII input_string; se la conversione fallisce, il parsing fallisce.

  2. Scartare tutti i caratteri SP all'inizio di input_string.

  3. Se field_type è "list", impostare output sul risultato dell'esecuzione di "Parsing a List", Sezione 4.2.1.

  4. Se field_type è "dictionary", impostare output sul risultato dell'esecuzione di "Parsing a Dictionary", Sezione 4.2.2.

  5. Se field_type è "item", impostare output sul risultato dell'esecuzione di "Parsing an Item", Sezione 4.2.3.

  6. Scartare tutti i caratteri SP all'inizio di input_string.

  7. Se input_string non è vuota, il parsing fallisce.

  8. Altrimenti, restituire output.

Principi chiave​

  • Parsing rigoroso: qualsiasi errore causa l'ignoramento dell'intero campo
  • Nessuna tolleranza agli errori: non si tenta di "riparare" input malformato
  • Sicurezza prima di tutto: prevenire attacchi di injection e ambiguità
  • Combinazione dei campi: il parser deve combinare in un unico field-value separato da virgole tutte le righe di campo nella stessa sezione, header o trailer, il cui nome corrisponde in modo case-insensitive

Note importanti​

Per Lists e Dictionaries, questo concatena correttamente tutte le righe del campo purché i singoli membri della struttura dati di primo livello non siano divisi tra più istanze di header.

Se il parsing fallisce, incluso durante la chiamata ad altri algoritmi, l'intero valore del campo MUST essere ignorato, cioè trattato come se il campo non fosse presente nella sezione. Questa rigorosità è intenzionale per migliorare interoperabilità e sicurezza, e le specifiche che fanno riferimento a questo documento non possono allentare tale requisito.

4.2.1 Parsing a List​

Data una stringa ASCII input_string, restituire un array di tuple (item_or_inner_list, parameters). input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Impostare members a un array vuoto.

  2. Mentre input_string non è vuota:

    • Aggiungere a members il risultato dell'esecuzione di "Parsing an Item or Inner List", Sezione 4.2.1.1
    • Scartare tutti i caratteri OWS all'inizio di input_string
    • Se input_string è vuota, restituire members
    • Consumare il primo carattere di input_string; se non è ",", il parsing fallisce
    • Scartare tutti i caratteri OWS all'inizio di input_string
    • Se input_string è vuota, esiste una virgola finale; il parsing fallisce

  3. Non è stata trovata alcuna struttura dati; restituire members, che è vuoto.

4.2.1.1 Parsing an Item or Inner List​

Data una stringa ASCII input_string, restituire una tupla (item_or_inner_list, parameters), dove item_or_inner_list può essere un singolo bare item oppure un array di tuple (bare_item, parameters). input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string è "(", restituire il risultato dell'esecuzione di "Parsing an Inner List", Sezione 4.2.1.2.

  2. Restituire il risultato dell'esecuzione di "Parsing an Item", Sezione 4.2.3.

4.2.1.2 Parsing an Inner List​

Data una stringa ASCII input_string, restituire una tupla (inner_list, parameters), dove inner_list è un array di tuple (bare_item, parameters). input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Consumare il primo carattere di input_string; se non è "(", il parsing fallisce.

  2. Impostare inner_list a un array vuoto.

  3. Mentre input_string non è vuota:

    • Scartare tutti i caratteri SP all'inizio di input_string
    • Se il primo carattere di input_string è ")":
      • Consumare il primo carattere di input_string
      • Impostare parameters al risultato dell'esecuzione di "Parsing Parameters", Sezione 4.2.3.2
      • Restituire la tupla (inner_list, parameters)
    • Impostare item al risultato dell'esecuzione di "Parsing an Item", Sezione 4.2.3
    • Aggiungere item a inner_list
    • Se il primo carattere di input_string non è SP né ")", il parsing fallisce

  4. Non è stata trovata la fine dell'Inner List; il parsing fallisce.

4.2.2 Parsing a Dictionary​

Data una stringa ASCII input_string, restituire una mappa ordinata con valori tuple (item_or_inner_list, parameters). input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Impostare dictionary a una mappa ordinata vuota.

  2. Mentre input_string non è vuota:

    • Impostare this_key al risultato dell'esecuzione di "Parsing a Key", Sezione 4.2.3.3
    • Se il primo carattere di input_string è "=":
      • Consumare il primo carattere di input_string
      • Impostare member al risultato dell'esecuzione di "Parsing an Item or Inner List", Sezione 4.2.1.1
    • Altrimenti:
      • Impostare value a Boolean true
      • Impostare parameters al risultato dell'esecuzione di "Parsing Parameters", Sezione 4.2.3.2
      • Impostare member alla tupla (value, parameters)
    • Se dictionary contiene già la chiave this_key, confrontata carattere per carattere, sostituire il suo valore con member
    • Altrimenti, aggiungere a dictionary la chiave this_key e il valore member
    • Scartare tutti i caratteri OWS all'inizio di input_string
    • Se input_string è vuota, restituire dictionary
    • Consumare il primo carattere di input_string; se non è ",", il parsing fallisce
    • Scartare tutti i caratteri OWS all'inizio di input_string
    • Se input_string è vuota, esiste una virgola finale; il parsing fallisce

  3. Non è stata trovata alcuna struttura dati; restituire dictionary, che è vuoto.

Nota: quando si incontrano chiavi Dictionary duplicate, tutte le istanze tranne l'ultima vengono ignorate.

4.2.3 Parsing an Item​

Data una stringa ASCII input_string, restituire una tupla (bare_item, parameters). input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Impostare bare_item al risultato dell'esecuzione di "Parsing a Bare Item", Sezione 4.2.3.1.

  2. Impostare parameters al risultato dell'esecuzione di "Parsing Parameters", Sezione 4.2.3.2.

  3. Restituire la tupla (bare_item, parameters).

4.2.3.1 Parsing a Bare Item​

Data una stringa ASCII input_string, restituire un bare Item. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string è "-" o DIGIT, restituire il risultato dell'esecuzione di "Parsing an Integer or Decimal", Sezione 4.2.4.

  2. Se il primo carattere di input_string è DQUOTE, restituire il risultato dell'esecuzione di "Parsing a String", Sezione 4.2.5.

  3. Se il primo carattere di input_string è ALPHA o "*", restituire il risultato dell'esecuzione di "Parsing a Token", Sezione 4.2.6.

  4. Se il primo carattere di input_string è ":", restituire il risultato dell'esecuzione di "Parsing a Byte Sequence", Sezione 4.2.7.

  5. Se il primo carattere di input_string è "?", restituire il risultato dell'esecuzione di "Parsing a Boolean", Sezione 4.2.8.

  6. Altrimenti, il tipo dell'item non è riconosciuto; il parsing fallisce.

4.2.3.2 Parsing Parameters​

Data una stringa ASCII input_string, restituire una mappa ordinata con bare Items come valori. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Impostare parameters a una mappa ordinata vuota.

  2. Mentre input_string non è vuota:

    • Se il primo carattere di input_string non è ";", uscire dal ciclo
    • Consumare il carattere ";" all'inizio di input_string
    • Scartare tutti i caratteri SP all'inizio di input_string
    • Impostare param_key al risultato dell'esecuzione di "Parsing a Key", Sezione 4.2.3.3
    • Impostare param_value a Boolean true
    • Se il primo carattere di input_string è "=":
      • Consumare il carattere "=" all'inizio di input_string
      • Impostare param_value al risultato dell'esecuzione di "Parsing a Bare Item", Sezione 4.2.3.1
    • Se parameters contiene già la chiave param_key, confrontata carattere per carattere, sostituire il suo valore con param_value
    • Altrimenti, aggiungere a parameters la chiave param_key e il valore param_value

  3. Restituire parameters.

Nota: quando si incontrano chiavi parametro duplicate, tutte le istanze tranne l'ultima vengono ignorate.

4.2.3.3 Parsing a Key​

Data una stringa ASCII input_string, restituire key. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string non è lcalpha o "*", il parsing fallisce.

  2. Impostare output_string alla stringa vuota.

  3. Mentre input_string non è vuota:

    • Se il primo carattere di input_string non è uno tra lcalpha, DIGIT, "_", "-", "." o "*", restituire output_string
    • Impostare char al risultato del consumo del primo carattere di input_string
    • Aggiungere char a output_string

  4. Restituire output_string.

4.2.4 Parsing an Integer or Decimal​

Data una stringa ASCII input_string, restituire Integer o Decimal. input_string viene modificata per rimuovere i valori analizzati.

Nota: questo algoritmo analizza sia Integers, Sezione 3.3.1, sia Decimals, Sezione 3.3.2, e restituisce la struttura corrispondente.

Algoritmo​

  1. Impostare type a "integer".

  2. Impostare sign a 1.

  3. Impostare input_number alla stringa vuota.

  4. Se il primo carattere di input_string è "-", consumarlo e impostare sign a -1.

  5. Se input_string è vuota, esiste un integer vuoto; il parsing fallisce.

  6. Se il primo carattere di input_string non è DIGIT, il parsing fallisce.

  7. Mentre input_string non è vuota:

    • Impostare char al risultato del consumo del primo carattere di input_string
    • Se char è DIGIT, aggiungerlo a input_number
    • Altrimenti, se type è "integer" e char è ".":
      • Se input_number contiene più di 12 caratteri, il parsing fallisce
      • Altrimenti, aggiungere char a input_number e impostare type a "decimal"
    • Altrimenti, anteporre char a input_string e uscire dal ciclo
    • Se type è "integer" e input_number contiene più di 15 caratteri, il parsing fallisce
    • Se type è "decimal" e input_number contiene più di 16 caratteri, il parsing fallisce

  8. Se type è "integer":

    • Analizzare input_number come intero e impostare output_number al risultato moltiplicato per sign

  9. Altrimenti:

    • Se l'ultimo carattere di input_number è ".", il parsing fallisce
    • Se il numero di caratteri dopo "." in input_number è maggiore di 3, il parsing fallisce
    • Analizzare input_number come numero decimale e impostare output_number al risultato moltiplicato per sign

  10. Restituire output_number.

4.2.5 Parsing a String​

Data una stringa ASCII input_string, restituire la String senza apici. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Impostare output_string alla stringa vuota.

  2. Se il primo carattere di input_string non è DQUOTE, il parsing fallisce.

  3. Scartare il primo carattere di input_string.

  4. Mentre input_string non è vuota:

    • Impostare char al risultato del consumo del primo carattere di input_string
    • Se char è una barra inversa ("\"):
      • Se input_string ora è vuota, il parsing fallisce
      • Impostare next_char al risultato del consumo del primo carattere di input_string
      • Se next_char non è DQUOTE né "\", il parsing fallisce
      • Aggiungere next_char a output_string
    • Altrimenti, se char è DQUOTE, restituire output_string
    • Altrimenti, se char è nell'intervallo %x00-1f o %x7f-ff, cioè non è in VCHAR o SP, il parsing fallisce
    • Altrimenti, aggiungere char a output_string

  5. È stata raggiunta la fine di input_string senza trovare il DQUOTE finale; il parsing fallisce.

4.2.6 Parsing a Token​

Data una stringa ASCII input_string, restituire Token. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string non è ALPHA o "*", il parsing fallisce.

  2. Impostare output_string alla stringa vuota.

  3. Mentre input_string non è vuota:

    • Se il primo carattere di input_string non appartiene a tchar, ":" o "/", restituire output_string
    • Impostare char al risultato del consumo del primo carattere di input_string
    • Aggiungere char a output_string

  4. Restituire output_string.

4.2.7 Parsing a Byte Sequence​

Data una stringa ASCII input_string, restituire Byte Sequence. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string non è ":", il parsing fallisce.

  2. Scartare il primo carattere di input_string.

  3. Se non c'è un carattere ":" prima della fine di input_string, il parsing fallisce.

  4. Impostare b64_content al risultato del consumo del contenuto di input_string fino alla prima occorrenza del carattere ":", esclusa.

  5. Consumare il carattere ":" all'inizio di input_string.

  6. Se b64_content contiene un carattere che non appartiene ad ALPHA, DIGIT, "+", "/" e "=", il parsing fallisce.

  7. Impostare binary_content al risultato della decodifica base64 [RFC4648] di b64_content, sintetizzando il padding quando necessario, vedere sotto i requisiti sul comportamento del destinatario. Se la decodifica base64 fallisce, il parsing fallisce.

  8. Restituire binary_content.

Note implementative:

  • Poiché alcune implementazioni base64 non consentono di rifiutare dati codificati senza padding "=" corretto, i parser SHOULD NOT fallire quando il padding "=" è assente, a meno che non sia impossibile configurarli in tal modo.
  • Poiché alcune implementazioni base64 non consentono di rifiutare dati codificati con bit di padding non nulli, i parser SHOULD NOT fallire in presenza di bit di padding non nulli, a meno che non sia impossibile configurarli in tal modo.
  • I parser MUST fallire sui caratteri fuori dall'alfabeto base64 e sui caratteri di nuova riga nei dati codificati.

4.2.8 Parsing a Boolean​

Data una stringa ASCII input_string, restituire Boolean. input_string viene modificata per rimuovere i valori analizzati.

Algoritmo​

  1. Se il primo carattere di input_string non è "?", il parsing fallisce.

  2. Scartare il primo carattere di input_string.

  3. Se il primo carattere di input_string corrisponde a "1", scartare il primo carattere e restituire true.

  4. Se il primo carattere di input_string corrisponde a "0", scartare il primo carattere e restituire false.

  5. Nessun valore corrisponde; il parsing fallisce.

Esempio Completo di Parsing​

Esempio di parsing di List​

// Stringa di input
"42;a=1, foo, (1 2);b"

// Risultato del parsing
[
  (42, {a: 1}),
  ("foo", {}),
  ([1, 2], {b: true})
]

Esempio di parsing di Dictionary​

// Stringa di input
"key1=42;a=1, key2, key3=(1 2)"

// Risultato del parsing
{
  key1: (42, {a: 1}),
  key2: (true, {}),
  key3: ([1, 2], {})
}

Esempio di parsing di Item​

// Stringa di input
"42;foo=\"bar\";flag"

// Risultato del parsing
(42, {foo: "bar", flag: true})

Esempio Completo di Serializzazione​

Esempio di List​

// Input
[
  (42, {a: 1}),
  ("foo", {}),
  ([1, 2], {b: true})
]

// Output
"42;a=1, foo, (1 2);b"

Esempio di Dictionary​

// Input
{
  key1: (42, {a: 1}),
  key2: (true, {}),
  key3: ([1, 2], {})
}

// Output
"key1=42;a=1, key2, key3=(1 2)"

Esempio di Item​

// Input
(42, {foo: "bar", flag: true})

// Output
"42;foo=\"bar\";flag"

Punti Chiave​

Serializzazione​

  1. Gestione dei valori vuoti: List e Dictionary vuoti non vengono serializzati, quindi l'intero campo viene omesso.
  2. Forma abbreviata per Boolean: per il valore true si omette la parte "=value".
  3. Formato rigoroso: ogni tipo ha requisiti di formato precisi.
  4. Fallimento immediato: qualsiasi errore di validazione fa fallire l'intera serializzazione.

Suggerimento implementativo​

// Esempio di pseudocodice
function serializeStructuredField(field) {
  if (isEmpty(field)) {
    return null;  // non serializzare
  }
  
  try {
    if (field.type === 'list') {
      return serializeList(field.value);
    } else if (field.type === 'dictionary') {
      return serializeDictionary(field.value);
    } else if (field.type === 'item') {
      return serializeItem(field.value, field.parameters);
    }
  } catch (error) {
    // Serializzazione fallita, restituire un errore
    throw new SerializationError(error);
  }
}

Anteprima della Sezione Successiva​

La Sezione 4.2, algoritmi di parsing, è altrettanto importante e definisce come trasformare i valori dei campi HTTP in dati strutturati. Gli algoritmi di parsing assicurano validazione rigorosa e gestione coerente degli errori.

Nota: poiché gli algoritmi di parsing sono molto dettagliati e simmetrici alla serializzazione, le implementazioni devono consultare la specifica RFC 8941 completa per garantire piena conformità.

Ultimo aggiornamento il