# data[].attributes.body
Il PAT si occupa della traduzione dei numeri delle porte in modo da accedere a molteplici host con un singolo indirizzo IP.
La tabella degli indirizzi è statica.

# data[].attributes.body
L'intestazione IP è costituita da alcuni gruppi di 4 byte

# data[].attributes.body
Utilizzato per la frammentazione

È una richiesta ai router di non frammentare il   datagramma poiché la destinazione non è in grado di rimettere insieme i pezzi.

-Tutti i frammenti tranne l'ultimo hanno questo bit impostato. È necessario sapere se sono arrivati ​​tutti i frammenti di un datagramma.

# data[].attributes.body
L'ICMP message è contenuto dal Payload dell' IP e contiene :

Tipo : Tipo di messaggio(errore - informazione).
Codice : Descrive il tipo di errore.
Checksum : Stringa di controllo dell'errore.

# data[].attributes.body
L' ICMP è un insieme di messaggi di controllo che svolgono diverse funzioni:

Segnalano errori di un Datagram.

Generano messaggi amministrativi (congestioni di traffico ecc.)

Generano messaggi di stato della rete

Lavora a livello dell' Internet IP.
L'ICMP non rende affidabile il protocollo IP ma ne segnala gli errori e i malfunzionamenti.

# data[].attributes.body
Consiste in bit privi di significato aggiunti in funzione della lunghezza del campo precedente per far sì che l’intestazione sia multipla di 32 bit

# data[].attributes.body
Ha lunghezza variabile e contiene opzioni relative al trasferimento del datagramma

# data[].attributes.body
nome del protocollo che ha richiesto il servizio

# data[].attributes.body
corrisponde agli indirizzi dell'host mittente e destinatario

# data[].attributes.body
corrisponde al tempo massimo di permanenza del datagramma nella rete
determinato da un  numero di "hop" fino  al nodo destinatario

# data[].attributes.body
Valore intero che serve all'host ricevente per identificare univocamente un datagramma

# data[].attributes.body
Specifica la lunghezza totale del datagramma misurata in byte

# data[].attributes.body
E' il campo che identifica la versione del protocollo IP

# data[].attributes.body
Il Supernetting consiste nell'unione di più reti per la creazione di una rete con un maggior numero di host
Es.

Realizzare un piano d’indirizzamento di una rete partendo dall’Ip: 195.168.0.0 per 2050 host.

1. Determinare il numero di indirizzi di classe C di cui ho bisogno:

x = (2050 + 3)/256 = 8,01(arrotondiamo per eccesso) → x=8+1=9 → 9*256=2304

2. Scrivo le reti di cui necessito:
9 reti di classe C:

195.168.0.0/24

195.168.1.0/24

195.168.2.0/24

195.168.3.0/24

195.168.4.0/24

195.168.5.0/24

195.168.6.0/24

195.168.7.0/24

195.168.8.0/24

3. Determinare il numero di bit  per rappresentare  le super reti e gli host per aggregare 9 reti di classe C:

2^S ≥ numero di reti di classe C → 2^S ≥ 9 → S=4

N: 24-S = 24-4 = 20

H=8+(8-S) = 8+4 = 12 → 2^12 = 4096 ≥ 2053

4. Scriviamo la Supernet mask:

SM = 255.255.11110000.0 = 255.255.240.0

5. Supernet:

SM: 255.255.240.0

Supernet: 195.168.0.0/20

BC: 195.168.8.255/20

GW: 195.168.8.254/20

H: Da 195.168.1.0/20 a 195.168.8.253/20

# data[].attributes.body
Il VLSM consiste nella creazione di più sottoreti con lunghezza variabile

Es.

SR1=10 Host

SR2=50 Host

SR3=25 Host

IP=192.168.12.0

1. Per prima cosa identifichiamo la classe dell’indirizzo IP. In questo caso l’indirizzo è di classe C

2. Selezioniamo la sottorete con più host. In questo caso SR2 che deve contenere almeno 50 host

3. Ora bisogna determinare il numero di bit “H”per rappresentare 50 host, l’indirizzo di BC e il GW, e il valore di “S”
2^H2 - 3 ≥ 50 → 2^6 - 3 ≥ 50 → H2=6
S2 = 8 - H2 = 8 - 6 = 2

4. Troviamo la Subnet Mask:
SM2=255.255.255.11000000
SM2=255.255.255.192

5. Ora determiniamo gli indirizzi delle sottoreti
x.y.z.000...0 → 192.168.12.0/26
x.y.z.010...0 → 192.168.12.64/26
x.y.z.100...0 → 192.168.12.128/26
x.y.z.110...0 → 192.168.12.192/26

6. Scegliamo o la prima o l'ultima sottorete e scriviamo le caratteristiche
SR2 = 192.168.12.192/26
SM2 = 255.255.255.192
BC2 = 192.168.12.255/26
GW2 = 192.168.12.254/26
61 host da 192.168.12.193/26
a 192.168.12.253/26

7. Ora prendo la più numerosa tra le sottoreti rimaste
SR3: 25 Host

8. Ora Determiniamo il numero di bit di H3 e di S3
2^H3 - 3 ≥ 25 → 2^5- 3 ≥ 25 → H3 = 5
S3 = 8 - S2 - H3 = 8 - 2 - 5 = 1

9. Determinare SM
SM3 = 255.255.255.11100000/27
SM3 = 255.255.255.224/27

10. Determinare le sottoreti
x.y.z.11000000
x.y.z.11100000

11. Procediamo ripetendo il passaggio 6

12. Prendo la sottorete rimasta
S1 = 10 host

13. Numero di bit nella subnet e negli host
2^H1- 3 ≥ 10 → H1 = 4
Sa=8-S2-S3-H1=1

14. Determino la SM:
SM1=255.255.255.11110000→255.255.255.240

15. Determiniamo le sottoreti
x.y.z.10000...0
x.y.z.10010...0

16. Ripetiamo il passaggio 6

# data[].attributes.body
Il Subnetting è il procedimento che ci consente di suddividere una rete, dettata da un indirizzo IP in più sottoreti.

Dato l’indirizzo Ip 192.168.10.0, dobbiamo ricavare 4 sottoreti:

1.  Per prima cosa bisogna identificare la classe dell’indirizzo Ip che può essere:
Classe A
Classe B
Classe C
In questo caso il nostro indirizzo è di Classe C.

2.  Ora dobbiamo trovare il numero di bit per il Subnet-Id e Host-Id:
2^S ≥ 4  →  S=2 (bit di necessità)  →  2^2 = 4  →  4 ≥ 4
H = 8 - S → 8 - 2 = 6

In questo caso avremo 24 bit di Net-Id, 2 bit di Subnet-Id e 6 bit di Host-Id.
NNNNNNNN.NNNNNNNN.NNNNNNNN.SSHHHHHH

3.  Una volta fatto ciò, scriviamo la Subnet Mask:
NNNNNNNN.NNNNNNNN.NNNNNNNN.SSHHHHHH /26
11111111.11111111.11111111.11000000 /26
SM = 255.255.255.192 /26

4.  Ora calcoliamo le sottoreti:
x.y.z 00 000000 → 192.168.10.0 /26
x.y.z 01 000000 → 192.168.10.64 /26
x.y.z 10 000000 → 192.168.10.128 /26
x.y.z 11 000000 →  192.168.10.192 /26

5.  L’ultimo passaggio è l’assegnazione degli indirizzi:

Gateway (GW): Penultimo indirizzo dell’intervallo
Broadcast (BR): Ultimo indirizzo dell’intervallo
Sottorete (SR): Indirizzo Ip della sottorete
Subnet mask (SM): SM della sottorete

Sottorete 1

GW: 192.168.10.62 /26
BR: 192.168.10.63 /26
SR1: 192.168.10.0 /26
SM: 255.255.255.192 /26
Host: da 192.168.10.1/26 a 192.168.10.61/26

Sottorete 2

GW: 192.168.10.126 /26
BR: 192.168.10.127 /26
SR2: 192.168.10.64 /26
SM: 255.255.255.192 /26
Host: da 192.168.10.65/26 a 192.168.10.125/26

Sottorete 3

GW: 192.168.10.191 /26
BR: 192.168.10.190 /26
SR3: 192.168.10.128 /26
SM: 255.255.255.192 /26
Host: da 192.168.10.128/26 a 192.168.10.190/26

Sottorete 4
GW: 192.168.10.254 /26
BR: 192.168.10.255 /26
SR4: 192.168.10.192 /26
SM: 255.255.255.192 /26
Host: da 192.168.10.193/26 a 192.168.10.253/26

# data[].attributes.body
Rappresenta il controllo di errore e ricalcola da ogni nodo che elabora il datagramma

# data[].attributes.body
Indica qual è la posizione di questo frammento nel datagramma

# data[].attributes.body
Specifica il tipo di servizio richiesto, oltre a venire usato come indicatore di priorità

# data[].attributes.body
Contiene 4 bit impostati a un valore che indica la lunghezza dell’intestazione dei datagrammi

# data[].attributes.body
Utilizzo efficiente degli indirizzi IP (allocazione dinamica).

Eliminazione degli errori di configurazione.

# data[].attributes.body
Il pacchetto ARP è composto da 3 settori.

Header

Info

FCS (Frame Check Sequence)

# data[].attributes.body
Divide i segmenti in Frame(Trame) con ognuno un significato diverso. Identifica gli errori di trasmissione e regola la velocità di trasmissione dei DTE. Si occupa del collegamento con la rete e fornisce informazioni sul tipo di segnale usato per trasmette le informazioni e sul DTE mittente

# data[].attributes.body
Decide il canale di comunicazione tra i DTE coinvolti nella trasmissione dati. Può eseguire l'operazione di Routing(se non sono nella stessa LAN) e l'operazione di Internetworking (se sono su reti diverse)

# data[].attributes.body
Divide il messaggio in segmenti numerati e questi, una volta giunti al destinatario, vengono riordinati e uniti per ricomporre il messaggio. Questo livello può operare usando i protocolli TCP(Transmission Control Protocol) o UDP(User Datagram Protocol). Il primo invia i pacchetti numerati in ordine e, in caso vengano persi, invia al mittente un messaggio di richiesta di rinvio del messaggio. Il secondo, invece, instrada i singoli pacchetti numerati in percorsi diversi, perché non dispone dello stesso algoritmo del TCP, e non applica alcun algoritmo di controllo sui pacchetti. I pacchetti possono giungere a destinazione in ordine sparso.

# data[].attributes.body
Permette i dialoghi utente-macchina e macchina-utente.
Mantiene collegato l'utente alla rete.
Si occupa del criptaggio e del decriptaggio dei pacchetti.
Si occupa della gestione dei linguaggi dei pacchetti ricevuti o inviati. Mantiene attive le sessioni di lavoro tra 2 o più utenti e, in caso di errori imprevisti, le chiude.

# data[].attributes.body
La SupernetMask serve per raggruppare due o più reti in un' unica rete, è composta da una sequenza di bit posti a 1 in corrispondenza dei valori dedicati al net-id e al supernet-id, e posti a 0 per bit corrispondenti all’host-id,  poi convertiti in valori decimali separati da un punto

# data[].attributes.body
Il NAT sostituisce l'IP privato con un indirizzo pubblico per poter inoltrare il pacchetto sulla rete.
Traduzione Indirizzi IP

Statico, mappatura uno ad uno tra indirizzi interni ed esterni. L'indirizzo pubblico rimane sempre lo stesso.

Dinamico, corrispondenza tra indirizzo esterno ed interno definito all'occorrenza. Usa un nuovo indirizzo ogni volta.

# data[].attributes.body
La SubnetMask serve per dividere una rete in più sottoreti, è composta da una sequenza di bit posti a 1 in corrispondenza dei valori dedicati al net-id e al subnet-id, e posti a 0 per bit corrispondenti all’host-id,  poi convertiti in valori decimali separati da un punto.
Dato che le diverse classi di indirizzi IP hanno diversi NET-ID e HOST-ID, per ogni classe viene definita una SubnetMask di default:

CLASSE A: 255.0.0.0

CLASSE B: 255.255.0.0

CLASSE C: 255.255.255.0

# data[].attributes.body
(Bit significativo 110)

NET-ID: 24 bit (1^, 2^, 3^ byte) = 16’777’216 reti

HOST-ID: 8 bit (4^ byte) = 256 reti

# data[].attributes.body
(Bit significativi 10)

NET-ID: 16 bit (1^, 2^ byte) = 65’536 reti

HOST-ID: 16 bit (3^, 4^ byte) = 65’536 reti

# data[].attributes.body
(Bit significativo 0)

NET-ID: 8 bit (1^byte) = 256 reti

HOST-ID: 24 bit (2^, 3^, 4^ byte) = 16’777’216 reti

# data[].attributes.body
Gli indirizzi sono classificati in tre classi differenti. Per identificare una classe è necessario convertire in binario il primo ottetto dell'indirizzo e controllare il valore del bit significativo

# data[].attributes.body
Nelle reti TCP/IP a ogni host deve essere assegnato un’indirizzo IP; quest’ultimo, composto da 32 bit (4 byte/ottetti), viene espresso scrivendo i valori decimali di ciascun byte/ottetti da 0 a 255 separati da un punto. Il protocollo IP fornisce l’instradamento dei pacchetti in rete fra i diversi host.
Ogni indirizzo è diviso in NET-ID e HOST-ID che, in base alla classe, corrispondono a degli ottetti

# data[].attributes.body
L' ARP si occupa della traduzione degli inidirizzi IP in indirizzi fisici.

Verifica di corrispondenza tra IP e fisico nella cache ARP (tabella che contiene Indirizzo IP e MAC Address).

Se non c'è corrispondenza, il mittente invia ARP request.

Ogni Host controlla il proprio indirizzo IP e se corrisponde invia un ARP reply.

# data[].attributes.headline
DHCP (Dinamic Host Configuration Protocol)

# data[].attributes.subject
DHCP (Dinamic Host Configuration Protocol)

# data[].attributes.body
Il DHCP è un server utilizzato per l'assegnazione di indirizzi IP in modo automatico.
Come funziona

Il PC invia una richiesta ai server DHCP.

Un DHCP risponde all'host con una proposta di IP.

Il PC accetta l'offerta e riceve la configurazione dal DHCP.

Il server invia il messaggio per completare la configurazione.

# data[].attributes.body
E' un protocollo di rete su cui è basato il funzionamento della rete internet, è un protocollo di interconnessione di reti. Il suo compito è l'imbustamento tra sottoreti.

# data[].attributes.headline
Indirizzi IP (classi + Subnetting + Supernetting Mask)

# data[].attributes.subject
Indirizzi IP (classi + Subnetting + Supernetting Mask)

# data[].attributes.body
L'incapsulamento è una serie di operazioni eseguite dai livelli(Pila TCP/IP) in spedizione.
Ogni livello aggiunge informazioni utili per l'invio del messaggio per poi spedirle al livello sottostante, è un po' come se ad ogni livello arrivasse una busta con i dati del livello soprastante.

Il messaggio viene suddiviso in pacchetti ed ognuno di loro segue un percorso attraverso i livelli della Pila TCP/IP:

-Il livello Applicazione aggiunge un Header-APP ai dati utente per poi passarlo al livello sottostante.
-Il livello Trasporto aggiunge un nuovo Header-TCP rendendo tutto il resto il Payload, ora l'unità di dati prende il nome di segmento TCP, per poi passare il tutto al livello sottostante.
-Il livello Internet aggiunge un nuovo Header-IP rendendo tutto il resto il Payload, ora l'unità di dati prende il nome di Datagram IP, per poi passare il tutto al livello sottostante.
-Il livello Rete-Host aggiunge un Header-ETH(Frame Ethernet) ed anche un Trailer-FCS(Frame Check Sequence) rendendo tutto il resto il Payload,