2. Procedure HOST-HOST
2.1 Generalità
L'idea di base è che diversi utenti, su un dato HOST, possano simultaneamente utilizzare la rete condividendo in time-sharing le sue risorse fisiche.
Ciò implica che all'interno di ogni sistema operativo HOST debba esistere un programma speciale che multiplexa i messaggi in uscita dagli utenti verso la rete e distribuisce i messaggi in entrata agli utenti appropriati. Chiameremo questo programma speciale programma Network.
2.2 Collegamenti e connessioni (vedi figura 1)
2.2.1 Definizioni
È conveniente considerare la rete come una scatola nera - un sistema il cui comportamento è noto ma i cui meccanismi non lo sono - per comunicare messaggi tra utenti remoti piuttosto che tra coppie di elaboratori HOST.
(a) Connessioni logiche
Definiamo connessione logica un percorso di comunicazione che collega due utenti presso HOST[s] remoti.
Con questo concetto, un utente (programma utente) in un elaboratore HOST può (1) stabilire diverse connessioni logiche verso qualsiasi utente di HOST remoti e (2) inviare o ricevere messaggi su tali connessioni.
Le connessioni appaiono agli utenti come duplex integrale.
Uno degli scopi del programma Network è servire gli utenti nello stabilire, identificare e mantenere queste connessioni.
(b) Collegamenti logici
Ogni connessione logica è costituita da una coppia di collegamenti direzionali: uno per trasmettere, l'altro per ricevere.
Tali collegamenti, detti collegamenti logici, sono stabiliti dai programmi Network e da essi utilizzati.
Si noti qui che gli utenti sono interessati solo alle connessioni e non sono affatto consapevoli dei collegamenti. Le relazioni tra collegamenti e connessioni sono gestite dal programma Network.
Uno dei vantaggi di definire una connessione come coppia di collegamenti direzionali è che un HOST avrà la capacità di richiudersi su se stesso attraverso il proprio IMP (apre una connessione verso se stesso). Questa caratteristica può essere utile a fini di debug.
Nel seguito di questo documento non useremo più l'attributo logico riferendoci a collegamenti o connessioni.
2.2.2 Tipi di connessione
Per raggiungere un'elevata flessibilità nell'utilizzo della rete è vantaggioso classificare le connessioni.
Si distinguono tre tipi di connessioni: (a) connessione di controllo, (b) connessione primaria e (c) connessione ausiliaria.
(a) Connessione di controllo
Questa connessione ha uno stato speciale ed è unica tra una coppia di HOST[s], ad esempio, se la rete comprende x HOST[s], vi sono al massimo x connessioni di controllo originate da un HOST.
Questa connessione è utilizzata dai programmi Network remoti per scambiarsi messaggi di controllo. I messaggi di controllo sono fondamentali per l'istituzione/eliminazione delle connessioni standard. (vedi 2.4.2)
Si noti qui che questa connessione di controllo è l'unica connessione che non è utilizzata dagli utenti dell'HOST.
Descriviamo ora le connessioni standard.
(b) Connessione primaria
Queste connessioni collegano utenti remoti.
Una connessione primaria:
- È unica tra una coppia di utenti ed è la prima a essere stabilita.
- È "simile a un telescrivente", cioè:
- vengono trasmessi caratteri ASCII;
- gli echi sono generati dall'HOST remoto;
- gli HOST[s] riceventi cercano i caratteri di interruzione;
- la velocità di trasmissione è bassa (meno di 20 caratteri/sec).
- È utilizzata principalmente per trasmettere comandi di controllo, ad esempio per il log-in in un sistema operativo HOST remoto.
(c) Connessione ausiliaria
Anche queste connessioni collegano utenti remoti:
Una connessione ausiliaria:
- È aperta parallelamente a una connessione primaria e non è unica, cioè tra gli utenti possono essere stabilite diverse connessioni ausiliarie.
- È utilizzata per trasmettere grandi volumi di dati (orientata ai file).
- È utilizzata sia per la trasmissione binaria sia per quella di caratteri.
[Figura 1 - Collegamenti e connessioni - vedi file PDF]
2.3 Struttura del messaggio
Gli HOST[s] comunicano tra loro tramite messaggi. Un messaggio può variare in lunghezza fino a 8095 bit (vedi più sotto la struttura). Le trasmissioni più grandi devono quindi essere suddivise dagli utenti dell'HOST in una sequenza di tali messaggi.
La struttura di un messaggio è illustrata nella figura 2.
Essa comprende quanto segue:
(1) Un'intestazione (32 bit): tipo di messaggio, HOST di origine/destinazione, numero di collegamento. (vedi rapporto BBN n. 1822, pp. 13, 17)
(2) Una marcatura (32 bit quando inviata dal Sigma 7) per iniziare un testo di messaggio su un confine di parola. (vedi rapporto BBN n. 1822, pp. 17, 19)
(3) Il testo del messaggio (max: 8015 bit per il Sigma 7). Esso consiste principalmente nel testo dell'utente. Tuttavia può rappresentare informazioni destinate all'uso dei programmi Network. (Messaggi di controllo, vedi 2.4.2)
(4) Un checksum (16 bit). Il suo scopo è verificare, a livello HOST, la corretta trasmissione di un messaggio. (Cambiamenti nel pattern di bit o trasposizione di pacchetti; i pacchetti sono definiti nel rapporto BBN n. 1763, p. 13) vedi più sotto per il calcolo del checksum.
(5) Un riempimento per risolvere i problemi di disallineamento della lunghezza delle parole. (vedi rapporto BBN n. 1822, p. 17, 19.). Per quanto riguarda il software, il riempimento interviene solo alla ricezione del messaggio per delimitare la fine del messaggio. (In trasmissione l'hardware si occupa del riempimento.)
Osservazione:
Calcolo del checksum:
Gli ultimi 16 bit di ogni messaggio inviato da un HOST sono un checksum. Questo checksum è calcolato sull'intero messaggio, inclusa ogni marcatura, ma escludendo l'intestazione di 32 bit e ogni riempimento. Per calcolare il checksum:
- Si consideri il messaggio riempito con zeri fino a una lunghezza di 8640 bit.
- Si suddividano gli 8640 bit in sei segmenti da 1440 bit, S0, S1...S5.
- Si suddivida ciascun segmento S da 1440 bit in 90 elementi da 16 bit, T0, T1...T89.
- Si definisca una funzione [(+)], che prende in ingresso due elementi da 16 bit e restituisce in uscita un elemento da 16 bit. Questa funzione è definita da
Tm [(+)] Tn = Tm [(+)] Tn, se Tm + Tn < 2[exp 16]
Tm [(+)] Tn = Tm [(+)] Tn - 2[exp 16] + 1, se Tm + Tn >= 2[exp 16]
- Per ogni segmento Si da 1440 bit si calcoli Ci = K(Si), dove
K(S) = T0 [(+)] T1 + ..... T89
- Si calcoli C = C0[(+)]C1[(+)]C1[(+)]C2[(+)]C2[(+)]C2[(+)]C2....[(+)]C5
(Si noti che C1[(+)]C1 è semplicemente C1 ruotato a sinistra di un bit)
Il numero C è il checksum. Il motivo per cui i Ci sono ruotati di i bit è rilevare la trasposizione dei pacchetti.
[Figura 2 - Formato di un messaggio inviato dal Sigma 7 - vedi file PDF]
2.4 Transazioni utente
Da quanto discusso finora, la rete appare all'utente come un insieme di connessioni. Spieghiamo ora come si può fare uso di queste connessioni.
Innanzitutto descriveremo l'insieme delle transazioni a cui un utente dovrebbe poter accedere per utilizzare le funzionalità delle connessioni.
Poi spiegheremo il ruolo del programma Network nell'esecuzione di queste transazioni. Ciò coprirà un protocollo HOST-HOST in cui i messaggi di controllo sono scambiati tra programmi di rete.
A scopo esplicativo tali transazioni sono rappresentate, a livello utente, sotto forma di chiamate a subroutine e parametri. Tuttavia ciò non implica affatto che l'implementazione seguirà da vicino questo schema. (Qui ci occupiamo più dell'aspetto descrittivo che di quello implementativo, vedi capitolo 3.)
2.4.1 Elenco delle transazioni
Di seguito sono riportate le descrizioni delle subroutine che potrebbero essere a disposizione dell'utente per creare/chiudere connessioni e trasmettere/ricevere dati su di esse. Questo insieme di subroutine può essere considerato una sorta di interfaccia tra il livello utente e il livello del programma di rete.
(a) Aprire una connessione primaria:
OPENPRIM (CONNECTID, HOSTID, BUFFADDR, [OPT]) CONNECTID: identificazione della connessione # HOSTID: identificazione dell'HOST remoto # BUFFADDR: indirizzo del buffer per i messaggi in entrata. OPT: opzioni quali messaggio richiesto dopo l'avvenuta istituzione della connessione, "full echo" (ogni messaggio è ritrasmesso dall'HOST remoto a scopo di verifica), ecc.
Osservazione: [ ] significa opzionale
(b) Aprire una connessione ausiliaria
OPENAUX (CONNECTID, BUFFADDR, N, [OPT]) CONNECTID: identificazione della connessione #, cioè l'identificazione della connessione primaria corrispondente (dapprima un utente deve aprire una connessione primaria). BUFFADDR: stesso significato di cui sopra. N: numero di connessioni ausiliarie che dovrebbero essere aperte. OPT: stesso significato di cui sopra.
(c) Trasmissione su connessione
TRANSM (CONNECTID, NO, BUFFADDR, N, [OPT]) CONNECTID: identificazione della connessione # NO: connessione #. La connessione primaria è sempre indicata come NO=0. Il numero di una connessione ausiliaria corrisponde all'ordine in cui è stata stabilita. (La prima ausiliaria aperta è indicata con NO=1, la seconda con NO=2, ecc.) BUFFADDR: indirizzo del buffer del messaggio da trasmettere. N: dimensione del messaggio (numero di byte) OPT: opzioni quali il tipo di dati (caratteri vs. binario), il bit di traccia, ecc.
(d) Chiudere una connessione
CLOSE (CONNECTID, [N], [NO]) CONNECTID: identificazione della connessione #. N: numero di connessioni da chiudere. Se omesso, tutte le connessioni in uso dall'utente, incluso il collegamento primario, sono chiuse. NO: nel caso di N diverso da zero, questo numero indica la connessione ausiliaria # da chiudere.
2.4.2 Protocollo HOST-HOST e messaggi di controllo
Il protocollo HOST-HOST è realizzato dai programmi Network. Esso comporta principalmente l'esecuzione delle transazioni precedenti (avviate dagli utenti) e comprende un dialogo HOST-HOST.
Questo dialogo assolve le procedure di controllo per aprire o chiudere connessioni e consiste nello scambio di messaggi di controllo sul collegamento di controllo. Un messaggio di controllo ha una struttura identica a quella di un messaggio normale; differisce da esso solo per il testo, che è destinato all'uso dei programmi Network invece che degli utenti.
Insistiamo sul fatto che questa procedura di controllo è completamente estranea alle procedure di controllo della trasmissione implementate negli elaboratori IMP. Qui siamo a livello HOST (programmi Network) e quindi i messaggi di controllo, che saranno descritti di seguito, sono trasmessi attraverso gli IMP[s] come messaggi normali.
Si considerino ora le transazioni precedenti e si descriva, per ciascuna di esse, quali messaggi sono scambiati su quali collegamenti. Ogni caso sarà spiegato mediante esempi banali.
Supponiamo che un utente di HOST(x) voglia accedere a un programma dell'HOST(y) remoto chiamato URSA.
(a) Aprire una connessione primaria: (OPENPRIM)
Il programma Network dell'HOST (x), risvegliato (vedi 3.3) da un utente per aprire una connessione primaria, avvia un dialogo con il programma Network dell'HOST (y).
(i) HOST(x) invia il seguente messaggio di controllo:
HOST(x) Control link HOST(y)
-------------------->
ENQ PRIM 0 1 2
ENQ: richiesta di istituzione della connessione (un carattere ASCII) PRIM: tipo di connessione: primaria (un carattere speciale) 0 1 2: collegamento in uscita #. È un numero decimale (3 caratteri ASCII), ad esempio il collegamento #12.
Questo collegamento # è stato determinato dal programma Network dell'HOST(x) (vedi implementazione: 3.3)
(ii) HOST(y) risponde inviando indietro il seguente messaggio di controllo:
HOST(x) Control link HOST(y)
<------------------------
ACK ENQ PRIM 0 1 2 0 1 5
ACK: riscontro positivo (un carattere ASCII) ENQ PRIM 0 1 2: stesso significato di cui sopra. Questa parte del messaggio è restituita a scopo di verifica. 0 1 5: collegamento in entrata #. Segue lo stesso schema del collegamento in uscita #. Questo collegamento # è stato determinato dal programma Network dell'HOST(y).
Ora la connessione è stabilita; userà i collegamenti #12 e 15 per scambiare messaggi utente. Si dice che la connessione è in uno stato di pre-log-in, cioè l'HOST(y) remoto si aspetta le sue procedure di log-in standard.
(b) Trasmissione sulla connessione primaria: (TRANSM)
Per mezzo di subroutine TRANSM riferite alla connessione primaria, l'utente di HOST(x) è in grado di effettuare il sign-in nel sistema operativo dell'HOST(y) e quindi di richiamare il programma URSA (programma utente dell'HOST(y)).
I programmi Network a entrambe le estremità useranno i collegamenti #12 e #15 per inoltrare i messaggi. Questi messaggi sono messaggi standard il cui contenuto serve per la sequenza di log in.
Un esempio banale potrebbe essere:
HOST(x) Prim. Link #12 HOST(y)
---------------------------->
! S I G N - I N : X X
HOST(x) Prim. Link #15 HOST(y)
<--------------------------
! ! R E A D Y
HOST(x) Prim. Link #12 HOST(y)
---------------------------->
! U R S A
(c) Aprire una connessione ausiliaria: (OPENAUXI)
In modo molto simile a (a), una connessione ausiliaria è stabilita tra HOST(x) e HOST(y). A tal fine, i messaggi di controllo sono scambiati sul collegamento di controllo.
HOST(x) Control link HOST(y)
------------------------------>
ENQ AUX 0 2 5
HOST(x) Control link HOST(y)
<--------------------------------
ACK ENQ AUX 0 2 5 0 2 1
Ora la connessione ausiliaria è stabilita; userà i collegamenti #25 e 21 per scambiare messaggi standard.
(d) Trasmissione sulla connessione ausiliaria: (TRANSM)
Per mezzo di subroutine TRANSM riferite alla connessione ausiliaria, gli utenti a entrambe le estremità possono scambiare dati:
HOST(x) Aux. Link #25 HOST(y)
-------------------------------->
X X ..... X X
HOST(x) Aux. Link #21 HOST(y)
<--------------------------------
X ......... X
ecc.......
(e) Chiudere le connessioni: (CLOSE)
Ciò è realizzato in modo simile a (a). L'utente chiama una subroutine CLOSE e quindi i programmi Network a entrambe le estremità scambiano messaggi di controllo.
HOST(x) Control Link HOST(y)
----------------------------->
EOT 0 0 1 0 1 2
EOT: fine della trasmissione (un carattere ASCII) 0 0 1 : numero di connessioni da chiudere (3 caratteri ASCII decimali) 0 1 2 : collegamento in uscita # da chiudere.
Poi HOST(y) risponde come in (a).
HOST(x) Control Link HOST(y)
<-----------------------------
ACK EOT 0 0 1 0 1 2 0 1 5
Osservazione 1 - In (a), (c) ed (e) HOST(y) può rispondere con un messaggio che include un carattere di riscontro negativo NAK invece di ACK. Ciò per molte e varie ragioni, quali: sequenza errata, connessione già aperta e così via. Il messaggio potrebbe essere NAK IND, dove IND è un carattere alfanumerico che indica, in forma codificata, perché il blocco precedente è stato rifiutato. Ricevendo tali riscontri, HOST(x) ripeterà il suo messaggio finché HOST(y) non lo accetta. Una procedura di emergenza avrà luogo se si verificano troppi "messaggi NAK" consecutivi.
Osservazione 2 - In ciascuna delle illustrazioni precedenti (frecce) è rappresentato solo il testo del messaggio. In realtà, su questi collegamenti sono scambiati messaggi completi (con intestazione, marcatura, riempimento...).