Home
Accesso / Registrazione
 di 

Ethernet 7/7

Ethernet  tutorial checksum

Checksum

Il checksum è un metodo per controllare l'integrità di un pacchetto, ovvero permette di stabilire se questo contiene errori (ed è quindi inutilizzabile).
Di per sé, la parola checksum non identifica un particolare algoritmo, ma quello utilizzato per IP ed altri proptocolli è
il complemento a 1 della somma dei complementi a 1 delle parole a 16bit dei dati su cui effettuare il calcolo; ovvero, si sommano tutte le parole a 16bit, sommando anche l'eventuale overflow ed infine si esegue il complemento a 1.

Prima è stato illustrato come il checksum, in fase di invio, venga calcolato e poi scritto nel pacchetto; ciò che non è ancora stato illustrato è il controllo del checksum all'arrivo di un pacchetto. Per verificare che il pacchetto sia integro, bisognerebbe salvare temporaneamente il campo checksum del pacchetto e mettere zero al suo posto, poi si esegue il calcolo e si confronta il risultato con quello salvato; se sono uguali, ovviamente, il pacchetto è corretto.

In realtà , per come è fatto l'algoritmo, la verifica è molto più semplice: infatti basta calcolare il checksum sul pacchetto senza modificarlo in alcun modo; se il risultato è zero, allora il pacchetto è OK, altrimenti è da scartare.

L'ENC28J60 integra, nel modulo DMA, una funzione abbastanza rapida per il calcolo del checksum, ed è ciò che utilizzeremo. Sfortunatamente, pero, nella revisione B5 del chip, tale funzione da dei grossi problemi alla ricezione dei pacchetti, quindi in questo caso il calcolo verrà eseguito via software.

Innanzitutto vediamo il prototipo della funzione DMAChecksum:

u16 DMAChecksum(u16 start, u16 len, BOOL rx)

il primo parametro indica l'indirizzo al quale iniziano i dati, len la lunghezza in byte di questi dati, infine rx serve ad indicare se l'indirizzo si riferisce alla memoria RX o TX. (L'indirizzo è un offset relativo, rispetto all'inizio del campo dati del pacchetto MAC)

Come dicevo prima, questo metodo ha due diverse implementazioni per le revisioni B1-B4 e B5, vediamo la prima:

u16 DMAChecksum(u16 start, u16 len, BOOL rx){
	// calcola il checksum utilizzando l'apposita funzione del chip
	u16 tmp;
	u8 L,H;
	if (rx) {
		tmp = TX_BUF_START + 1 + sizeof(MAC_Header) + start;
	} else {
		tmp = packetStart + 6 + sizeof(MAC_Header) + start;
		if (tmp > RX_BUF_END)
			tmp = tmp - RX_BUF_END + RX_BUF_START - 1;
	}

	setBank(0);
	writeReg(EDMASTL, LOW(tmp));
	writeReg(EDMASTH, HIGH(tmp));
	
	tmp = tmp+len-1; 			// fine pacchetto
	if (!rx && tmp > RX_BUF_END)
		tmp = tmp - RX_BUF_END + RX_BUF_START - 1;
	writeReg(EDMANDL, LOW(tmp));
	writeReg(EDMANDH, HIGH(tmp));
	
	BFSReg(ECON1, 0b00110000);      	// inizio calcolo
	while(readETH(ECON1) & 0b00100000);	// attende fine calcolo
	tmp = (u16)readETH(EDMACSL) << 8;
	tmp = tmp | readETH(EDMACSH);
	return tmp;				// ritorna il checksum calcolato
}

Prima di tutto, vengono calcolati e scritti negli appositi registri gli indirizzi assoluti di inizio e fine
dei dati su cui effettuare l'operazione. Poi viene avviato il calcono e se ne attende il termine.

Nel secondo caso, si esegue il calcolo via software, il che rende l'operazione molto più lenta:

u16 DMAChecksum(u16 start, u16 len, BOOL rx){
		// calcola il checksum via software
	u16	tmp;
	u16 reg[2];
	u32 sum;
	u16 len2;
	int i;

	if (rx) {
    	tmp = TX_BUF_START + 1 + sizeof(MAC_Header) + start;
	} else {
		tmp = packetStart + 6 + sizeof(MAC_Header) + start;
		if (tmp > RX_BUF_END)
			tmp = tmp - RX_BUF_END + RX_BUF_START - 1;
	}

	// salva ERDPT
	setBank(0);
	reg[0] = readETH(ERDPTL);
	reg[1] = readETH(ERDPTH);

	writeReg(ERDPTL,LOW(tmp));
	writeReg(ERDPTH,HIGH(tmp));

	sum = 0;
	len2 = len & 0xFE;
	CS = 0;
	spiWrite(RBM);
	for (i=0; i<len2; i=i+2){
		tmp = ((u16)spiRead()) << 8 | spiRead();
		sum = sum + (u32) tmp;	
	}
	if (len2!=len) sum += ((u32)spiRead()) << 8; 		// se il pacchetto ha lunghezza dispari
	CS = 1;
	
	while (sum >> 16)
	  sum = (sum & 0xFFFF) + (sum >>  16);

	tmp = ~sum;

	// ripristina ERDPT;
	setBank(0);
	writeReg(ERDPTL,reg[0]);
	writeReg(ERDPTH,reg[1]);

	return htons(tmp);					// ritorna il checksum calcolato
}

Prima di effettuare l'operazione, viene salvato il registro ERDPT (ripristinato alla fine), perché¨ verranno letti tutti i byte necessari al calcolo.

Vediamo anche il metodo putChecksum utilizzato in precedenza:

void putChecksum(u16 offset, u16 sum){
	// scrive il checksum "sum" all'indirizzo "offset" all'interno del buffer di scrittura
	u16 tmp;
	u16 addr[2];
	setBank(0);		
	addr[0] = readETH(EWRPTL);			// salva temporaneamente il puntatore
	addr[1] = readETH(EWRPTH);			// di scrittura
	tmp = 1+sizeof(MAC_Header)+offset;		// nuovo indirizzo
	writeReg(EWRPTL,LOW(TX_BUF_START+tmp));
	writeReg(EWRPTH,HIGH(TX_BUF_START+tmp));	// carica il puntatore
	encPut(LOW(sum));
	encPut(HIGH(sum));      			// scrive il checksum
	writeReg(EWRPTL,addr[0]);
	writeReg(EWRPTH,addr[1]);			// ripristina il vecchio puntatore	
}

ICMP
L'ICMP è un protocollo di servizio (descritto dalla RFC 792), utilizzato per effettuare controlli e segnalazioni all'interno
di una rete. Un pacchetto ICMP può trasportare diversi tipi di messaggi, ma quello più conosciuto e l'unico trattato qui, è la richiesta di Echo, conosciuto anche come Ping.
Nel modello ISO/OSI questo protocollo viene solitamente inserito al terzo livello, non essendo propriamente un protocollo di trasporto,
ma si trova comunque al di sopra del protocollo IP all'interno del quale viene incapsulato.

Struttura del pacchetto
La struttura di un pacchetto ICMP varia a seconda del messaggio trasportato, salvo un'intestazione comune a tutti i tipi.
Vediamo il caso particolare di una richiesta di eco:

ICMP

- Type: assume il valore 8 per la richiesta, mentre nel pacchetto di risposta vale 0.
- Code: inutilizzato.
- Checksum: L'ormai noto campo di controllo. L'algoritmo utilizzato è lo stesso del protocollo IP.
- Identifier e Sequence Number: vengono generati dal richiedente per riconoscere la risposta. Vengono lasciati inalterati da chi risponde.
- Data: contiene un numero variabile di dati che vengono restituiti tali e quali nella risposta.

Il codice
Prima di tutto vediamo il contenuto del file icmp.h il quale contiene alcune define, ma soprattutto
la definizione del pacchetto ICMP.

#define ICMP_ECHO		8
#define ICMP_ECHO_REPLY		0
#define MAX_ICMP_DATA 		32  	// dimensione massima del campo dati

typedef struct {
	u8	type;
	u8	code;
	u16	checksum;
	u16	id;
	u16	sn;
	u8	data[MAX_ICMP_DATA];
} ICMPPacket;

void processICMP(IP_Header ipHeader);

Come si può vedere sono presenti i vari campi descritti nel paragrafo precedente.

Il file icmp.c contiene il codice che permette di rispondere ad un ping.

#include "stack.h"

#define ICMP_Offset	sizeof(IP_Header)

void processICMP(IP_Header ipHeader){
	ICMPPacket	packet;
	u8 size;

	size = ipHeader.totalLength - (ipHeader.verlen & 0x0F)*4;
	if (size > sizeof(packet)) size = sizeof(packet);
	encGetArray((u8*)&packet, size);
	
	if (packet.type == ICMP_ECHO){
		packet.type = ICMP_ECHO_REPLY;
		packet.checksum = 0;
		IPPutHeader(ipHeader.sourceIP, IPPROTO_ICMP, (u8*)&packet, size, size);
		putChecksum(ICMP_Offset+2,DMAChecksum(ICMP_Offset,size,TRUE));
		MACSend();
	}	
}

Attraverso il metodo encGetArray il pacchetto viene letto e salvato nella variabile packet. Poi, una volta
esaminato il campo type, se questo risulta essere una richiesta di eco, viene costruito il pacchetto di risposta:
il campo type viene settato a 0 (Echo Reply), il checksum azzerato e ricalcolato una volta che il pacchetto
viene scritto nel buffer; infine si invia il tutto con MACSend.

ProcessPacket
Perchè tutto funzioni, bisogna implementare un metodo che esamini i pacchetti in arrivo
e li mandi ai relativi gestori (IP e ARP per il terzo livello).
Questo metodo è processPacket ed è richiamato all'interno di un loop infinito nel metodo main:

void main() {
	encInit();
	
	while (1)
		processPacket();	
}

Vediamo il file stack.c

#include "stack.h"

MACAddr	remoteAddr;

void processPacket(){
	MAC_Header header;
	setBank(1);
	while (readETH(EPKTCNT)) { // se c'è almeno un pacchetto

		MACGetHeader(&header);
		if (header.type == TYPE_IP){
			remoteAddr = header.sourceMAC;
			processIP();
		} else
		if (header.type == TYPE_ARP)
			processARP();

		freeRxSpace();  // libera lo spazio nel buffer RX
	}
}

Leggendo il registro EPKCNT verifichiamo che ci sia almeno un pacchetto in attesa di essere letto, poi con MACGetHeader viene
letta l'intestazione MAC ed attraverso il campo type viene scelto se chiamare processIP o proccessARP (o anche nessuno dei due).
Questi metodi sono stati già trattati nelle pagine precedenti.

 

 

Scrivi un commento all'articolo esprimendo la tua opinione sul tema, chiedendo eventuali spiegazioni e/o approfondimenti e contribuendo allo sviluppo dell'argomento proposto. Verranno accettati solo commenti a tema con l'argomento dell'articolo stesso. Commenti NON a tema dovranno essere necessariamente inseriti nel Forum creando un "nuovo argomento di discussione". Per commentare devi accedere al Blog

 

 

Login   
 Twitter Facebook LinkedIn Youtube Google RSS

Ultimi Commenti